curioustorvald/Terrarum
1
0
Fork 0
mirror of https://github.com/curioustorvald/Terrarum.git synced 2026-03-07 20:31:51 +09:00
Code Issues Packages Projects Releases Wiki Activity

shader cleanup; a config key for higher bits per pixel on graphics

Browse Source
This commit is contained in:
minjaesong
2022-03-25 15:49:43 +09:00
parent af542e43a9
commit 327e000a54
17 changed files with 39 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/net/torvald/terrarum/App.java
View File

@@ -19,7 +19,6 @@ import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.GdxRuntimeException;
import com.badlogic.gdx.utils.JsonValue;
import com.github.strikerx3.jxinput.XInputDevice;
import net.torvald.gdx.graphics.PixmapIO2;
import net.torvald.getcpuname.GetCpuName;
import net.torvald.terrarum.controller.GdxControllerAdapter;
import net.torvald.terrarum.controller.TerrarumController;
@@ -439,14 +438,16 @@ public class App implements ApplicationListener {
ditherPatterns[i] = t;
}
shaderBayerSkyboxFill = loadShaderFromClasspath("shaders/4096.vert", "shaders/4096_bayer_skyboxfill.frag");
shaderHicolour = loadShaderFromClasspath("shaders/4096.vert", "shaders/hicolour.frag");
shaderDebugDiff = loadShaderFromClasspath("shaders/4096.vert", "shaders/diff.frag");
shaderBayerSkyboxFill = loadShaderFromClasspath("shaders/default.vert",
"shaders/float_to_disp_dither_static.frag"
);
shaderHicolour = loadShaderFromClasspath("shaders/default.vert", "shaders/hicolour.frag");
shaderDebugDiff = loadShaderFromClasspath("shaders/default.vert", "shaders/diff.frag");
shaderPassthruRGBA = SpriteBatch.createDefaultShader();
shaderDitherRGBA = loadShaderFromClasspath("shaders/4096.vert", "shaders/4096_bayer.frag"); // always load the shader regardless of config because the config may cange
shaderColLUT = loadShaderFromClasspath("shaders/4096.vert", "shaders/passthrurgb.frag");
shaderReflect = loadShaderFromClasspath("shaders/4096.vert", "shaders/reflect.frag");
shaderGhastlyWhite = loadShaderFromClasspath("shaders/4096.vert", "shaders/ghastlywhite.frag");
shaderDitherRGBA = loadShaderFromClasspath("shaders/default.vert", "shaders/float_to_disp_dither.frag"); // always load the shader regardless of config because the config may cange
shaderColLUT = loadShaderFromClasspath("shaders/default.vert", "shaders/passthrurgb.frag");
shaderReflect = loadShaderFromClasspath("shaders/default.vert", "shaders/reflect.frag");
shaderGhastlyWhite = loadShaderFromClasspath("shaders/default.vert", "shaders/ghastlywhite.frag");
fullscreenQuad = new Mesh(
true, 4, 6,

2
src/net/torvald/terrarum/ColorLimiterTest.kt
View File

@@ -38,7 +38,7 @@ object ColorLimiterTest : ApplicationAdapter() {
override fun create() {
ShaderProgram.pedantic = false
shader4096 = ShaderProgram(Gdx.files.internal("assets/shaders/4096.vert"), Gdx.files.internal("assets/shaders/4096_bayer.frag"))
shader4096 = ShaderProgram(Gdx.files.internal("assets/shaders/default.vert"), Gdx.files.internal("assets/shaders/float_to_disp_dither.frag"))
shader4096.bind()
shader4096.setUniformf("rcount", 4f)
shader4096.setUniformf("gcount", 4f)

1
src/net/torvald/terrarum/DefaultConfig.kt
View File

@@ -11,6 +11,7 @@ object DefaultConfig {
val hashMap = hashMapOf<String, Any>(
"displayfps" to 0, // 0: no limit, non-zero: limit
"displaycolourdepth" to 8,
"usevsync" to false,
"screenwidth" to TerrarumScreenSize.defaultW,
"screenheight" to TerrarumScreenSize.defaultH,

2
src/net/torvald/terrarum/GlslTilingTest.kt
View File

@@ -47,7 +47,7 @@ object GlslTilingTest : ApplicationAdapter() {
override fun create() {
ShaderProgram.pedantic = false
shader = ShaderProgram(Gdx.files.internal("assets/shaders/4096.vert"), Gdx.files.internal("assets/shaders/tiling.frag"))
shader = ShaderProgram(Gdx.files.internal("assets/shaders/default.vert"), Gdx.files.internal("assets/shaders/tiling.frag"))
font = TerrarumSansBitmap("assets/graphics/fonts/terrarum-sans-bitmap", flipY = false)

9
src/net/torvald/terrarum/PostProcessor.kt
View File

@@ -41,6 +41,14 @@ object PostProcessor : Disposable {
private val functionRowHelper = Texture(Gdx.files.internal("assets/graphics/function_row_help.png"))
private val shaderQuant = mapOf(
8 to 255f,
10 to 1023f,
12 to 4095f,
14 to 16383f,
15 to 32767f,
16 to 65535f
)
init {
App.disposables.add(this)
@@ -139,6 +147,7 @@ object PostProcessor : Disposable {
App.shaderDitherRGBA.setUniformi("u_texture", 0)
App.shaderDitherRGBA.setUniformi("rnd", rng.nextInt(8192), rng.nextInt(8192))
App.shaderDitherRGBA.setUniformi("u_pattern", 1)
App.shaderDitherRGBA.setUniformf("quant", shaderQuant[App.getConfigInt("displaycolourdepth")] ?: 255f)
App.fullscreenQuad.render(App.shaderDitherRGBA, GL20.GL_TRIANGLES)
}
else {

2
src/net/torvald/terrarum/ShitOnGlsl.kt
View File

@@ -39,7 +39,7 @@ object ShitOnGlsl : ApplicationAdapter() {
override fun create() {
ShaderProgram.pedantic = false
shader = ShaderProgram(Gdx.files.internal("assets/shaders/4096.vert"), Gdx.files.internal("assets/shaders/crt.frag"))
shader = ShaderProgram(Gdx.files.internal("assets/shaders/default.vert"), Gdx.files.internal("assets/shaders/crt.frag"))
font = TerrarumSansBitmap("assets/graphics/fonts/terrarum-sans-bitmap", flipY = false)

14
src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt
View File

@@ -115,21 +115,17 @@ object IngameRenderer : Disposable {
// these codes will run regardless of the invocation of the "initialise()" function
// the "initialise()" function will also be called
init {
// shaderBlurDither = App.loadShaderFromClasspath("shaders/blur.vert", "shaders/blur_dither.frag")
// shaderRGBOnlyDither = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/4096_bayer_rgb1.frag")
// shaderAtoGreyDither = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/4096_bayer_aaa1.frag")
shaderBlur = App.loadShaderFromClasspath("shaders/blur.vert", "shaders/blur.frag")
shaderRGBOnly = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/rgbonly.frag")
shaderAtoGrey = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/aonly.frag")
shaderRGBOnly = App.loadShaderFromClasspath("shaders/default.vert", "shaders/rgbonly.frag")
shaderAtoGrey = App.loadShaderFromClasspath("shaders/default.vert", "shaders/aonly.frag")
shaderAlphaDither = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/alphadither.frag")
shaderAlphaDither = App.loadShaderFromClasspath("shaders/default.vert", "shaders/alphadither.frag")
shaderBlendGlow = App.loadShaderFromClasspath("shaders/blendGlow.vert", "shaders/blendGlow.frag")
shaderKawaseDown = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/kawasedown.frag")
shaderKawaseUp = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/kawaseup.frag")
shaderKawaseDown = App.loadShaderFromClasspath("shaders/default.vert", "shaders/kawasedown.frag")
shaderKawaseUp = App.loadShaderFromClasspath("shaders/default.vert", "shaders/kawaseup.frag")
if (!shaderBlendGlow.isCompiled) {
Gdx.app.log("shaderBlendGlow", shaderBlendGlow.log)

6
src/net/torvald/terrarum/modulebasegame/ui/UILoadDemoSavefiles.kt
View File

@@ -579,17 +579,17 @@ class UIItemPlayerCells(
val bodypartImages = props.bodypartJoints.keys.associate { partname ->
fileGetter(partname).let { file ->
if (file == null) {
printdbg(this, " Partname $partname points to a null file!")
// printdbg(this, " Partname $partname points to a null file!")
partname to null
}
else {
try {
printdbg(this, " Partname $partname successfully retrieved")
// printdbg(this, " Partname $partname successfully retrieved")
val bytes = file.readAllBytes()
partname to Pixmap(bytes, 0, bytes.size)
}
catch (e: GdxRuntimeException) {
printdbg(this, " Partname $partname failed to load: ${e.message}")
// printdbg(this, " Partname $partname failed to load: ${e.message}")
partname to null
}
}

8
src/net/torvald/terrarum/ui/Toolkit.kt
View File

@@ -29,10 +29,10 @@ object Toolkit : Disposable {
}
private val shaderKawaseDown = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/kawasedown.frag")
private val shaderKawaseUp = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/kawaseup.frag")
private val shaderBoxDown = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/boxdown.frag")
private val shaderBoxUp = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/boxup.frag")
private val shaderKawaseDown = App.loadShaderFromClasspath("shaders/default.vert", "shaders/kawasedown.frag")
private val shaderKawaseUp = App.loadShaderFromClasspath("shaders/default.vert", "shaders/kawaseup.frag")
private val shaderBoxDown = App.loadShaderFromClasspath("shaders/default.vert", "shaders/boxdown.frag")
private val shaderBoxUp = App.loadShaderFromClasspath("shaders/default.vert", "shaders/boxup.frag")
private lateinit var fboBlur: FloatFrameBuffer
private lateinit var fboBlurHalf: FloatFrameBuffer

2
src/net/torvald/terrarum/worlddrawer/BlocksDrawer.kt
View File

@@ -85,7 +85,7 @@ internal object BlocksDrawer {
private lateinit var tilesQuad: Mesh
private val shader = App.loadShaderFromClasspath("shaders/4096.vert", "shaders/tiling_dither.frag")
private val shader = App.loadShaderFromClasspath("shaders/default.vert", "shaders/tiling_dither.frag")
init {

14
src/shaders/4096.frag
View File

@@ -1,14 +0,0 @@
varying vec4 v_color;
varying vec2 v_texCoords;
uniform sampler2D u_texture;
void main(void) {
vec4 color = texture2D(u_texture, v_texCoords).rgba;
color.r = floor(15.0 * color.r + 0.5) / 15.0;
color.g = floor(15.0 * color.g + 0.5) / 15.0;
color.b = floor(15.0 * color.b + 0.5) / 15.0;
// a: passthrough
gl_FragColor = color;
}

43
src/shaders/4096_bayer_aaa1.frag
View File

@@ -1,43 +0,0 @@
/**
* Blue Noise texture created by Christoph Peters, released under CC0
* http://momentsingraphics.de/BlueNoise.html
*/
#version 130
#ifdef GL_ES
precision mediump float;
#endif
varying vec4 v_color;
varying vec2 v_texCoords;
uniform sampler2D u_texture;
uniform sampler2D u_pattern;
uniform ivec2 rnd = ivec2(0,0);
float quant = 127.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec4 quantiser = vec4(quant);
vec4 quantiserDivider = vec4(1.0 / quant);
vec2 boolean = vec2(0.0, 1.0);
vec4 halfvec = vec4(0.5);
vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
vec4 nearestColour(vec4 inColor) {
return floor(quantiser * inColor + halfvec) * quantiserDivider;
}
vec4 getDitherredDot(vec4 inColor) {
vec4 bayerThreshold = vec4(texture2D(u_pattern, (gl_FragCoord.xy + rnd) * patternsize) - 0.5);
return nearestColour(bayerThreshold * quantiserDivider + inColor);
}
void main(void) {
// create texture coordinates based on pixelSize //
vec4 inColor = v_color * (texture2D(u_texture, v_texCoords)).aaaa;
vec4 selvec = getDitherredDot(inColor);
gl_FragColor = selvec * boolean.yyyx + boolean.xxxy; // use quantised RGB but not the A
}

43
src/shaders/4096_bayer_rgb1.frag
View File

@@ -1,43 +0,0 @@
/**
* Blue Noise texture created by Christoph Peters, released under CC0
* http://momentsingraphics.de/BlueNoise.html
*/
#version 130
#ifdef GL_ES
precision mediump float;
#endif
varying vec4 v_color;
varying vec2 v_texCoords;
uniform sampler2D u_texture;
uniform sampler2D u_pattern;
uniform ivec2 rnd = ivec2(0,0);
float quant = 127.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec4 quantiser = vec4(quant);
vec4 quantiserDivider = vec4(1.0 / quant);
vec2 boolean = vec2(0.0, 1.0);
vec4 halfvec = vec4(0.5);
vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
vec4 nearestColour(vec4 inColor) {
return floor(quantiser * inColor + halfvec) * quantiserDivider;
}
vec4 getDitherredDot(vec4 inColor) {
vec4 bayerThreshold = vec4(texture2D(u_pattern, (gl_FragCoord.xy + rnd) * patternsize) - 0.5);
return nearestColour(bayerThreshold * quantiserDivider + inColor);
}
void main(void) {
// create texture coordinates based on pixelSize //
vec4 inColor = v_color * (texture2D(u_texture, v_texCoords));
vec4 selvec = getDitherredDot(inColor);
gl_FragColor = selvec * boolean.yyyx + boolean.xxxy; // use quantised RGB but not the A
}

59
src/shaders/blur_dither.frag
View File

@@ -1,59 +0,0 @@
/**
* Blue Noise texture created by Christoph Peters, released under CC0
* http://momentsingraphics.de/BlueNoise.html
*/
#version 130
#ifdef GL_ES
precision mediump float;
#endif
varying vec4 v_color;
varying vec2 v_texCoords;
uniform sampler2D u_texture;
uniform sampler2D u_pattern;
uniform ivec2 rnd = ivec2(0,0);
float quant = 127.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec4 quantiser = vec4(quant);
vec4 quantiserDivider = vec4(1.0 / quant);
vec2 boolean = vec2(0.0, 1.0);
vec4 halfvec = vec4(0.5);
vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
vec4 nearestColour(vec4 inColor) {
return floor(quantiser * inColor + halfvec) * quantiserDivider;
}
vec4 getDitherredDot(vec4 inColor) {
vec4 bayerThreshold = vec4(texture2D(u_pattern, (gl_FragCoord.xy + rnd) * patternsize) - 0.5);
return nearestColour(bayerThreshold * quantiserDivider + inColor);
}
uniform vec2 iResolution;
uniform float flip;
uniform vec2 direction;
vec4 blur(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) {
vec4 color = vec4(0.0);
vec2 off1 = vec2(1.3846153846) * direction;
vec2 off2 = vec2(3.2307692308) * direction;
color += texture2D(image, uv) * 0.2270270270;
color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162;
color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162;
color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703;
color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703;
return color;
}
void main() {
vec2 uv = vec2(gl_FragCoord.xy / iResolution.xy);
if (flip == 1.0) { uv.y = 1.0 - uv.y; }
vec4 inColor = blur(u_texture, uv, iResolution.xy, direction);
vec4 selvec = getDitherredDot(inColor);
gl_FragColor = selvec; // quantise all four RGBA
}

0
src/shaders/4096.vert → src/shaders/default.vert
View File

8
src/shaders/4096_bayer.frag → src/shaders/float_to_disp_dither.frag
View File

@@ -23,9 +23,7 @@ uniform sampler2D u_texture;
uniform sampler2D u_pattern;
uniform ivec2 rnd = ivec2(0,0);
float quant = 255.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec4 quantiser = vec4(quant);
vec4 quantiserDivider = vec4(1.0 / quant);
uniform float quant = 255.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec2 boolean = vec2(0.0, 1.0);
vec4 halfvec = vec4(0.5);
@@ -33,12 +31,12 @@ vec4 halfvec = vec4(0.5);
vec2 patternsize = vec2(1.0/512.0, 1.0/512.0);
vec4 nearestColour(vec4 inColor) {
return floor(quantiser * inColor + halfvec) * quantiserDivider;
return floor(vec4(quant) * inColor + halfvec) * vec4(1.0 / quant);
}
vec4 getDitherredDot(vec4 inColor) {
vec4 bayerThreshold = vec4(texture2D(u_pattern, (gl_FragCoord.xy + rnd) * patternsize) - 0.5);
return nearestColour(bayerThreshold * quantiserDivider + inColor);
return nearestColour(bayerThreshold * vec4(1.0 / quant) + inColor);
}

2
src/shaders/4096_bayer_skyboxfill.frag → src/shaders/float_to_disp_dither_static.frag
View File

@@ -19,7 +19,7 @@ uniform float parallax_size = 1.0/3.0; // 0: no parallax
uniform float zoomInv = 1.0;
float quant = 63.0; // 64 steps -> 63.0; 256 steps -> 255.0
float quant = 255.0; // 64 steps -> 63.0; 256 steps -> 255.0
vec4 quantiser = vec4(quant);
vec4 quantiserDivider = vec4(1.0 / quant);