From d28698b6688104b8963ea95a2f292684fda17f77 Mon Sep 17 00:00:00 2001 From: minjaesong Date: Sat, 9 Oct 2021 20:34:53 +0900 Subject: [PATCH] dither on lighting and blurring, with an option to turn them off --- assets/4096_bayer.frag | 21 +- assets/4096_bayer_aaa1.frag | 310 +++++++++++++++++ assets/4096_bayer_rgb1.frag | 310 +++++++++++++++++ assets/aonly.frag | 5 +- assets/blur_dither.frag | 315 ++++++++++++++++++ assets/rgbonly.frag | 5 +- src/net/torvald/terrarum/UIFakeGradOverlay.kt | 3 - .../terrarum/modulebasegame/IngameRenderer.kt | 59 +++- src/net/torvald/terrarum/ui/Toolkit.kt | 5 +- .../torvald/terrarum/ui/UIAutosaveNotifier.kt | 3 +- 10 files changed, 1000 insertions(+), 36 deletions(-) create mode 100644 assets/4096_bayer_aaa1.frag create mode 100644 assets/4096_bayer_rgb1.frag create mode 100644 assets/blur_dither.frag diff --git a/assets/4096_bayer.frag b/assets/4096_bayer.frag index 7380c874f..c48986a2f 100644 --- a/assets/4096_bayer.frag +++ b/assets/4096_bayer.frag @@ -282,6 +282,17 @@ vec4 quantiserDivider = vec4(1.0 / quant); vec2 boolean = vec2(0.0, 1.0); vec4 halfvec = vec4(0.5); +vec4 nearestColour(vec4 inColor) { + return floor(quantiser * inColor + halfvec) * quantiserDivider; +} + +vec4 getDitherredDot(vec4 inColor) { + vec2 entry = mod(gl_FragCoord.xy, vec2(bayerSize, bayerSize)); + int index = int(entry.y) * int(bayerSize) + int(entry.x); + vec4 bayerThreshold = vec4(bayerTex[index] / bayerDivider - 0.5); + return nearestColour(inColor + bayerThreshold * quantiserDivider); +} + vec4 gammaIn(vec4 col) { return pow(col, vec4(2.2)); } @@ -290,18 +301,10 @@ vec4 gammaOut(vec4 col) { return pow(col, vec4(1.0 / 2.2)); } -vec4 nearestColour(vec4 inColor) { - return floor(quantiser * inColor + halfvec) * quantiserDivider; -} - void main(void) { // create texture coordinates based on pixelSize // vec4 inColor = v_color * (texture2D(u_texture, v_texCoords)); - vec2 entry = mod(gl_FragCoord.xy, vec2(bayerSize, bayerSize)); - int index = int(entry.y) * int(bayerSize) + int(entry.x); - - vec4 bayerThreshold = vec4(bayerTex[index] / bayerDivider - 0.5); - vec4 selvec = nearestColour(inColor + bayerThreshold * quantiserDivider); + vec4 selvec = getDitherredDot(inColor); gl_FragColor = selvec * boolean.yyyx + inColor * boolean.xxxy; // use quantised RGB but not the A } \ No newline at end of file diff --git a/assets/4096_bayer_aaa1.frag b/assets/4096_bayer_aaa1.frag new file mode 100644 index 000000000..251c742b5 --- /dev/null +++ b/assets/4096_bayer_aaa1.frag @@ -0,0 +1,310 @@ +/** + * Blue Noise texture created by Christoph Peters, released under CC0 + * http://momentsingraphics.de/BlueNoise.html + */ + +#version 120 +#ifdef GL_ES + precision mediump float; +#endif + + +varying vec4 v_color; +varying vec2 v_texCoords; +uniform sampler2D u_texture; + +vec4 bayerTex[256] = vec4[]( +vec4( 65, 205, 111, 82), +vec4( 0, 255, 65, 133), +vec4(134, 25, 88, 9), +vec4(185, 105, 231, 39), +vec4( 66, 161, 152, 139), +vec4( 35, 91, 170, 203), +vec4(115, 247, 78, 3), +vec4(144, 22, 193, 59), +vec4(157, 165, 156, 148), +vec4(245, 114, 131, 233), +vec4( 57, 192, 202, 132), +vec4( 15, 30, 162, 31), +vec4( 83, 217, 17, 63), +vec4( 39, 147, 189, 214), +vec4(129, 71, 168, 106), +vec4(243, 135, 1, 195), +vec4( 75, 173, 213, 232), +vec4(233, 122, 175, 161), +vec4(203, 142, 26, 213), +vec4( 21, 234, 118, 251), +vec4( 86, 1, 7, 70), +vec4(162, 218, 222, 113), +vec4(249, 150, 105, 244), +vec4( 49, 186, 51, 124), +vec4( 11, 41, 229, 183), +vec4( 90, 65, 4, 22), +vec4(186, 252, 43, 115), +vec4(165, 131, 141, 166), +vec4(202, 53, 221, 239), +vec4(228, 20, 69, 1), +vec4(173, 226, 230, 123), +vec4( 29, 39, 130, 43), +vec4(124, 15, 251, 28), +vec4( 98, 216, 79, 90), +vec4(145, 47, 137, 53), +vec4(225, 198, 203, 197), +vec4( 54, 60, 190, 25), +vec4(130, 133, 38, 172), +vec4(218, 75, 143, 46), +vec4(105, 124, 243, 97), +vec4(201, 227, 115, 218), +vec4(123, 84, 81, 68), +vec4( 32, 4, 97, 207), +vec4(133, 179, 254, 84), +vec4( 99, 79, 55, 50), +vec4( 9, 160, 119, 184), +vec4(108, 189, 92, 141), +vec4(194, 86, 47, 246), +vec4( 48, 111, 185, 67), +vec4(170, 157, 14, 147), +vec4( 12, 70, 54, 122), +vec4(110, 98, 235, 105), +vec4(197, 180, 70, 155), +vec4(177, 31, 94, 85), +vec4( 4, 239, 21, 224), +vec4( 78, 14, 167, 30), +vec4(172, 106, 183, 162), +vec4(234, 209, 212, 6), +vec4(221, 144, 151, 254), +vec4( 73, 235, 178, 103), +vec4(250, 101, 23, 151), +vec4( 60, 119, 205, 221), +vec4(156, 248, 154, 13), +vec4(217, 59, 31, 168), +vec4(238, 238, 144, 209), +vec4( 37, 177, 223, 227), +vec4(154, 11, 165, 182), +vec4(254, 249, 108, 5), +vec4( 74, 164, 153, 238), +vec4( 30, 112, 253, 128), +vec4(239, 201, 126, 190), +vec4(139, 49, 59, 145), +vec4( 63, 172, 11, 78), +vec4( 20, 156, 32, 200), +vec4( 46, 27, 72, 135), +vec4(148, 44, 107, 38), +vec4(180, 196, 192, 193), +vec4( 24, 9, 6, 72), +vec4(140, 208, 242, 96), +vec4( 84, 138, 102, 114), +vec4(182, 34, 199, 19), +vec4( 64, 81, 122, 45), +vec4(208, 128, 91, 79), +vec4( 92, 211, 28, 36), +vec4(122, 23, 44, 212), +vec4( 44, 83, 187, 58), +vec4(190, 139, 216, 11), +vec4( 96, 223, 85, 241), +vec4(159, 92, 198, 117), +vec4(113, 58, 232, 55), +vec4(193, 129, 136, 173), +vec4( 85, 215, 238, 15), +vec4(211, 69, 62, 125), +vec4(118, 166, 129, 243), +vec4(242, 26, 172, 54), +vec4( 6, 95, 73, 179), +vec4(106, 224, 57, 129), +vec4(127, 199, 8, 252), +vec4(227, 145, 247, 164), +vec4( 18, 43, 209, 201), +vec4(168, 229, 173, 137), +vec4(150, 154, 0, 71), +vec4(216, 67, 140, 177), +vec4( 14, 3, 104, 102), +vec4(206, 194, 160, 41), +vec4(252, 245, 121, 229), +vec4(128, 181, 41, 93), +vec4( 1, 110, 164, 236), +vec4(166, 241, 25, 160), +vec4( 40, 149, 86, 29), +vec4( 70, 50, 225, 204), +vec4(198, 183, 40, 143), +vec4(163, 64, 159, 231), +vec4( 26, 2, 179, 104), +vec4( 79, 115, 133, 91), +vec4(188, 56, 63, 23), +vec4( 58, 97, 116, 112), +vec4(246, 187, 77, 247), +vec4(114, 254, 226, 158), +vec4( 82, 37, 50, 18), +vec4( 53, 120, 249, 205), +vec4( 33, 78, 19, 150), +vec4(224, 13, 95, 186), +vec4(103, 36, 219, 64), +vec4( 55, 87, 197, 110), +vec4(230, 127, 147, 216), +vec4( 95, 213, 114, 87), +vec4(137, 108, 208, 2), +vec4(251, 236, 233, 192), +vec4( 50, 169, 20, 57), +vec4(204, 193, 84, 153), +vec4(142, 242, 149, 188), +vec4(101, 125, 240, 225), +vec4( 8, 19, 36, 48), +vec4(132, 176, 194, 86), +vec4(232, 103, 15, 215), +vec4(181, 162, 67, 121), +vec4(143, 220, 206, 26), +vec4( 69, 140, 180, 80), +vec4(171, 171, 74, 7), +vec4(189, 230, 52, 140), +vec4(149, 6, 250, 42), +vec4(215, 77, 13, 175), +vec4( 16, 155, 98, 74), +vec4(176, 136, 68, 34), +vec4(116, 21, 195, 217), +vec4(241, 88, 48, 14), +vec4( 38, 33, 220, 66), +vec4(222, 210, 182, 171), +vec4(175, 76, 96, 32), +vec4( 71, 134, 155, 131), +vec4( 41, 54, 127, 185), +vec4(158, 206, 171, 61), +vec4( 91, 24, 145, 248), +vec4( 22, 99, 112, 167), +vec4(244, 202, 2, 222), +vec4( 10, 62, 125, 196), +vec4(121, 188, 184, 250), +vec4( 34, 253, 35, 120), +vec4( 88, 40, 139, 157), +vec4(152, 102, 106, 107), +vec4( 68, 72, 255, 134), +vec4( 2, 219, 123, 240), +vec4(160, 151, 30, 118), +vec4( 89, 163, 10, 146), +vec4(210, 8, 109, 99), +vec4( 27, 222, 236, 230), +vec4(196, 237, 214, 0), +vec4(120, 148, 87, 144), +vec4(219, 68, 37, 108), +vec4(199, 250, 246, 49), +vec4(111, 48, 228, 130), +vec4( 80, 132, 158, 98), +vec4(236, 116, 83, 60), +vec4( 61, 18, 215, 24), +vec4(192, 175, 169, 237), +vec4(231, 52, 5, 181), +vec4( 97, 244, 157, 47), +vec4(187, 184, 90, 81), +vec4(126, 109, 204, 208), +vec4( 51, 61, 142, 10), +vec4(109, 190, 53, 255), +vec4(147, 117, 71, 73), +vec4(240, 42, 24, 199), +vec4( 3, 89, 188, 89), +vec4( 59, 10, 58, 234), +vec4(135, 182, 101, 33), +vec4( 47, 158, 135, 211), +vec4(155, 29, 27, 12), +vec4(207, 93, 64, 149), +vec4(131, 221, 239, 88), +vec4( 42, 207, 45, 202), +vec4( 13, 123, 132, 4), +vec4(138, 7, 227, 165), +vec4(200, 141, 60, 95), +vec4(226, 45, 174, 194), +vec4( 19, 251, 244, 40), +vec4(253, 96, 163, 178), +vec4(183, 28, 201, 52), +vec4( 77, 197, 120, 163), +vec4(104, 168, 224, 20), +vec4(164, 126, 12, 180), +vec4(248, 107, 166, 154), +vec4(179, 225, 196, 76), +vec4( 28, 195, 207, 189), +vec4(100, 143, 93, 170), +vec4(167, 82, 117, 228), +vec4(220, 159, 191, 69), +vec4(112, 32, 75, 142), +vec4( 56, 200, 210, 245), +vec4( 31, 85, 34, 27), +vec4( 81, 16, 113, 152), +vec4(169, 130, 80, 219), +vec4( 62, 231, 3, 127), +vec4(136, 146, 134, 109), +vec4( 45, 80, 42, 136), +vec4(205, 243, 148, 210), +vec4( 17, 214, 237, 65), +vec4( 87, 38, 76, 119), +vec4(223, 73, 49, 242), +vec4( 67, 246, 9, 51), +vec4( 5, 0, 150, 111), +vec4(255, 63, 176, 37), +vec4( 76, 233, 22, 126), +vec4(146, 113, 100, 56), +vec4(214, 153, 146, 223), +vec4(247, 228, 16, 116), +vec4(119, 170, 186, 62), +vec4(153, 212, 217, 77), +vec4( 7, 66, 99, 16), +vec4( 94, 178, 252, 226), +vec4(229, 5, 177, 35), +vec4(174, 137, 89, 249), +vec4(125, 57, 110, 101), +vec4( 36, 17, 181, 8), +vec4(141, 174, 124, 220), +vec4(195, 121, 218, 138), +vec4(117, 46, 234, 17), +vec4(184, 167, 56, 253), +vec4( 23, 185, 248, 206), +vec4(161, 94, 200, 21), +vec4(178, 55, 161, 100), +vec4( 43, 74, 241, 187), +vec4(102, 191, 46, 169), +vec4(235, 35, 128, 235), +vec4(209, 118, 61, 94), +vec4(191, 51, 29, 159), +vec4( 25, 204, 211, 191), +vec4( 72, 100, 18, 83), +vec4(213, 232, 66, 44), +vec4(107, 152, 245, 174), +vec4(237, 90, 33, 198), +vec4(151, 203, 103, 92), +vec4( 52, 104, 82, 156), +vec4(212, 240, 138, 75), +vec4( 93, 12, 39, 176) +); + +float bayerSize = 16.0; +float bayerDivider = bayerSize * bayerSize; + +float quant = 63.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); + +vec4 nearestColour(vec4 inColor) { + return floor(quantiser * inColor + halfvec) * quantiserDivider; +} + +vec4 getDitherredDot(vec4 inColor) { + vec2 entry = mod(gl_FragCoord.xy, vec2(bayerSize, bayerSize)); + int index = int(entry.y) * int(bayerSize) + int(entry.x); + vec4 bayerThreshold = vec4(bayerTex[index] / bayerDivider - 0.5); + return nearestColour(inColor + bayerThreshold * quantiserDivider); +} + +vec4 gammaIn(vec4 col) { + return pow(col, vec4(2.2)); +} + +vec4 gammaOut(vec4 col) { + return pow(col, vec4(1.0 / 2.2)); +} + +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 +} \ No newline at end of file diff --git a/assets/4096_bayer_rgb1.frag b/assets/4096_bayer_rgb1.frag new file mode 100644 index 000000000..1b5e7816f --- /dev/null +++ b/assets/4096_bayer_rgb1.frag @@ -0,0 +1,310 @@ +/** + * Blue Noise texture created by Christoph Peters, released under CC0 + * http://momentsingraphics.de/BlueNoise.html + */ + +#version 120 +#ifdef GL_ES + precision mediump float; +#endif + + +varying vec4 v_color; +varying vec2 v_texCoords; +uniform sampler2D u_texture; + +vec4 bayerTex[256] = vec4[]( +vec4(111, 82, 65, 205), +vec4( 65, 133, 0, 255), +vec4( 88, 9, 134, 25), +vec4(231, 39, 185, 105), +vec4(152, 139, 66, 161), +vec4(170, 203, 35, 91), +vec4( 78, 3, 115, 247), +vec4(193, 59, 144, 22), +vec4(156, 148, 157, 165), +vec4(131, 233, 245, 114), +vec4(202, 132, 57, 192), +vec4(162, 31, 15, 30), +vec4( 17, 63, 83, 217), +vec4(189, 214, 39, 147), +vec4(168, 106, 129, 71), +vec4( 1, 195, 243, 135), +vec4(213, 232, 75, 173), +vec4(175, 161, 233, 122), +vec4( 26, 213, 203, 142), +vec4(118, 251, 21, 234), +vec4( 7, 70, 86, 1), +vec4(222, 113, 162, 218), +vec4(105, 244, 249, 150), +vec4( 51, 124, 49, 186), +vec4(229, 183, 11, 41), +vec4( 4, 22, 90, 65), +vec4( 43, 115, 186, 252), +vec4(141, 166, 165, 131), +vec4(221, 239, 202, 53), +vec4( 69, 1, 228, 20), +vec4(230, 123, 173, 226), +vec4(130, 43, 29, 39), +vec4(251, 28, 124, 15), +vec4( 79, 90, 98, 216), +vec4(137, 53, 145, 47), +vec4(203, 197, 225, 198), +vec4(190, 25, 54, 60), +vec4( 38, 172, 130, 133), +vec4(143, 46, 218, 75), +vec4(243, 97, 105, 124), +vec4(115, 218, 201, 227), +vec4( 81, 68, 123, 84), +vec4( 97, 207, 32, 4), +vec4(254, 84, 133, 179), +vec4( 55, 50, 99, 79), +vec4(119, 184, 9, 160), +vec4( 92, 141, 108, 189), +vec4( 47, 246, 194, 86), +vec4(185, 67, 48, 111), +vec4( 14, 147, 170, 157), +vec4( 54, 122, 12, 70), +vec4(235, 105, 110, 98), +vec4( 70, 155, 197, 180), +vec4( 94, 85, 177, 31), +vec4( 21, 224, 4, 239), +vec4(167, 30, 78, 14), +vec4(183, 162, 172, 106), +vec4(212, 6, 234, 209), +vec4(151, 254, 221, 144), +vec4(178, 103, 73, 235), +vec4( 23, 151, 250, 101), +vec4(205, 221, 60, 119), +vec4(154, 13, 156, 248), +vec4( 31, 168, 217, 59), +vec4(144, 209, 238, 238), +vec4(223, 227, 37, 177), +vec4(165, 182, 154, 11), +vec4(108, 5, 254, 249), +vec4(153, 238, 74, 164), +vec4(253, 128, 30, 112), +vec4(126, 190, 239, 201), +vec4( 59, 145, 139, 49), +vec4( 11, 78, 63, 172), +vec4( 32, 200, 20, 156), +vec4( 72, 135, 46, 27), +vec4(107, 38, 148, 44), +vec4(192, 193, 180, 196), +vec4( 6, 72, 24, 9), +vec4(242, 96, 140, 208), +vec4(102, 114, 84, 138), +vec4(199, 19, 182, 34), +vec4(122, 45, 64, 81), +vec4( 91, 79, 208, 128), +vec4( 28, 36, 92, 211), +vec4( 44, 212, 122, 23), +vec4(187, 58, 44, 83), +vec4(216, 11, 190, 139), +vec4( 85, 241, 96, 223), +vec4(198, 117, 159, 92), +vec4(232, 55, 113, 58), +vec4(136, 173, 193, 129), +vec4(238, 15, 85, 215), +vec4( 62, 125, 211, 69), +vec4(129, 243, 118, 166), +vec4(172, 54, 242, 26), +vec4( 73, 179, 6, 95), +vec4( 57, 129, 106, 224), +vec4( 8, 252, 127, 199), +vec4(247, 164, 227, 145), +vec4(209, 201, 18, 43), +vec4(173, 137, 168, 229), +vec4( 0, 71, 150, 154), +vec4(140, 177, 216, 67), +vec4(104, 102, 14, 3), +vec4(160, 41, 206, 194), +vec4(121, 229, 252, 245), +vec4( 41, 93, 128, 181), +vec4(164, 236, 1, 110), +vec4( 25, 160, 166, 241), +vec4( 86, 29, 40, 149), +vec4(225, 204, 70, 50), +vec4( 40, 143, 198, 183), +vec4(159, 231, 163, 64), +vec4(179, 104, 26, 2), +vec4(133, 91, 79, 115), +vec4( 63, 23, 188, 56), +vec4(116, 112, 58, 97), +vec4( 77, 247, 246, 187), +vec4(226, 158, 114, 254), +vec4( 50, 18, 82, 37), +vec4(249, 205, 53, 120), +vec4( 19, 150, 33, 78), +vec4( 95, 186, 224, 13), +vec4(219, 64, 103, 36), +vec4(197, 110, 55, 87), +vec4(147, 216, 230, 127), +vec4(114, 87, 95, 213), +vec4(208, 2, 137, 108), +vec4(233, 192, 251, 236), +vec4( 20, 57, 50, 169), +vec4( 84, 153, 204, 193), +vec4(149, 188, 142, 242), +vec4(240, 225, 101, 125), +vec4( 36, 48, 8, 19), +vec4(194, 86, 132, 176), +vec4( 15, 215, 232, 103), +vec4( 67, 121, 181, 162), +vec4(206, 26, 143, 220), +vec4(180, 80, 69, 140), +vec4( 74, 7, 171, 171), +vec4( 52, 140, 189, 230), +vec4(250, 42, 149, 6), +vec4( 13, 175, 215, 77), +vec4( 98, 74, 16, 155), +vec4( 68, 34, 176, 136), +vec4(195, 217, 116, 21), +vec4( 48, 14, 241, 88), +vec4(220, 66, 38, 33), +vec4(182, 171, 222, 210), +vec4( 96, 32, 175, 76), +vec4(155, 131, 71, 134), +vec4(127, 185, 41, 54), +vec4(171, 61, 158, 206), +vec4(145, 248, 91, 24), +vec4(112, 167, 22, 99), +vec4( 2, 222, 244, 202), +vec4(125, 196, 10, 62), +vec4(184, 250, 121, 188), +vec4( 35, 120, 34, 253), +vec4(139, 157, 88, 40), +vec4(106, 107, 152, 102), +vec4(255, 134, 68, 72), +vec4(123, 240, 2, 219), +vec4( 30, 118, 160, 151), +vec4( 10, 146, 89, 163), +vec4(109, 99, 210, 8), +vec4(236, 230, 27, 222), +vec4(214, 0, 196, 237), +vec4( 87, 144, 120, 148), +vec4( 37, 108, 219, 68), +vec4(246, 49, 199, 250), +vec4(228, 130, 111, 48), +vec4(158, 98, 80, 132), +vec4( 83, 60, 236, 116), +vec4(215, 24, 61, 18), +vec4(169, 237, 192, 175), +vec4( 5, 181, 231, 52), +vec4(157, 47, 97, 244), +vec4( 90, 81, 187, 184), +vec4(204, 208, 126, 109), +vec4(142, 10, 51, 61), +vec4( 53, 255, 109, 190), +vec4( 71, 73, 147, 117), +vec4( 24, 199, 240, 42), +vec4(188, 89, 3, 89), +vec4( 58, 234, 59, 10), +vec4(101, 33, 135, 182), +vec4(135, 211, 47, 158), +vec4( 27, 12, 155, 29), +vec4( 64, 149, 207, 93), +vec4(239, 88, 131, 221), +vec4( 45, 202, 42, 207), +vec4(132, 4, 13, 123), +vec4(227, 165, 138, 7), +vec4( 60, 95, 200, 141), +vec4(174, 194, 226, 45), +vec4(244, 40, 19, 251), +vec4(163, 178, 253, 96), +vec4(201, 52, 183, 28), +vec4(120, 163, 77, 197), +vec4(224, 20, 104, 168), +vec4( 12, 180, 164, 126), +vec4(166, 154, 248, 107), +vec4(196, 76, 179, 225), +vec4(207, 189, 28, 195), +vec4( 93, 170, 100, 143), +vec4(117, 228, 167, 82), +vec4(191, 69, 220, 159), +vec4( 75, 142, 112, 32), +vec4(210, 245, 56, 200), +vec4( 34, 27, 31, 85), +vec4(113, 152, 81, 16), +vec4( 80, 219, 169, 130), +vec4( 3, 127, 62, 231), +vec4(134, 109, 136, 146), +vec4( 42, 136, 45, 80), +vec4(148, 210, 205, 243), +vec4(237, 65, 17, 214), +vec4( 76, 119, 87, 38), +vec4( 49, 242, 223, 73), +vec4( 9, 51, 67, 246), +vec4(150, 111, 5, 0), +vec4(176, 37, 255, 63), +vec4( 22, 126, 76, 233), +vec4(100, 56, 146, 113), +vec4(146, 223, 214, 153), +vec4( 16, 116, 247, 228), +vec4(186, 62, 119, 170), +vec4(217, 77, 153, 212), +vec4( 99, 16, 7, 66), +vec4(252, 226, 94, 178), +vec4(177, 35, 229, 5), +vec4( 89, 249, 174, 137), +vec4(110, 101, 125, 57), +vec4(181, 8, 36, 17), +vec4(124, 220, 141, 174), +vec4(218, 138, 195, 121), +vec4(234, 17, 117, 46), +vec4( 56, 253, 184, 167), +vec4(248, 206, 23, 185), +vec4(200, 21, 161, 94), +vec4(161, 100, 178, 55), +vec4(241, 187, 43, 74), +vec4( 46, 169, 102, 191), +vec4(128, 235, 235, 35), +vec4( 61, 94, 209, 118), +vec4( 29, 159, 191, 51), +vec4(211, 191, 25, 204), +vec4( 18, 83, 72, 100), +vec4( 66, 44, 213, 232), +vec4(245, 174, 107, 152), +vec4( 33, 198, 237, 90), +vec4(103, 92, 151, 203), +vec4( 82, 156, 52, 104), +vec4(138, 75, 212, 240), +vec4( 39, 176, 93, 12) +); + +float bayerSize = 16.0; +float bayerDivider = bayerSize * bayerSize; + +float quant = 63.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); + +vec4 nearestColour(vec4 inColor) { + return floor(quantiser * inColor + halfvec) * quantiserDivider; +} + +vec4 getDitherredDot(vec4 inColor) { + vec2 entry = mod(gl_FragCoord.xy, vec2(bayerSize, bayerSize)); + int index = int(entry.y) * int(bayerSize) + int(entry.x); + vec4 bayerThreshold = vec4(bayerTex[index] / bayerDivider - 0.5); + return nearestColour(inColor + bayerThreshold * quantiserDivider); +} + +vec4 gammaIn(vec4 col) { + return pow(col, vec4(2.2)); +} + +vec4 gammaOut(vec4 col) { + return pow(col, vec4(1.0 / 2.2)); +} + +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 +} \ No newline at end of file diff --git a/assets/aonly.frag b/assets/aonly.frag index 49e3089db..45c2cd411 100644 --- a/assets/aonly.frag +++ b/assets/aonly.frag @@ -2,7 +2,8 @@ varying vec4 v_color; varying vec2 v_texCoords; uniform sampler2D u_texture; +vec2 boolean = vec2(0.0, 1.0); + void main(void) { - vec3 alpha = texture2D(u_texture, v_texCoords).aaa; - gl_FragColor = vec4(alpha, 1.0); + gl_FragColor = texture2D(u_texture, v_texCoords).aaaa * boolean.yyyx + boolean.xxxy; } \ No newline at end of file diff --git a/assets/blur_dither.frag b/assets/blur_dither.frag new file mode 100644 index 000000000..b8298937c --- /dev/null +++ b/assets/blur_dither.frag @@ -0,0 +1,315 @@ +#ifdef GL_ES + precision mediump float; +#endif + + +varying vec4 v_color; +varying vec2 v_texCoords; +uniform sampler2D u_texture; + + +vec4 bayerTex[256] = vec4[]( +vec4( 82, 65, 205, 111), +vec4(133, 0, 255, 65), +vec4( 9, 134, 25, 88), +vec4( 39, 185, 105, 231), +vec4(139, 66, 161, 152), +vec4(203, 35, 91, 170), +vec4( 3, 115, 247, 78), +vec4( 59, 144, 22, 193), +vec4(148, 157, 165, 156), +vec4(233, 245, 114, 131), +vec4(132, 57, 192, 202), +vec4( 31, 15, 30, 162), +vec4( 63, 83, 217, 17), +vec4(214, 39, 147, 189), +vec4(106, 129, 71, 168), +vec4(195, 243, 135, 1), +vec4(232, 75, 173, 213), +vec4(161, 233, 122, 175), +vec4(213, 203, 142, 26), +vec4(251, 21, 234, 118), +vec4( 70, 86, 1, 7), +vec4(113, 162, 218, 222), +vec4(244, 249, 150, 105), +vec4(124, 49, 186, 51), +vec4(183, 11, 41, 229), +vec4( 22, 90, 65, 4), +vec4(115, 186, 252, 43), +vec4(166, 165, 131, 141), +vec4(239, 202, 53, 221), +vec4( 1, 228, 20, 69), +vec4(123, 173, 226, 230), +vec4( 43, 29, 39, 130), +vec4( 28, 124, 15, 251), +vec4( 90, 98, 216, 79), +vec4( 53, 145, 47, 137), +vec4(197, 225, 198, 203), +vec4( 25, 54, 60, 190), +vec4(172, 130, 133, 38), +vec4( 46, 218, 75, 143), +vec4( 97, 105, 124, 243), +vec4(218, 201, 227, 115), +vec4( 68, 123, 84, 81), +vec4(207, 32, 4, 97), +vec4( 84, 133, 179, 254), +vec4( 50, 99, 79, 55), +vec4(184, 9, 160, 119), +vec4(141, 108, 189, 92), +vec4(246, 194, 86, 47), +vec4( 67, 48, 111, 185), +vec4(147, 170, 157, 14), +vec4(122, 12, 70, 54), +vec4(105, 110, 98, 235), +vec4(155, 197, 180, 70), +vec4( 85, 177, 31, 94), +vec4(224, 4, 239, 21), +vec4( 30, 78, 14, 167), +vec4(162, 172, 106, 183), +vec4( 6, 234, 209, 212), +vec4(254, 221, 144, 151), +vec4(103, 73, 235, 178), +vec4(151, 250, 101, 23), +vec4(221, 60, 119, 205), +vec4( 13, 156, 248, 154), +vec4(168, 217, 59, 31), +vec4(209, 238, 238, 144), +vec4(227, 37, 177, 223), +vec4(182, 154, 11, 165), +vec4( 5, 254, 249, 108), +vec4(238, 74, 164, 153), +vec4(128, 30, 112, 253), +vec4(190, 239, 201, 126), +vec4(145, 139, 49, 59), +vec4( 78, 63, 172, 11), +vec4(200, 20, 156, 32), +vec4(135, 46, 27, 72), +vec4( 38, 148, 44, 107), +vec4(193, 180, 196, 192), +vec4( 72, 24, 9, 6), +vec4( 96, 140, 208, 242), +vec4(114, 84, 138, 102), +vec4( 19, 182, 34, 199), +vec4( 45, 64, 81, 122), +vec4( 79, 208, 128, 91), +vec4( 36, 92, 211, 28), +vec4(212, 122, 23, 44), +vec4( 58, 44, 83, 187), +vec4( 11, 190, 139, 216), +vec4(241, 96, 223, 85), +vec4(117, 159, 92, 198), +vec4( 55, 113, 58, 232), +vec4(173, 193, 129, 136), +vec4( 15, 85, 215, 238), +vec4(125, 211, 69, 62), +vec4(243, 118, 166, 129), +vec4( 54, 242, 26, 172), +vec4(179, 6, 95, 73), +vec4(129, 106, 224, 57), +vec4(252, 127, 199, 8), +vec4(164, 227, 145, 247), +vec4(201, 18, 43, 209), +vec4(137, 168, 229, 173), +vec4( 71, 150, 154, 0), +vec4(177, 216, 67, 140), +vec4(102, 14, 3, 104), +vec4( 41, 206, 194, 160), +vec4(229, 252, 245, 121), +vec4( 93, 128, 181, 41), +vec4(236, 1, 110, 164), +vec4(160, 166, 241, 25), +vec4( 29, 40, 149, 86), +vec4(204, 70, 50, 225), +vec4(143, 198, 183, 40), +vec4(231, 163, 64, 159), +vec4(104, 26, 2, 179), +vec4( 91, 79, 115, 133), +vec4( 23, 188, 56, 63), +vec4(112, 58, 97, 116), +vec4(247, 246, 187, 77), +vec4(158, 114, 254, 226), +vec4( 18, 82, 37, 50), +vec4(205, 53, 120, 249), +vec4(150, 33, 78, 19), +vec4(186, 224, 13, 95), +vec4( 64, 103, 36, 219), +vec4(110, 55, 87, 197), +vec4(216, 230, 127, 147), +vec4( 87, 95, 213, 114), +vec4( 2, 137, 108, 208), +vec4(192, 251, 236, 233), +vec4( 57, 50, 169, 20), +vec4(153, 204, 193, 84), +vec4(188, 142, 242, 149), +vec4(225, 101, 125, 240), +vec4( 48, 8, 19, 36), +vec4( 86, 132, 176, 194), +vec4(215, 232, 103, 15), +vec4(121, 181, 162, 67), +vec4( 26, 143, 220, 206), +vec4( 80, 69, 140, 180), +vec4( 7, 171, 171, 74), +vec4(140, 189, 230, 52), +vec4( 42, 149, 6, 250), +vec4(175, 215, 77, 13), +vec4( 74, 16, 155, 98), +vec4( 34, 176, 136, 68), +vec4(217, 116, 21, 195), +vec4( 14, 241, 88, 48), +vec4( 66, 38, 33, 220), +vec4(171, 222, 210, 182), +vec4( 32, 175, 76, 96), +vec4(131, 71, 134, 155), +vec4(185, 41, 54, 127), +vec4( 61, 158, 206, 171), +vec4(248, 91, 24, 145), +vec4(167, 22, 99, 112), +vec4(222, 244, 202, 2), +vec4(196, 10, 62, 125), +vec4(250, 121, 188, 184), +vec4(120, 34, 253, 35), +vec4(157, 88, 40, 139), +vec4(107, 152, 102, 106), +vec4(134, 68, 72, 255), +vec4(240, 2, 219, 123), +vec4(118, 160, 151, 30), +vec4(146, 89, 163, 10), +vec4( 99, 210, 8, 109), +vec4(230, 27, 222, 236), +vec4( 0, 196, 237, 214), +vec4(144, 120, 148, 87), +vec4(108, 219, 68, 37), +vec4( 49, 199, 250, 246), +vec4(130, 111, 48, 228), +vec4( 98, 80, 132, 158), +vec4( 60, 236, 116, 83), +vec4( 24, 61, 18, 215), +vec4(237, 192, 175, 169), +vec4(181, 231, 52, 5), +vec4( 47, 97, 244, 157), +vec4( 81, 187, 184, 90), +vec4(208, 126, 109, 204), +vec4( 10, 51, 61, 142), +vec4(255, 109, 190, 53), +vec4( 73, 147, 117, 71), +vec4(199, 240, 42, 24), +vec4( 89, 3, 89, 188), +vec4(234, 59, 10, 58), +vec4( 33, 135, 182, 101), +vec4(211, 47, 158, 135), +vec4( 12, 155, 29, 27), +vec4(149, 207, 93, 64), +vec4( 88, 131, 221, 239), +vec4(202, 42, 207, 45), +vec4( 4, 13, 123, 132), +vec4(165, 138, 7, 227), +vec4( 95, 200, 141, 60), +vec4(194, 226, 45, 174), +vec4( 40, 19, 251, 244), +vec4(178, 253, 96, 163), +vec4( 52, 183, 28, 201), +vec4(163, 77, 197, 120), +vec4( 20, 104, 168, 224), +vec4(180, 164, 126, 12), +vec4(154, 248, 107, 166), +vec4( 76, 179, 225, 196), +vec4(189, 28, 195, 207), +vec4(170, 100, 143, 93), +vec4(228, 167, 82, 117), +vec4( 69, 220, 159, 191), +vec4(142, 112, 32, 75), +vec4(245, 56, 200, 210), +vec4( 27, 31, 85, 34), +vec4(152, 81, 16, 113), +vec4(219, 169, 130, 80), +vec4(127, 62, 231, 3), +vec4(109, 136, 146, 134), +vec4(136, 45, 80, 42), +vec4(210, 205, 243, 148), +vec4( 65, 17, 214, 237), +vec4(119, 87, 38, 76), +vec4(242, 223, 73, 49), +vec4( 51, 67, 246, 9), +vec4(111, 5, 0, 150), +vec4( 37, 255, 63, 176), +vec4(126, 76, 233, 22), +vec4( 56, 146, 113, 100), +vec4(223, 214, 153, 146), +vec4(116, 247, 228, 16), +vec4( 62, 119, 170, 186), +vec4( 77, 153, 212, 217), +vec4( 16, 7, 66, 99), +vec4(226, 94, 178, 252), +vec4( 35, 229, 5, 177), +vec4(249, 174, 137, 89), +vec4(101, 125, 57, 110), +vec4( 8, 36, 17, 181), +vec4(220, 141, 174, 124), +vec4(138, 195, 121, 218), +vec4( 17, 117, 46, 234), +vec4(253, 184, 167, 56), +vec4(206, 23, 185, 248), +vec4( 21, 161, 94, 200), +vec4(100, 178, 55, 161), +vec4(187, 43, 74, 241), +vec4(169, 102, 191, 46), +vec4(235, 235, 35, 128), +vec4( 94, 209, 118, 61), +vec4(159, 191, 51, 29), +vec4(191, 25, 204, 211), +vec4( 83, 72, 100, 18), +vec4( 44, 213, 232, 66), +vec4(174, 107, 152, 245), +vec4(198, 237, 90, 33), +vec4( 92, 151, 203, 103), +vec4(156, 52, 104, 82), +vec4( 75, 212, 240, 138), +vec4(176, 93, 12, 39) +); + +float bayerSize = 16.0; +float bayerDivider = bayerSize * bayerSize; + +float quant = 63.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); + +vec4 nearestColour(vec4 inColor) { + return floor(quantiser * inColor + halfvec) * quantiserDivider; +} + +vec4 getDitherredDot(vec4 inColor) { + vec2 entry = mod(gl_FragCoord.xy, vec2(bayerSize, bayerSize)); + int index = int(entry.y) * int(bayerSize) + int(entry.x); + vec4 bayerThreshold = vec4(bayerTex[index] / bayerDivider - 0.5); + return nearestColour(inColor + bayerThreshold * quantiserDivider); +} + +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 * boolean.yyyx + inColor * boolean.xxxy; // use quantised RGB but not the A +} \ No newline at end of file diff --git a/assets/rgbonly.frag b/assets/rgbonly.frag index fed6005ff..9c9c50456 100644 --- a/assets/rgbonly.frag +++ b/assets/rgbonly.frag @@ -2,7 +2,8 @@ varying vec4 v_color; varying vec2 v_texCoords; uniform sampler2D u_texture; +vec2 boolean = vec2(0.0, 1.0); + void main(void) { - vec3 color = texture2D(u_texture, v_texCoords).rgb; - gl_FragColor = vec4(color, 1.0); + gl_FragColor = texture2D(u_texture, v_texCoords).rgba * boolean.yyyx + boolean.xxxy; } \ No newline at end of file diff --git a/src/net/torvald/terrarum/UIFakeGradOverlay.kt b/src/net/torvald/terrarum/UIFakeGradOverlay.kt index 7cdf3b8b3..b85126de8 100644 --- a/src/net/torvald/terrarum/UIFakeGradOverlay.kt +++ b/src/net/torvald/terrarum/UIFakeGradOverlay.kt @@ -55,8 +55,6 @@ class UIFakeBlurOverlay(val blurRadius: Float, val nodarken: Boolean) : UICanvas override var openCloseTime: Second = 0f - private val shaderBlur = App.loadShaderFromFile("assets/blur.vert", "assets/blur.frag") - private val darken = Color(0.5f, 0.5f, 0.5f, 1f) override fun updateUI(delta: Float) {} @@ -79,6 +77,5 @@ class UIFakeBlurOverlay(val blurRadius: Float, val nodarken: Boolean) : UICanvas override fun endOpening(delta: Float) {} override fun endClosing(delta: Float) {} override fun dispose() { - shaderBlur.dispose() } } \ No newline at end of file diff --git a/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt b/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt index 15b15f105..95fd6c50f 100644 --- a/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt +++ b/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt @@ -17,7 +17,6 @@ import net.torvald.terrarum.gamecontroller.KeyToggler import net.torvald.terrarum.gameparticles.ParticleBase import net.torvald.terrarum.gameworld.GameWorld import net.torvald.terrarum.gameworld.fmod -import net.torvald.terrarum.ui.UICanvas import net.torvald.terrarum.weather.WeatherMixer import net.torvald.terrarum.worlddrawer.BlocksDrawer import net.torvald.terrarum.worlddrawer.FeaturesDrawer @@ -30,6 +29,11 @@ import kotlin.system.exitProcess * This will be rendered to a postprocessor FBO. * * For the entire render path, see AppLoader. + * + * NOTE: config "fx_dither" only controls the skybox (which is capable of having more than 256 colours + * thanks to the hardware linear intp.) because this dithering shader is somewhat heavy. + * + * Actors' transparency (and not an UI) still uses its own lightweight ditherrer */ object IngameRenderer : Disposable { /** for non-private use, use with care! */ @@ -53,12 +57,26 @@ object IngameRenderer : Disposable { // you must have lightMixed FBO; otherwise you'll be reading from unbaked FBO and it freaks out GPU + inline fun isDither() = App.getConfigBoolean("fx_dither") + val shaderBlur: ShaderProgram - val shaderBayer: ShaderProgram - val shaderBlendGlow: ShaderProgram + get() = if (isDither()) shaderBlurDither else shaderBlurRaw val shaderRGBOnly: ShaderProgram + get() = if (isDither()) shaderRGBOnlyDither else shaderRGBOnlyRaw val shaderAtoGrey: ShaderProgram + get() = if (isDither()) shaderAtoGreyDither else shaderAtoGreyRaw + + val shaderBlurDither: ShaderProgram + val shaderBlurRaw: ShaderProgram + val shaderRGBOnlyDither: ShaderProgram + val shaderRGBOnlyRaw: ShaderProgram + val shaderAtoGreyDither: ShaderProgram + val shaderAtoGreyRaw: ShaderProgram + + val shaderBayer: ShaderProgram val shaderPassthru = SpriteBatch.createDefaultShader() + + val shaderBlendGlow: ShaderProgram val shaderAlphaDither: ShaderProgram private val WIDTH = App.scr.width @@ -70,9 +88,7 @@ object IngameRenderer : Disposable { private var player: ActorWithBody? = null - var uiListToDraw: List = arrayListOf() - - const val lightmapDownsample = 4f //2f: still has choppy look when the camera moves but unnoticeable when blurred + const val lightmapDownsample = 1f//4f //2f: still has choppy look when the camera moves but unnoticeable when blurred private var debugMode = 0 @@ -92,14 +108,18 @@ object IngameRenderer : Disposable { // these codes will run regardless of the invocation of the "initialise()" function // the "initialise()" function will also be called init { - shaderBlur = App.loadShaderFromFile("assets/blur.vert", "assets/blur.frag") + shaderBlurDither = App.loadShaderFromFile("assets/blur.vert", "assets/blur_dither.frag") + shaderRGBOnlyDither = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer_rgb1.frag") + shaderAtoGreyDither = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer_aaa1.frag") + + shaderBlurRaw = App.loadShaderFromFile("assets/blur.vert", "assets/blur.frag") + shaderRGBOnlyRaw = App.loadShaderFromFile("assets/4096.vert", "assets/rgbonly.frag") + shaderAtoGreyRaw = App.loadShaderFromFile("assets/4096.vert", "assets/aonly.frag") shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer.frag") // always load the shader regardless of config because the config may cange shaderAlphaDither = App.loadShaderFromFile("assets/4096.vert", "assets/alphadither.frag") shaderBlendGlow = App.loadShaderFromFile("assets/blendGlow.vert", "assets/blendGlow.frag") - shaderRGBOnly = App.loadShaderFromFile("assets/4096.vert", "assets/rgbonly.frag") - shaderAtoGrey = App.loadShaderFromFile("assets/4096.vert", "assets/aonly.frag") if (!shaderBlendGlow.isCompiled) { @@ -108,7 +128,7 @@ object IngameRenderer : Disposable { } - if (App.getConfigBoolean("fx_dither")) { + if (isDither()) { if (!shaderBayer.isCompiled) { Gdx.app.log("shaderBayer", shaderBayer.log) exitProcess(1) @@ -402,7 +422,7 @@ object IngameRenderer : Disposable { fboRGB.inAction(camera, batch) { batch.inUse { - batch.shader = null + batch.shader = shaderAlphaDither batch.color = Color.WHITE } @@ -421,7 +441,7 @@ object IngameRenderer : Disposable { setCameraPosition(0f, 0f) BlocksDrawer.drawTerrain(batch.projectionMatrix, false) - batch.shader = null + batch.shader = shaderAlphaDither batch.inUse { ///////////////// // draw actors // @@ -498,7 +518,7 @@ object IngameRenderer : Disposable { fboA.inAction(camera, batch) { batch.inUse { - batch.shader = null + batch.shader = shaderAlphaDither batch.color = Color.WHITE } @@ -566,7 +586,7 @@ object IngameRenderer : Disposable { fboRGB_lightMixed.inAction(camera, batch) { batch.inUse { - batch.shader = null + batch.shader = shaderAlphaDither batch.color = Color.WHITE } @@ -746,11 +766,16 @@ object IngameRenderer : Disposable { batch.dispose() - shaderBlur.dispose() + + shaderBlurDither.dispose() + shaderBlurRaw.dispose() + shaderRGBOnlyDither.dispose() + shaderRGBOnlyRaw.dispose() + shaderAtoGreyDither.dispose() + shaderAtoGreyRaw.dispose() + shaderBayer.dispose() shaderBlendGlow.dispose() - shaderRGBOnly.dispose() - shaderAtoGrey.dispose() shaderPassthru.dispose() shaderAlphaDither.dispose() diff --git a/src/net/torvald/terrarum/ui/Toolkit.kt b/src/net/torvald/terrarum/ui/Toolkit.kt index f8bb675b0..d3fb63400 100644 --- a/src/net/torvald/terrarum/ui/Toolkit.kt +++ b/src/net/torvald/terrarum/ui/Toolkit.kt @@ -7,6 +7,7 @@ import com.badlogic.gdx.graphics.Pixmap import com.badlogic.gdx.graphics.Texture import com.badlogic.gdx.graphics.g2d.SpriteBatch import com.badlogic.gdx.graphics.g2d.TextureRegion +import com.badlogic.gdx.graphics.glutils.ShaderProgram import com.badlogic.gdx.utils.Disposable import net.torvald.terrarum.App import net.torvald.terrarum.CommonResourcePool @@ -22,7 +23,9 @@ object Toolkit : Disposable { val DEFAULT_BOX_BORDER_COL = Color(1f, 1f, 1f, 0.2f) - private val shaderBlur = App.loadShaderFromFile("assets/blur.vert", "assets/blur2.frag") + val shaderBlur: ShaderProgram + get() = if (IngameRenderer.isDither()) IngameRenderer.shaderBlurDither else IngameRenderer.shaderBlurRaw + val baloonTile = TextureRegionPack("assets/graphics/gui/message_black_tileable.tga", 36, 36, flipY = true) diff --git a/src/net/torvald/terrarum/ui/UIAutosaveNotifier.kt b/src/net/torvald/terrarum/ui/UIAutosaveNotifier.kt index 2908a3029..6626f2a06 100644 --- a/src/net/torvald/terrarum/ui/UIAutosaveNotifier.kt +++ b/src/net/torvald/terrarum/ui/UIAutosaveNotifier.kt @@ -55,14 +55,13 @@ class UIAutosaveNotifier : UICanvas() { val offX = (App.scr.tvSafeGraphicsWidth * 1.25f).roundToInt().toFloat() val offY = App.scr.tvSafeGraphicsHeight + 9f // +9 to align to quickslot and watch UI - val text = if (errored) Lang["ERROR_GENERIC_TEXT"] else Lang["MENU_IO_SAVING"] + val text = if (errored) Lang["ERROR_GENERIC_TEXT"].replace(".","") else Lang["MENU_IO_SAVING"] batch.color = if (errored) errorCol else normalCol if (!errored) batch.draw(spin, offX, offY)// else RED_X_SYMBOL App.fontGame.draw(batch, text, offX + 30f, offY) } fun setAsError() { - println("ugh, diddums") errored = true }