Paste your logs.

Built for Minecraft & Hytale

Forge 1.18.1 Client Log

176 errors
20697 lines
Raw
Detected
Minecraft version: 1.18.1 Forge version: 39.0.17 Java version: 17.0.1
1
[11Jan2022 17:17:12.316] [main/INFO] [cpw.mods.modlauncher.Launcher/MODLAUNCHER]: ModLauncher running: args [--username, DvI_y, --version, 1.18.1-forge-39.0.17, --gameDir, C:\Users\PC\AppData\Roaming\.minecraft, --assetsDir, C:\Users\PC\AppData\Roaming\.minecraft\assets, --assetIndex, 1.18, --uuid, 5e8660f7df7b4aad8405bd65e7b7e8f5, --accessToken, ????????, --clientId, NTg2NDg1ODEtNTBmNC00YTk1LTgyN2EtMTdkZGI0Y2UyY2Yx, --xuid, 2535405237799348, --userType, msa, --versionType, release, --launchTarget, forgeclient, --fml.forgeVersion, 39.0.17, --fml.mcVersion, 1.18.1, --fml.forgeGroup, net.minecraftforge, --fml.mcpVersion, 20211210.034407]
2
[11Jan2022 17:17:12.321] [main/INFO] [cpw.mods.modlauncher.Launcher/MODLAUNCHER]: ModLauncher 9.0.7+91+master.8569cdf starting: java version 17.0.1 by Microsoft
3
[11Jan2022 17:17:12.569] [main/INFO] [optifine.OptiFineTransformationService/]: OptiFineTransformationService.onLoad
4
[11Jan2022 17:17:12.570] [main/INFO] [optifine.OptiFineTransformationService/]: OptiFine ZIP file URL: union:/C:/Users/PC/AppData/Roaming/.minecraft/mods/OptiFine_1.18.1_HD_U_H4.jar%2352!
5
[11Jan2022 17:17:12.580] [main/INFO] [optifine.OptiFineTransformationService/]: OptiFine ZIP file: C:\Users\PC\AppData\Roaming\.minecraft\mods\OptiFine_1.18.1_HD_U_H4.jar
6
[11Jan2022 17:17:12.582] [main/INFO] [optifine.OptiFineTransformer/]: Target.PRE_CLASS is available
7
[11Jan2022 17:17:12.653] [main/INFO] [mixin/]: SpongePowered MIXIN Subsystem Version=0.8.5 Source=union:/C:/Users/PC/AppData/Roaming/.minecraft/libraries/org/spongepowered/mixin/0.8.5/mixin-0.8.5.jar%2319! Service=ModLauncher Env=CLIENT
8
[11Jan2022 17:17:12.662] [main/INFO] [optifine.OptiFineTransformationService/]: OptiFineTransformationService.initialize
9
[11Jan2022 17:17:13.653] [main/INFO] [optifine.OptiFineTransformationService/]: OptiFineTransformationService.transformers
10
[11Jan2022 17:17:13.659] [main/INFO] [optifine.OptiFineTransformer/]: Targets: 342
11
[11Jan2022 17:17:14.110] [main/INFO] [optifine.OptiFineTransformationService/]: additionalClassesLocator: [optifine., net.optifine.]
12
[11Jan2022 17:17:14.553] [main/INFO] [mixin/]: Compatibility level set to JAVA_17
13
[11Jan2022 17:17:14.559] [main/INFO] [cpw.mods.modlauncher.LaunchServiceHandler/MODLAUNCHER]: Launching target 'forgeclient' with arguments [--version, 1.18.1-forge-39.0.17, --gameDir, C:\Users\PC\AppData\Roaming\.minecraft, --assetsDir, C:\Users\PC\AppData\Roaming\.minecraft\assets, --uuid, 5e8660f7df7b4aad8405bd65e7b7e8f5, --username, DvI_y, --assetIndex, 1.18, --accessToken, ????????, --clientId, NTg2NDg1ODEtNTBmNC00YTk1LTgyN2EtMTdkZGI0Y2UyY2Yx, --xuid, 2535405237799348, --userType, msa, --versionType, release]
14
[11Jan2022 17:17:14.883] [main/WARN] [mixin/]: Error loading class: net/minecraft/client/renderer/LevelRenderer (java.lang.UnsupportedOperationException: PermittedSubclasses requires ASM9)
15
[11Jan2022 17:17:14.883] [main/WARN] [mixin/]: @Mixin target net.minecraft.client.renderer.LevelRenderer was not found flywheel.mixins.json:CancelEntityRenderMixin
16
[17:17:23] [Render thread/WARN]: Assets URL 'union:/C:/Users/PC/AppData/Roaming/.minecraft/libraries/net/minecraft/client/1.18.1-20211210.034407/client-1.18.1-20211210.034407-srg.jar%2357!/assets/.mcassetsroot' uses unexpected schema
17
[17:17:23] [Render thread/WARN]: Assets URL 'union:/C:/Users/PC/AppData/Roaming/.minecraft/libraries/net/minecraft/client/1.18.1-20211210.034407/client-1.18.1-20211210.034407-srg.jar%2357!/data/.mcassetsroot' uses unexpected schema
18
[11Jan2022 17:17:23.450] [Render thread/INFO] [com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService/]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD'
19
[17:17:24] [Render thread/INFO]: Setting user: DvI_y
20
[17:17:24] [Render thread/INFO]: [OptiFine] (Reflector) Class not present: net.minecraft.launchwrapper.Launch
21
[17:17:24] [Render thread/INFO]: Backend library: LWJGL version 3.2.2 SNAPSHOT
22
[17:17:25] [Render thread/INFO]: [OptiFine]
23
[17:17:25] [Render thread/INFO]: [OptiFine] OptiFine_1.18.1_HD_U_H4
24
[17:17:25] [Render thread/INFO]: [OptiFine] Build: 20211212-175054
25
[17:17:25] [Render thread/INFO]: [OptiFine] OS: Windows 10 (amd64) version 10.0
26
[17:17:25] [Render thread/INFO]: [OptiFine] Java: 17.0.1, Microsoft
27
[17:17:25] [Render thread/INFO]: [OptiFine] VM: OpenJDK 64-Bit Server VM (mixed mode), Microsoft
28
[17:17:25] [Render thread/INFO]: [OptiFine] LWJGL: 3.3.0 Win32 WGL EGL OSMesa VisualC DLL
29
[17:17:25] [Render thread/INFO]: [OptiFine] OpenGL: Radeon RX 580 Series, version 3.2.14761 Core Profile Forward-Compatible Context 21.10.2 30.0.13025.5005, ATI Technologies Inc.
30
[17:17:25] [Render thread/INFO]: [OptiFine] OpenGL Version: 3.2.14761
31
[17:17:25] [Render thread/INFO]: [OptiFine] Maximum texture size: 16384x16384
32
[17:17:25] [VersionCheck/INFO]: [OptiFine] Checking for new version
33
[17:17:25] [Render thread/INFO]: [Shaders] OpenGL Version: 3.2.14761 Core Profile Forward-Compatible Context 21.10.2 30.0.13025.5005
34
[17:17:25] [Render thread/INFO]: [Shaders] Vendor: ATI Technologies Inc.
35
[17:17:25] [Render thread/INFO]: [Shaders] Renderer: Radeon RX 580 Series
36
[17:17:25] [Render thread/INFO]: [Shaders] Capabilities: 2.0 2.1 3.0 3.2 -
37
[17:17:25] [Render thread/INFO]: [Shaders] GL_MAX_DRAW_BUFFERS: 8
38
[17:17:25] [Render thread/INFO]: [Shaders] GL_MAX_COLOR_ATTACHMENTS: 8
39
[17:17:25] [Render thread/INFO]: [Shaders] GL_MAX_TEXTURE_IMAGE_UNITS: 32
40
[17:17:25] [Render thread/INFO]: [Shaders] Load shaders configuration.
41
[17:17:25] [Render thread/INFO]: [Shaders] No shaderpack loaded.
42
[17:17:25] [Render thread/INFO]: [OptiFine] [Shaders] Delayed loading of item mappings after resources are loaded
43
[17:17:25] [Render thread/INFO]: [OptiFine] [Shaders] Delayed loading of entity mappings after resources are loaded
44
[17:17:26] [modloading-worker-0/INFO]: Forge mod loading, version 39.0.17, for MC 1.18.1 with MCP 20211210.034407
45
[17:17:26] [modloading-worker-0/INFO]: MinecraftForge v39.0.17 Initialized
46
[17:17:26] [modloading-worker-0/INFO]: Optifine detected.
47
[17:17:26] [modloading-worker-0/INFO]: Successfully loaded com.jozufozu.flywheel.mixin.PausedPartialTickAccessor
48
[17:17:26] [VersionCheck/INFO]: [OptiFine] java.io.FileNotFoundException: http://optifine.net/version/1.18.1/HD_U.txt
49
[17:17:26] [modloading-worker-0/INFO]: Detected new forge version, registering events reflectively.
50
[17:17:29] [Render thread/INFO]: Potentially Dangerous alternative prefix `minecraft` for name `milk`, expected `forge`. This could be a intended override, but in most cases indicates a broken mod.
51
[17:17:29] [Render thread/INFO]: Potentially Dangerous alternative prefix `minecraft` for name `flowing_milk`, expected `forge`. This could be a intended override, but in most cases indicates a broken mod.
52
[17:17:29] [Render thread/WARN]: [OptiFine] (Reflector) java.lang.ClassNotFoundException: sun.misc.SharedSecrets
53
[17:17:29] [Render thread/WARN]: [OptiFine] (Reflector) java.lang.ClassNotFoundException: jdk.internal.misc.SharedSecrets
54
[17:17:29] [Render thread/WARN]: [OptiFine] (Reflector) java.lang.ClassNotFoundException: sun.misc.VM
55
[17:17:29] [Render thread/WARN]: [OptiFine] (Reflector) java.lang.reflect.InaccessibleObjectException: Unable to make public static long jdk.internal.misc.VM.maxDirectMemory() accessible: module java.base does not "exports jdk.internal.misc" to module net.optifine
56
[11Jan2022 17:17:30.466] [Render thread/INFO] [com.mojang.text2speech.NarratorWindows/]: Narrator library for x64 successfully loaded
57
[17:17:30] [Render thread/INFO]: Reloading ResourceManager: Default, Mod Resources
58
[17:17:30] [Render thread/INFO]: [OptiFine] *** Reloading textures ***
59
[17:17:30] [Render thread/INFO]: [OptiFine] Resource packs: Mod Resources
60
[17:17:30] [Render thread/INFO]: [OptiFine] *** Reflector Forge ***
61
[17:17:30] [Render thread/INFO]: [OptiFine] (Reflector) Class not present: mods.betterfoliage.client.BetterFoliageClient
62
[17:17:31] [Render thread/INFO]: [OptiFine] *** Reflector Vanilla ***
63
[17:17:31] [Worker-Main-9/INFO]: [OptiFine] Multitexture: false
64
[17:17:31] [Worker-Main-15/INFO]: [OptiFine] Multitexture: false
65
[17:17:31] [Worker-Main-13/INFO]: [OptiFine] Multitexture: false
66
[17:17:31] [Worker-Main-12/INFO]: [OptiFine] Multitexture: false
67
[11Jan2022 17:17:31.876] [Forge Version Check/INFO] [net.minecraftforge.fml.VersionChecker/]: [forge] Starting version check at https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json
68
[17:17:32] [Worker-Main-12/INFO]: [OptiFine] Scaled non power of 2: jei:gui/icons/recipe_transfer, 7 -> 14
69
[17:17:32] [Worker-Main-15/INFO]: Loading Xaero's Minimap - Stage 1/2
70
[17:17:33] [Render thread/INFO]: Loading Xaero's Minimap - Stage 2/2
71
[11Jan2022 17:17:33.167] [Forge Version Check/INFO] [net.minecraftforge.fml.VersionChecker/]: [forge] Found status: BETA_OUTDATED Current: 39.0.17 Target: 39.0.18
72
[17:17:39] [Worker-Main-11/WARN]: [OptiFine] Unknown resource pack file: mod_resources
73
[17:17:39] [Worker-Main-11/WARN]: [OptiFine] Unknown resource pack file: mod_resources
74
[17:17:39] [Worker-Main-11/WARN]: [OptiFine] Unknown resource pack file: mod_resources
75
[17:17:39] [Worker-Main-11/WARN]: [OptiFine] Unknown resource pack file: mod_resources
76
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
77
[17:17:40] [Worker-Main-11/WARN]: [OptiFine] Unknown resource pack file: mod_resources
78
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] Multipass connected textures: false
79
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/00_glass_white/glass_pane_white.properties
80
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/00_glass_white/glass_white.properties
81
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/01_glass_orange/glass_orange.properties
82
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/01_glass_orange/glass_pane_orange.properties
83
[17:17:40] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/02_glass_magenta/glass_magenta.properties
84
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/02_glass_magenta/glass_pane_magenta.properties
85
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/03_glass_light_blue/glass_light_blue.properties
86
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/03_glass_light_blue/glass_pane_light_blue.properties
87
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/04_glass_yellow/glass_pane_yellow.properties
88
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/04_glass_yellow/glass_yellow.properties
89
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/05_glass_lime/glass_lime.properties
90
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/05_glass_lime/glass_pane_lime.properties
91
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/06_glass_pink/glass_pane_pink.properties
92
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/06_glass_pink/glass_pink.properties
93
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/07_glass_gray/glass_gray.properties
94
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/07_glass_gray/glass_pane_gray.properties
95
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/08_glass_light_gray/glass_light_gray.properties
96
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/08_glass_light_gray/glass_pane_light_gray.properties
97
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/09_glass_cyan/glass_cyan.properties
98
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/09_glass_cyan/glass_pane_cyan.properties
99
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/10_glass_purple/glass_pane_purple.properties
100
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/10_glass_purple/glass_purple.properties
101
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/11_glass_blue/glass_blue.properties
102
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/11_glass_blue/glass_pane_blue.properties
103
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/12_glass_brown/glass_brown.properties
104
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/12_glass_brown/glass_pane_brown.properties
105
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/13_glass_green/glass_green.properties
106
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/13_glass_green/glass_pane_green.properties
107
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/14_glass_red/glass_pane_red.properties
108
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/14_glass_red/glass_red.properties
109
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/15_glass_black/glass_black.properties
110
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/15_glass_black/glass_pane_black.properties
111
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/20_glass/glass.properties
112
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/20_glass/glass_pane.properties
113
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/21_tinted_glass/tinted_glass.properties
114
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/30_bookshelf/bookshelf.properties
115
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/40_sandstone/sandstone.properties
116
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/41_red_sandstone/red_sandstone.properties
117
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] Multipass connected textures: false
118
[17:17:41] [Worker-Main-11/INFO]: [OptiFine] BetterGrass: Parsing default configuration optifine/bettergrass.properties
119
[17:17:46] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 4
120
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
121
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
122
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
123
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
124
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
125
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
126
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
127
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
128
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
129
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
130
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
131
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
132
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
133
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
134
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
135
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
136
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
137
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
138
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
139
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
140
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Multitexture: false
141
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Sprite size: 64
142
[17:17:48] [Worker-Main-11/INFO]: [OptiFine] Mipmap levels: 6
143
[17:17:48] [Worker-Main-11/WARN]: Unused frames in sprite minecraft:missingno: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
144
[17:17:48] [Render thread/INFO]: Loading context 'flywheel:context/crumbling'
145
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
146
147
[17:17:48] [Render thread/ERROR]: #version 150
148
#extension GL_ARB_conservative_depth : enable
149
#define VERTEX_SHADER
150
#if defined(VERTEX_SHADER)
151
out float FragDistance;
152
#elif defined(FRAGMENT_SHADER)
153
in float FragDistance;
154
#endif
155
uniform vec4 uFogColor;
156
uniform vec2 uFogRange;
157
158
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
159
float distXZ = length(worldPos.xz - cameraPos.xz);
160
float distY = abs(worldPos.y - cameraPos.y);
161
return max(distXZ, distY);
162
}
163
164
float cylindrical_distance(vec3 worldPos) {
165
float distXZ = length(worldPos.xz);
166
float distY = abs(worldPos.y);
167
return max(distXZ, distY);
168
}
169
170
float FLWFogFactor() {
171
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
172
}
173
174
175
uniform float uTime;
176
uniform mat4 uViewProjection;
177
uniform vec3 uCameraPos;
178
179
uniform vec2 uTextureScale;
180
uniform sampler2D uBlockAtlas;
181
uniform sampler2D uLightMap;
182
uniform sampler2D uCrumbling;
183
184
uniform vec2 uWindowSize;
185
186
void FLWFinalizeNormal(inout vec3 normal) {
187
// noop
188
}
189
190
#if defined(VERTEX_SHADER)
191
void FLWFinalizeWorldPos(inout vec4 worldPos) {
192
#if defined(USE_FOG)
193
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
194
#endif
195
196
gl_Position = uViewProjection * worldPos;
197
}
198
199
#elif defined(FRAGMENT_SHADER)
200
201
out vec4 fragColor;
202
203
vec4 FLWBlockTexture(vec2 texCoords) {
204
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
205
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
206
cr.a = cr.a * diffuseAlpha;
207
return cr;
208
}
209
210
void FLWFinalizeColor(vec4 color) {
211
#if defined(USE_FOG)
212
float a = color.a;
213
float fog = clamp(FLWFogFactor(), 0., 1.);
214
215
color = mix(uFogColor, color, fog);
216
color.a = a;
217
#endif
218
219
if (color.a < 0.1) {
220
discard;
221
}
222
223
fragColor = color;
224
}
225
226
vec4 FLWLight(vec2 lightCoords) {
227
return vec4(1.);
228
}
229
#endif
230
231
232
float diffuse(vec3 normal) {
233
vec3 n2 = normal * normal * vec3(.6, .25, .8);
234
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
235
}
236
struct Vertex {
237
vec3 pos;
238
vec2 texCoords;
239
vec3 normal;
240
};
241
242
struct BlockFrag {
243
vec2 texCoords;
244
vec4 color;
245
float diffuse;
246
vec2 light;
247
};
248
249
#if defined(FRAGMENT_SHADER)
250
void fragment(BlockFrag r) {
251
vec4 tex = FLWBlockTexture(r.texCoords);
252
253
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
254
255
FLWFinalizeColor(color);
256
}
257
#endif
258
259
260
261
262
struct Instance {
263
vec2 light;
264
vec4 color;
265
mat4 transform;
266
mat3 normalMat;
267
};
268
269
#if defined(VERTEX_SHADER)
270
BlockFrag vertex(Vertex v, Instance i) {
271
vec4 worldPos = i.transform * vec4(v.pos, 1.);
272
273
vec3 norm = i.normalMat * v.normal;
274
275
FLWFinalizeWorldPos(worldPos);
276
FLWFinalizeNormal(norm);
277
278
norm = normalize(norm);
279
280
BlockFrag b;
281
b.diffuse = diffuse(norm);
282
b.texCoords = v.texCoords;
283
b.light = i.light;
284
#if defined(DEBUG_NORMAL)
285
b.color = vec4(norm, 1.);
286
#else
287
b.color = i.color;
288
#endif
289
return b;
290
}
291
#endif
292
293
in vec3 a_v_pos;
294
in vec2 a_v_texCoords;
295
in vec3 a_v_normal;
296
in vec2 a_i_light;
297
in vec4 a_i_color;
298
in mat4 a_i_transform;
299
in mat3 a_i_normalMat;
300
out vec2 v2f_texCoords;
301
out vec4 v2f_color;
302
out float v2f_diffuse;
303
out vec2 v2f_light;
304
void main() {
305
Vertex v;
306
v.pos = a_v_pos;
307
v.texCoords = a_v_texCoords;
308
v.normal = a_v_normal;
309
Instance i;
310
i.light = a_i_light;
311
i.color = a_i_color;
312
i.transform = a_i_transform;
313
i.normalMat = a_i_normalMat;
314
BlockFrag o = vertex(v, i);
315
v2f_texCoords = o.texCoords;
316
v2f_color = o.color;
317
v2f_diffuse = o.diffuse;
318
v2f_light = o.light;
319
}
320
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
321
322
[17:17:48] [Render thread/ERROR]: #version 150
323
#extension GL_ARB_conservative_depth : enable
324
#define FRAGMENT_SHADER
325
#if defined(VERTEX_SHADER)
326
out float FragDistance;
327
#elif defined(FRAGMENT_SHADER)
328
in float FragDistance;
329
#endif
330
uniform vec4 uFogColor;
331
uniform vec2 uFogRange;
332
333
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
334
float distXZ = length(worldPos.xz - cameraPos.xz);
335
float distY = abs(worldPos.y - cameraPos.y);
336
return max(distXZ, distY);
337
}
338
339
float cylindrical_distance(vec3 worldPos) {
340
float distXZ = length(worldPos.xz);
341
float distY = abs(worldPos.y);
342
return max(distXZ, distY);
343
}
344
345
float FLWFogFactor() {
346
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
347
}
348
349
350
uniform float uTime;
351
uniform mat4 uViewProjection;
352
uniform vec3 uCameraPos;
353
354
uniform vec2 uTextureScale;
355
uniform sampler2D uBlockAtlas;
356
uniform sampler2D uLightMap;
357
uniform sampler2D uCrumbling;
358
359
uniform vec2 uWindowSize;
360
361
void FLWFinalizeNormal(inout vec3 normal) {
362
// noop
363
}
364
365
#if defined(VERTEX_SHADER)
366
void FLWFinalizeWorldPos(inout vec4 worldPos) {
367
#if defined(USE_FOG)
368
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
369
#endif
370
371
gl_Position = uViewProjection * worldPos;
372
}
373
374
#elif defined(FRAGMENT_SHADER)
375
376
out vec4 fragColor;
377
378
vec4 FLWBlockTexture(vec2 texCoords) {
379
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
380
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
381
cr.a = cr.a * diffuseAlpha;
382
return cr;
383
}
384
385
void FLWFinalizeColor(vec4 color) {
386
#if defined(USE_FOG)
387
float a = color.a;
388
float fog = clamp(FLWFogFactor(), 0., 1.);
389
390
color = mix(uFogColor, color, fog);
391
color.a = a;
392
#endif
393
394
if (color.a < 0.1) {
395
discard;
396
}
397
398
fragColor = color;
399
}
400
401
vec4 FLWLight(vec2 lightCoords) {
402
return vec4(1.);
403
}
404
#endif
405
406
407
float diffuse(vec3 normal) {
408
vec3 n2 = normal * normal * vec3(.6, .25, .8);
409
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
410
}
411
struct Vertex {
412
vec3 pos;
413
vec2 texCoords;
414
vec3 normal;
415
};
416
417
struct BlockFrag {
418
vec2 texCoords;
419
vec4 color;
420
float diffuse;
421
vec2 light;
422
};
423
424
#if defined(FRAGMENT_SHADER)
425
void fragment(BlockFrag r) {
426
vec4 tex = FLWBlockTexture(r.texCoords);
427
428
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
429
430
FLWFinalizeColor(color);
431
}
432
#endif
433
434
435
436
437
struct Instance {
438
vec2 light;
439
vec4 color;
440
mat4 transform;
441
mat3 normalMat;
442
};
443
444
#if defined(VERTEX_SHADER)
445
BlockFrag vertex(Vertex v, Instance i) {
446
vec4 worldPos = i.transform * vec4(v.pos, 1.);
447
448
vec3 norm = i.normalMat * v.normal;
449
450
FLWFinalizeWorldPos(worldPos);
451
FLWFinalizeNormal(norm);
452
453
norm = normalize(norm);
454
455
BlockFrag b;
456
b.diffuse = diffuse(norm);
457
b.texCoords = v.texCoords;
458
b.light = i.light;
459
#if defined(DEBUG_NORMAL)
460
b.color = vec4(norm, 1.);
461
#else
462
b.color = i.color;
463
#endif
464
return b;
465
}
466
#endif
467
468
in vec2 v2f_texCoords;
469
in vec4 v2f_color;
470
in float v2f_diffuse;
471
in vec2 v2f_light;
472
void main() {
473
BlockFrag o;
474
o.texCoords = v2f_texCoords;
475
o.color = v2f_color;
476
o.diffuse = v2f_diffuse;
477
o.light = v2f_light;
478
fragment(o);
479
}
480
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
481
482
[17:17:48] [Render thread/ERROR]: #version 150
483
#extension GL_ARB_conservative_depth : enable
484
#define VERTEX_SHADER
485
#define DEBUG_NORMAL
486
#if defined(VERTEX_SHADER)
487
out float FragDistance;
488
#elif defined(FRAGMENT_SHADER)
489
in float FragDistance;
490
#endif
491
uniform vec4 uFogColor;
492
uniform vec2 uFogRange;
493
494
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
495
float distXZ = length(worldPos.xz - cameraPos.xz);
496
float distY = abs(worldPos.y - cameraPos.y);
497
return max(distXZ, distY);
498
}
499
500
float cylindrical_distance(vec3 worldPos) {
501
float distXZ = length(worldPos.xz);
502
float distY = abs(worldPos.y);
503
return max(distXZ, distY);
504
}
505
506
float FLWFogFactor() {
507
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
508
}
509
510
511
uniform float uTime;
512
uniform mat4 uViewProjection;
513
uniform vec3 uCameraPos;
514
515
uniform vec2 uTextureScale;
516
uniform sampler2D uBlockAtlas;
517
uniform sampler2D uLightMap;
518
uniform sampler2D uCrumbling;
519
520
uniform vec2 uWindowSize;
521
522
void FLWFinalizeNormal(inout vec3 normal) {
523
// noop
524
}
525
526
#if defined(VERTEX_SHADER)
527
void FLWFinalizeWorldPos(inout vec4 worldPos) {
528
#if defined(USE_FOG)
529
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
530
#endif
531
532
gl_Position = uViewProjection * worldPos;
533
}
534
535
#elif defined(FRAGMENT_SHADER)
536
537
out vec4 fragColor;
538
539
vec4 FLWBlockTexture(vec2 texCoords) {
540
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
541
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
542
cr.a = cr.a * diffuseAlpha;
543
return cr;
544
}
545
546
void FLWFinalizeColor(vec4 color) {
547
#if defined(USE_FOG)
548
float a = color.a;
549
float fog = clamp(FLWFogFactor(), 0., 1.);
550
551
color = mix(uFogColor, color, fog);
552
color.a = a;
553
#endif
554
555
if (color.a < 0.1) {
556
discard;
557
}
558
559
fragColor = color;
560
}
561
562
vec4 FLWLight(vec2 lightCoords) {
563
return vec4(1.);
564
}
565
#endif
566
567
568
float diffuse(vec3 normal) {
569
vec3 n2 = normal * normal * vec3(.6, .25, .8);
570
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
571
}
572
struct Vertex {
573
vec3 pos;
574
vec2 texCoords;
575
vec3 normal;
576
};
577
578
struct BlockFrag {
579
vec2 texCoords;
580
vec4 color;
581
float diffuse;
582
vec2 light;
583
};
584
585
#if defined(FRAGMENT_SHADER)
586
void fragment(BlockFrag r) {
587
vec4 tex = FLWBlockTexture(r.texCoords);
588
589
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
590
591
FLWFinalizeColor(color);
592
}
593
#endif
594
595
596
597
598
struct Instance {
599
vec2 light;
600
vec4 color;
601
mat4 transform;
602
mat3 normalMat;
603
};
604
605
#if defined(VERTEX_SHADER)
606
BlockFrag vertex(Vertex v, Instance i) {
607
vec4 worldPos = i.transform * vec4(v.pos, 1.);
608
609
vec3 norm = i.normalMat * v.normal;
610
611
FLWFinalizeWorldPos(worldPos);
612
FLWFinalizeNormal(norm);
613
614
norm = normalize(norm);
615
616
BlockFrag b;
617
b.diffuse = diffuse(norm);
618
b.texCoords = v.texCoords;
619
b.light = i.light;
620
#if defined(DEBUG_NORMAL)
621
b.color = vec4(norm, 1.);
622
#else
623
b.color = i.color;
624
#endif
625
return b;
626
}
627
#endif
628
629
in vec3 a_v_pos;
630
in vec2 a_v_texCoords;
631
in vec3 a_v_normal;
632
in vec2 a_i_light;
633
in vec4 a_i_color;
634
in mat4 a_i_transform;
635
in mat3 a_i_normalMat;
636
out vec2 v2f_texCoords;
637
out vec4 v2f_color;
638
out float v2f_diffuse;
639
out vec2 v2f_light;
640
void main() {
641
Vertex v;
642
v.pos = a_v_pos;
643
v.texCoords = a_v_texCoords;
644
v.normal = a_v_normal;
645
Instance i;
646
i.light = a_i_light;
647
i.color = a_i_color;
648
i.transform = a_i_transform;
649
i.normalMat = a_i_normalMat;
650
BlockFrag o = vertex(v, i);
651
v2f_texCoords = o.texCoords;
652
v2f_color = o.color;
653
v2f_diffuse = o.diffuse;
654
v2f_light = o.light;
655
}
656
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
657
658
[17:17:48] [Render thread/ERROR]: #version 150
659
#extension GL_ARB_conservative_depth : enable
660
#define FRAGMENT_SHADER
661
#define DEBUG_NORMAL
662
#if defined(VERTEX_SHADER)
663
out float FragDistance;
664
#elif defined(FRAGMENT_SHADER)
665
in float FragDistance;
666
#endif
667
uniform vec4 uFogColor;
668
uniform vec2 uFogRange;
669
670
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
671
float distXZ = length(worldPos.xz - cameraPos.xz);
672
float distY = abs(worldPos.y - cameraPos.y);
673
return max(distXZ, distY);
674
}
675
676
float cylindrical_distance(vec3 worldPos) {
677
float distXZ = length(worldPos.xz);
678
float distY = abs(worldPos.y);
679
return max(distXZ, distY);
680
}
681
682
float FLWFogFactor() {
683
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
684
}
685
686
687
uniform float uTime;
688
uniform mat4 uViewProjection;
689
uniform vec3 uCameraPos;
690
691
uniform vec2 uTextureScale;
692
uniform sampler2D uBlockAtlas;
693
uniform sampler2D uLightMap;
694
uniform sampler2D uCrumbling;
695
696
uniform vec2 uWindowSize;
697
698
void FLWFinalizeNormal(inout vec3 normal) {
699
// noop
700
}
701
702
#if defined(VERTEX_SHADER)
703
void FLWFinalizeWorldPos(inout vec4 worldPos) {
704
#if defined(USE_FOG)
705
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
706
#endif
707
708
gl_Position = uViewProjection * worldPos;
709
}
710
711
#elif defined(FRAGMENT_SHADER)
712
713
out vec4 fragColor;
714
715
vec4 FLWBlockTexture(vec2 texCoords) {
716
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
717
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
718
cr.a = cr.a * diffuseAlpha;
719
return cr;
720
}
721
722
void FLWFinalizeColor(vec4 color) {
723
#if defined(USE_FOG)
724
float a = color.a;
725
float fog = clamp(FLWFogFactor(), 0., 1.);
726
727
color = mix(uFogColor, color, fog);
728
color.a = a;
729
#endif
730
731
if (color.a < 0.1) {
732
discard;
733
}
734
735
fragColor = color;
736
}
737
738
vec4 FLWLight(vec2 lightCoords) {
739
return vec4(1.);
740
}
741
#endif
742
743
744
float diffuse(vec3 normal) {
745
vec3 n2 = normal * normal * vec3(.6, .25, .8);
746
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
747
}
748
struct Vertex {
749
vec3 pos;
750
vec2 texCoords;
751
vec3 normal;
752
};
753
754
struct BlockFrag {
755
vec2 texCoords;
756
vec4 color;
757
float diffuse;
758
vec2 light;
759
};
760
761
#if defined(FRAGMENT_SHADER)
762
void fragment(BlockFrag r) {
763
vec4 tex = FLWBlockTexture(r.texCoords);
764
765
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
766
767
FLWFinalizeColor(color);
768
}
769
#endif
770
771
772
773
774
struct Instance {
775
vec2 light;
776
vec4 color;
777
mat4 transform;
778
mat3 normalMat;
779
};
780
781
#if defined(VERTEX_SHADER)
782
BlockFrag vertex(Vertex v, Instance i) {
783
vec4 worldPos = i.transform * vec4(v.pos, 1.);
784
785
vec3 norm = i.normalMat * v.normal;
786
787
FLWFinalizeWorldPos(worldPos);
788
FLWFinalizeNormal(norm);
789
790
norm = normalize(norm);
791
792
BlockFrag b;
793
b.diffuse = diffuse(norm);
794
b.texCoords = v.texCoords;
795
b.light = i.light;
796
#if defined(DEBUG_NORMAL)
797
b.color = vec4(norm, 1.);
798
#else
799
b.color = i.color;
800
#endif
801
return b;
802
}
803
#endif
804
805
in vec2 v2f_texCoords;
806
in vec4 v2f_color;
807
in float v2f_diffuse;
808
in vec2 v2f_light;
809
void main() {
810
BlockFrag o;
811
o.texCoords = v2f_texCoords;
812
o.color = v2f_color;
813
o.diffuse = v2f_diffuse;
814
o.light = v2f_light;
815
fragment(o);
816
}
817
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
818
819
[17:17:48] [Render thread/ERROR]: #version 150
820
#extension GL_ARB_conservative_depth : enable
821
#define VERTEX_SHADER
822
#if defined(VERTEX_SHADER)
823
out float FragDistance;
824
#elif defined(FRAGMENT_SHADER)
825
in float FragDistance;
826
#endif
827
uniform vec4 uFogColor;
828
uniform vec2 uFogRange;
829
830
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
831
float distXZ = length(worldPos.xz - cameraPos.xz);
832
float distY = abs(worldPos.y - cameraPos.y);
833
return max(distXZ, distY);
834
}
835
836
float cylindrical_distance(vec3 worldPos) {
837
float distXZ = length(worldPos.xz);
838
float distY = abs(worldPos.y);
839
return max(distXZ, distY);
840
}
841
842
float FLWFogFactor() {
843
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
844
}
845
846
847
uniform float uTime;
848
uniform mat4 uViewProjection;
849
uniform vec3 uCameraPos;
850
851
uniform vec2 uTextureScale;
852
uniform sampler2D uBlockAtlas;
853
uniform sampler2D uLightMap;
854
uniform sampler2D uCrumbling;
855
856
uniform vec2 uWindowSize;
857
858
void FLWFinalizeNormal(inout vec3 normal) {
859
// noop
860
}
861
862
#if defined(VERTEX_SHADER)
863
void FLWFinalizeWorldPos(inout vec4 worldPos) {
864
#if defined(USE_FOG)
865
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
866
#endif
867
868
gl_Position = uViewProjection * worldPos;
869
}
870
871
#elif defined(FRAGMENT_SHADER)
872
873
out vec4 fragColor;
874
875
vec4 FLWBlockTexture(vec2 texCoords) {
876
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
877
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
878
cr.a = cr.a * diffuseAlpha;
879
return cr;
880
}
881
882
void FLWFinalizeColor(vec4 color) {
883
#if defined(USE_FOG)
884
float a = color.a;
885
float fog = clamp(FLWFogFactor(), 0., 1.);
886
887
color = mix(uFogColor, color, fog);
888
color.a = a;
889
#endif
890
891
if (color.a < 0.1) {
892
discard;
893
}
894
895
fragColor = color;
896
}
897
898
vec4 FLWLight(vec2 lightCoords) {
899
return vec4(1.);
900
}
901
#endif
902
903
904
#define PIOVER2 1.5707963268
905
906
vec4 quat(vec3 axis, float angle) {
907
float halfAngle = angle * PIOVER2 / 180.0;
908
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
909
return vec4(axis.xyz * cs.y, cs.x);
910
}
911
912
vec4 quatMult(vec4 q1, vec4 q2) {
913
// disgustingly vectorized quaternion multiplication
914
vec4 a = q1.w * q2.xyzw;
915
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
916
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
917
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
918
919
return a + b + c + d;
920
}
921
922
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
923
vec3 i = q.xyz;
924
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
925
}
926
927
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
928
return rotateVertexByQuat(v, quat(axis, angle));
929
}
930
931
float diffuse(vec3 normal) {
932
vec3 n2 = normal * normal * vec3(.6, .25, .8);
933
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
934
}
935
struct Vertex {
936
vec3 pos;
937
vec2 texCoords;
938
vec3 normal;
939
};
940
941
struct BlockFrag {
942
vec2 texCoords;
943
vec4 color;
944
float diffuse;
945
vec2 light;
946
};
947
948
#if defined(FRAGMENT_SHADER)
949
void fragment(BlockFrag r) {
950
vec4 tex = FLWBlockTexture(r.texCoords);
951
952
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
953
954
FLWFinalizeColor(color);
955
}
956
#endif
957
958
959
960
961
962
963
struct Oriented {
964
vec2 light;
965
vec4 color;
966
vec3 pos;
967
vec3 pivot;
968
vec4 rotation;
969
};
970
971
#if defined(VERTEX_SHADER)
972
BlockFrag vertex(Vertex v, Oriented o) {
973
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
974
975
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
976
977
FLWFinalizeWorldPos(worldPos);
978
FLWFinalizeNormal(norm);
979
980
BlockFrag b;
981
b.diffuse = diffuse(norm);
982
b.texCoords = v.texCoords;
983
b.light = o.light;
984
#if defined(DEBUG_NORMAL)
985
b.color = vec4(norm, 1.);
986
#else
987
b.color = o.color;
988
#endif
989
return b;
990
}
991
#endif
992
993
in vec3 a_v_pos;
994
in vec2 a_v_texCoords;
995
in vec3 a_v_normal;
996
in vec2 a_i_light;
997
in vec4 a_i_color;
998
in vec3 a_i_pos;
999
in vec3 a_i_pivot;
1000
in vec4 a_i_rotation;
1001
out vec2 v2f_texCoords;
1002
out vec4 v2f_color;
1003
out float v2f_diffuse;
1004
out vec2 v2f_light;
1005
void main() {
1006
Vertex v;
1007
v.pos = a_v_pos;
1008
v.texCoords = a_v_texCoords;
1009
v.normal = a_v_normal;
1010
Oriented i;
1011
i.light = a_i_light;
1012
i.color = a_i_color;
1013
i.pos = a_i_pos;
1014
i.pivot = a_i_pivot;
1015
i.rotation = a_i_rotation;
1016
BlockFrag o = vertex(v, i);
1017
v2f_texCoords = o.texCoords;
1018
v2f_color = o.color;
1019
v2f_diffuse = o.diffuse;
1020
v2f_light = o.light;
1021
}
1022
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
1023
1024
[17:17:48] [Render thread/ERROR]: #version 150
1025
#extension GL_ARB_conservative_depth : enable
1026
#define FRAGMENT_SHADER
1027
#if defined(VERTEX_SHADER)
1028
out float FragDistance;
1029
#elif defined(FRAGMENT_SHADER)
1030
in float FragDistance;
1031
#endif
1032
uniform vec4 uFogColor;
1033
uniform vec2 uFogRange;
1034
1035
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
1036
float distXZ = length(worldPos.xz - cameraPos.xz);
1037
float distY = abs(worldPos.y - cameraPos.y);
1038
return max(distXZ, distY);
1039
}
1040
1041
float cylindrical_distance(vec3 worldPos) {
1042
float distXZ = length(worldPos.xz);
1043
float distY = abs(worldPos.y);
1044
return max(distXZ, distY);
1045
}
1046
1047
float FLWFogFactor() {
1048
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
1049
}
1050
1051
1052
uniform float uTime;
1053
uniform mat4 uViewProjection;
1054
uniform vec3 uCameraPos;
1055
1056
uniform vec2 uTextureScale;
1057
uniform sampler2D uBlockAtlas;
1058
uniform sampler2D uLightMap;
1059
uniform sampler2D uCrumbling;
1060
1061
uniform vec2 uWindowSize;
1062
1063
void FLWFinalizeNormal(inout vec3 normal) {
1064
// noop
1065
}
1066
1067
#if defined(VERTEX_SHADER)
1068
void FLWFinalizeWorldPos(inout vec4 worldPos) {
1069
#if defined(USE_FOG)
1070
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
1071
#endif
1072
1073
gl_Position = uViewProjection * worldPos;
1074
}
1075
1076
#elif defined(FRAGMENT_SHADER)
1077
1078
out vec4 fragColor;
1079
1080
vec4 FLWBlockTexture(vec2 texCoords) {
1081
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
1082
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
1083
cr.a = cr.a * diffuseAlpha;
1084
return cr;
1085
}
1086
1087
void FLWFinalizeColor(vec4 color) {
1088
#if defined(USE_FOG)
1089
float a = color.a;
1090
float fog = clamp(FLWFogFactor(), 0., 1.);
1091
1092
color = mix(uFogColor, color, fog);
1093
color.a = a;
1094
#endif
1095
1096
if (color.a < 0.1) {
1097
discard;
1098
}
1099
1100
fragColor = color;
1101
}
1102
1103
vec4 FLWLight(vec2 lightCoords) {
1104
return vec4(1.);
1105
}
1106
#endif
1107
1108
1109
#define PIOVER2 1.5707963268
1110
1111
vec4 quat(vec3 axis, float angle) {
1112
float halfAngle = angle * PIOVER2 / 180.0;
1113
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
1114
return vec4(axis.xyz * cs.y, cs.x);
1115
}
1116
1117
vec4 quatMult(vec4 q1, vec4 q2) {
1118
// disgustingly vectorized quaternion multiplication
1119
vec4 a = q1.w * q2.xyzw;
1120
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
1121
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
1122
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
1123
1124
return a + b + c + d;
1125
}
1126
1127
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
1128
vec3 i = q.xyz;
1129
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
1130
}
1131
1132
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
1133
return rotateVertexByQuat(v, quat(axis, angle));
1134
}
1135
1136
float diffuse(vec3 normal) {
1137
vec3 n2 = normal * normal * vec3(.6, .25, .8);
1138
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
1139
}
1140
struct Vertex {
1141
vec3 pos;
1142
vec2 texCoords;
1143
vec3 normal;
1144
};
1145
1146
struct BlockFrag {
1147
vec2 texCoords;
1148
vec4 color;
1149
float diffuse;
1150
vec2 light;
1151
};
1152
1153
#if defined(FRAGMENT_SHADER)
1154
void fragment(BlockFrag r) {
1155
vec4 tex = FLWBlockTexture(r.texCoords);
1156
1157
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
1158
1159
FLWFinalizeColor(color);
1160
}
1161
#endif
1162
1163
1164
1165
1166
1167
1168
struct Oriented {
1169
vec2 light;
1170
vec4 color;
1171
vec3 pos;
1172
vec3 pivot;
1173
vec4 rotation;
1174
};
1175
1176
#if defined(VERTEX_SHADER)
1177
BlockFrag vertex(Vertex v, Oriented o) {
1178
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
1179
1180
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
1181
1182
FLWFinalizeWorldPos(worldPos);
1183
FLWFinalizeNormal(norm);
1184
1185
BlockFrag b;
1186
b.diffuse = diffuse(norm);
1187
b.texCoords = v.texCoords;
1188
b.light = o.light;
1189
#if defined(DEBUG_NORMAL)
1190
b.color = vec4(norm, 1.);
1191
#else
1192
b.color = o.color;
1193
#endif
1194
return b;
1195
}
1196
#endif
1197
1198
in vec2 v2f_texCoords;
1199
in vec4 v2f_color;
1200
in float v2f_diffuse;
1201
in vec2 v2f_light;
1202
void main() {
1203
BlockFrag o;
1204
o.texCoords = v2f_texCoords;
1205
o.color = v2f_color;
1206
o.diffuse = v2f_diffuse;
1207
o.light = v2f_light;
1208
fragment(o);
1209
}
1210
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
1211
1212
[17:17:48] [Render thread/ERROR]: #version 150
1213
#extension GL_ARB_conservative_depth : enable
1214
#define VERTEX_SHADER
1215
#define DEBUG_NORMAL
1216
#if defined(VERTEX_SHADER)
1217
out float FragDistance;
1218
#elif defined(FRAGMENT_SHADER)
1219
in float FragDistance;
1220
#endif
1221
uniform vec4 uFogColor;
1222
uniform vec2 uFogRange;
1223
1224
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
1225
float distXZ = length(worldPos.xz - cameraPos.xz);
1226
float distY = abs(worldPos.y - cameraPos.y);
1227
return max(distXZ, distY);
1228
}
1229
1230
float cylindrical_distance(vec3 worldPos) {
1231
float distXZ = length(worldPos.xz);
1232
float distY = abs(worldPos.y);
1233
return max(distXZ, distY);
1234
}
1235
1236
float FLWFogFactor() {
1237
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
1238
}
1239
1240
1241
uniform float uTime;
1242
uniform mat4 uViewProjection;
1243
uniform vec3 uCameraPos;
1244
1245
uniform vec2 uTextureScale;
1246
uniform sampler2D uBlockAtlas;
1247
uniform sampler2D uLightMap;
1248
uniform sampler2D uCrumbling;
1249
1250
uniform vec2 uWindowSize;
1251
1252
void FLWFinalizeNormal(inout vec3 normal) {
1253
// noop
1254
}
1255
1256
#if defined(VERTEX_SHADER)
1257
void FLWFinalizeWorldPos(inout vec4 worldPos) {
1258
#if defined(USE_FOG)
1259
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
1260
#endif
1261
1262
gl_Position = uViewProjection * worldPos;
1263
}
1264
1265
#elif defined(FRAGMENT_SHADER)
1266
1267
out vec4 fragColor;
1268
1269
vec4 FLWBlockTexture(vec2 texCoords) {
1270
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
1271
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
1272
cr.a = cr.a * diffuseAlpha;
1273
return cr;
1274
}
1275
1276
void FLWFinalizeColor(vec4 color) {
1277
#if defined(USE_FOG)
1278
float a = color.a;
1279
float fog = clamp(FLWFogFactor(), 0., 1.);
1280
1281
color = mix(uFogColor, color, fog);
1282
color.a = a;
1283
#endif
1284
1285
if (color.a < 0.1) {
1286
discard;
1287
}
1288
1289
fragColor = color;
1290
}
1291
1292
vec4 FLWLight(vec2 lightCoords) {
1293
return vec4(1.);
1294
}
1295
#endif
1296
1297
1298
#define PIOVER2 1.5707963268
1299
1300
vec4 quat(vec3 axis, float angle) {
1301
float halfAngle = angle * PIOVER2 / 180.0;
1302
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
1303
return vec4(axis.xyz * cs.y, cs.x);
1304
}
1305
1306
vec4 quatMult(vec4 q1, vec4 q2) {
1307
// disgustingly vectorized quaternion multiplication
1308
vec4 a = q1.w * q2.xyzw;
1309
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
1310
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
1311
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
1312
1313
return a + b + c + d;
1314
}
1315
1316
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
1317
vec3 i = q.xyz;
1318
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
1319
}
1320
1321
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
1322
return rotateVertexByQuat(v, quat(axis, angle));
1323
}
1324
1325
float diffuse(vec3 normal) {
1326
vec3 n2 = normal * normal * vec3(.6, .25, .8);
1327
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
1328
}
1329
struct Vertex {
1330
vec3 pos;
1331
vec2 texCoords;
1332
vec3 normal;
1333
};
1334
1335
struct BlockFrag {
1336
vec2 texCoords;
1337
vec4 color;
1338
float diffuse;
1339
vec2 light;
1340
};
1341
1342
#if defined(FRAGMENT_SHADER)
1343
void fragment(BlockFrag r) {
1344
vec4 tex = FLWBlockTexture(r.texCoords);
1345
1346
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
1347
1348
FLWFinalizeColor(color);
1349
}
1350
#endif
1351
1352
1353
1354
1355
1356
1357
struct Oriented {
1358
vec2 light;
1359
vec4 color;
1360
vec3 pos;
1361
vec3 pivot;
1362
vec4 rotation;
1363
};
1364
1365
#if defined(VERTEX_SHADER)
1366
BlockFrag vertex(Vertex v, Oriented o) {
1367
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
1368
1369
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
1370
1371
FLWFinalizeWorldPos(worldPos);
1372
FLWFinalizeNormal(norm);
1373
1374
BlockFrag b;
1375
b.diffuse = diffuse(norm);
1376
b.texCoords = v.texCoords;
1377
b.light = o.light;
1378
#if defined(DEBUG_NORMAL)
1379
b.color = vec4(norm, 1.);
1380
#else
1381
b.color = o.color;
1382
#endif
1383
return b;
1384
}
1385
#endif
1386
1387
in vec3 a_v_pos;
1388
in vec2 a_v_texCoords;
1389
in vec3 a_v_normal;
1390
in vec2 a_i_light;
1391
in vec4 a_i_color;
1392
in vec3 a_i_pos;
1393
in vec3 a_i_pivot;
1394
in vec4 a_i_rotation;
1395
out vec2 v2f_texCoords;
1396
out vec4 v2f_color;
1397
out float v2f_diffuse;
1398
out vec2 v2f_light;
1399
void main() {
1400
Vertex v;
1401
v.pos = a_v_pos;
1402
v.texCoords = a_v_texCoords;
1403
v.normal = a_v_normal;
1404
Oriented i;
1405
i.light = a_i_light;
1406
i.color = a_i_color;
1407
i.pos = a_i_pos;
1408
i.pivot = a_i_pivot;
1409
i.rotation = a_i_rotation;
1410
BlockFrag o = vertex(v, i);
1411
v2f_texCoords = o.texCoords;
1412
v2f_color = o.color;
1413
v2f_diffuse = o.diffuse;
1414
v2f_light = o.light;
1415
}
1416
[17:17:48] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
1417
1418
[17:17:48] [Render thread/ERROR]: #version 150
1419
#extension GL_ARB_conservative_depth : enable
1420
#define FRAGMENT_SHADER
1421
#define DEBUG_NORMAL
1422
#if defined(VERTEX_SHADER)
1423
out float FragDistance;
1424
#elif defined(FRAGMENT_SHADER)
1425
in float FragDistance;
1426
#endif
1427
uniform vec4 uFogColor;
1428
uniform vec2 uFogRange;
1429
1430
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
1431
float distXZ = length(worldPos.xz - cameraPos.xz);
1432
float distY = abs(worldPos.y - cameraPos.y);
1433
return max(distXZ, distY);
1434
}
1435
1436
float cylindrical_distance(vec3 worldPos) {
1437
float distXZ = length(worldPos.xz);
1438
float distY = abs(worldPos.y);
1439
return max(distXZ, distY);
1440
}
1441
1442
float FLWFogFactor() {
1443
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
1444
}
1445
1446
1447
uniform float uTime;
1448
uniform mat4 uViewProjection;
1449
uniform vec3 uCameraPos;
1450
1451
uniform vec2 uTextureScale;
1452
uniform sampler2D uBlockAtlas;
1453
uniform sampler2D uLightMap;
1454
uniform sampler2D uCrumbling;
1455
1456
uniform vec2 uWindowSize;
1457
1458
void FLWFinalizeNormal(inout vec3 normal) {
1459
// noop
1460
}
1461
1462
#if defined(VERTEX_SHADER)
1463
void FLWFinalizeWorldPos(inout vec4 worldPos) {
1464
#if defined(USE_FOG)
1465
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
1466
#endif
1467
1468
gl_Position = uViewProjection * worldPos;
1469
}
1470
1471
#elif defined(FRAGMENT_SHADER)
1472
1473
out vec4 fragColor;
1474
1475
vec4 FLWBlockTexture(vec2 texCoords) {
1476
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
1477
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
1478
cr.a = cr.a * diffuseAlpha;
1479
return cr;
1480
}
1481
1482
void FLWFinalizeColor(vec4 color) {
1483
#if defined(USE_FOG)
1484
float a = color.a;
1485
float fog = clamp(FLWFogFactor(), 0., 1.);
1486
1487
color = mix(uFogColor, color, fog);
1488
color.a = a;
1489
#endif
1490
1491
if (color.a < 0.1) {
1492
discard;
1493
}
1494
1495
fragColor = color;
1496
}
1497
1498
vec4 FLWLight(vec2 lightCoords) {
1499
return vec4(1.);
1500
}
1501
#endif
1502
1503
1504
#define PIOVER2 1.5707963268
1505
1506
vec4 quat(vec3 axis, float angle) {
1507
float halfAngle = angle * PIOVER2 / 180.0;
1508
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
1509
return vec4(axis.xyz * cs.y, cs.x);
1510
}
1511
1512
vec4 quatMult(vec4 q1, vec4 q2) {
1513
// disgustingly vectorized quaternion multiplication
1514
vec4 a = q1.w * q2.xyzw;
1515
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
1516
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
1517
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
1518
1519
return a + b + c + d;
1520
}
1521
1522
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
1523
vec3 i = q.xyz;
1524
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
1525
}
1526
1527
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
1528
return rotateVertexByQuat(v, quat(axis, angle));
1529
}
1530
1531
float diffuse(vec3 normal) {
1532
vec3 n2 = normal * normal * vec3(.6, .25, .8);
1533
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
1534
}
1535
struct Vertex {
1536
vec3 pos;
1537
vec2 texCoords;
1538
vec3 normal;
1539
};
1540
1541
struct BlockFrag {
1542
vec2 texCoords;
1543
vec4 color;
1544
float diffuse;
1545
vec2 light;
1546
};
1547
1548
#if defined(FRAGMENT_SHADER)
1549
void fragment(BlockFrag r) {
1550
vec4 tex = FLWBlockTexture(r.texCoords);
1551
1552
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
1553
1554
FLWFinalizeColor(color);
1555
}
1556
#endif
1557
1558
1559
1560
1561
1562
1563
struct Oriented {
1564
vec2 light;
1565
vec4 color;
1566
vec3 pos;
1567
vec3 pivot;
1568
vec4 rotation;
1569
};
1570
1571
#if defined(VERTEX_SHADER)
1572
BlockFrag vertex(Vertex v, Oriented o) {
1573
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
1574
1575
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
1576
1577
FLWFinalizeWorldPos(worldPos);
1578
FLWFinalizeNormal(norm);
1579
1580
BlockFrag b;
1581
b.diffuse = diffuse(norm);
1582
b.texCoords = v.texCoords;
1583
b.light = o.light;
1584
#if defined(DEBUG_NORMAL)
1585
b.color = vec4(norm, 1.);
1586
#else
1587
b.color = o.color;
1588
#endif
1589
return b;
1590
}
1591
#endif
1592
1593
in vec2 v2f_texCoords;
1594
in vec4 v2f_color;
1595
in float v2f_diffuse;
1596
in vec2 v2f_light;
1597
void main() {
1598
BlockFrag o;
1599
o.texCoords = v2f_texCoords;
1600
o.color = v2f_color;
1601
o.diffuse = v2f_diffuse;
1602
o.light = v2f_light;
1603
fragment(o);
1604
}
1605
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
1606
1607
[17:17:48] [Render thread/ERROR]: #version 150
1608
#extension GL_ARB_conservative_depth : enable
1609
#define VERTEX_SHADER
1610
#if defined(VERTEX_SHADER)
1611
out float FragDistance;
1612
#elif defined(FRAGMENT_SHADER)
1613
in float FragDistance;
1614
#endif
1615
uniform vec4 uFogColor;
1616
uniform vec2 uFogRange;
1617
1618
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
1619
float distXZ = length(worldPos.xz - cameraPos.xz);
1620
float distY = abs(worldPos.y - cameraPos.y);
1621
return max(distXZ, distY);
1622
}
1623
1624
float cylindrical_distance(vec3 worldPos) {
1625
float distXZ = length(worldPos.xz);
1626
float distY = abs(worldPos.y);
1627
return max(distXZ, distY);
1628
}
1629
1630
float FLWFogFactor() {
1631
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
1632
}
1633
1634
1635
uniform float uTime;
1636
uniform mat4 uViewProjection;
1637
uniform vec3 uCameraPos;
1638
1639
uniform vec2 uTextureScale;
1640
uniform sampler2D uBlockAtlas;
1641
uniform sampler2D uLightMap;
1642
uniform sampler2D uCrumbling;
1643
1644
uniform vec2 uWindowSize;
1645
1646
void FLWFinalizeNormal(inout vec3 normal) {
1647
// noop
1648
}
1649
1650
#if defined(VERTEX_SHADER)
1651
void FLWFinalizeWorldPos(inout vec4 worldPos) {
1652
#if defined(USE_FOG)
1653
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
1654
#endif
1655
1656
gl_Position = uViewProjection * worldPos;
1657
}
1658
1659
#elif defined(FRAGMENT_SHADER)
1660
1661
out vec4 fragColor;
1662
1663
vec4 FLWBlockTexture(vec2 texCoords) {
1664
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
1665
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
1666
cr.a = cr.a * diffuseAlpha;
1667
return cr;
1668
}
1669
1670
void FLWFinalizeColor(vec4 color) {
1671
#if defined(USE_FOG)
1672
float a = color.a;
1673
float fog = clamp(FLWFogFactor(), 0., 1.);
1674
1675
color = mix(uFogColor, color, fog);
1676
color.a = a;
1677
#endif
1678
1679
if (color.a < 0.1) {
1680
discard;
1681
}
1682
1683
fragColor = color;
1684
}
1685
1686
vec4 FLWLight(vec2 lightCoords) {
1687
return vec4(1.);
1688
}
1689
#endif
1690
1691
1692
mat4 rotate(vec3 axis, float angle) {
1693
float s = sin(angle);
1694
float c = cos(angle);
1695
float oc = 1. - c;
1696
1697
vec3 sa = axis * s;
1698
1699
mat4 mr = mat4(1.);
1700
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
1701
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
1702
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
1703
1704
return mr;
1705
}
1706
1707
mat4 rotation(vec3 rot) {
1708
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
1709
}
1710
1711
mat3 modelToNormal(mat4 mat) {
1712
// Discard the edges. This won't be accurate for scaled or skewed matrices,
1713
// but we don't have to work with those often.
1714
mat3 m;
1715
m[0] = mat[0].xyz;
1716
m[1] = mat[1].xyz;
1717
m[2] = mat[2].xyz;
1718
return m;
1719
}
1720
1721
float diffuse(vec3 normal) {
1722
vec3 n2 = normal * normal * vec3(.6, .25, .8);
1723
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
1724
}
1725
struct Vertex {
1726
vec3 pos;
1727
vec2 texCoords;
1728
vec3 normal;
1729
};
1730
1731
struct BlockFrag {
1732
vec2 texCoords;
1733
vec4 color;
1734
float diffuse;
1735
vec2 light;
1736
};
1737
1738
#if defined(FRAGMENT_SHADER)
1739
void fragment(BlockFrag r) {
1740
vec4 tex = FLWBlockTexture(r.texCoords);
1741
1742
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
1743
1744
FLWFinalizeColor(color);
1745
}
1746
#endif
1747
#define PI 3.1415926538
1748
1749
1750
1751
1752
struct Rotating {
1753
vec2 light;
1754
vec4 color;
1755
vec3 pos;
1756
float speed;
1757
float offset;
1758
vec3 axis;
1759
};
1760
1761
1762
1763
1764
mat4 kineticRotation(float offset, float speed, vec3 axis) {
1765
float degrees = offset + uTime * speed * 3./10.;
1766
float angle = fract(degrees / 360.) * PI * 2.;
1767
1768
return rotate(axis, angle);
1769
}
1770
1771
#if defined(VERTEX_SHADER)
1772
BlockFrag vertex(Vertex v, Rotating instance) {
1773
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
1774
1775
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
1776
worldPos += vec4(instance.pos + .5, 0.);
1777
1778
vec3 norm = modelToNormal(spin) * v.normal;
1779
1780
FLWFinalizeWorldPos(worldPos);
1781
FLWFinalizeNormal(norm);
1782
1783
BlockFrag b;
1784
b.diffuse = diffuse(norm);
1785
b.texCoords = v.texCoords;
1786
b.light = instance.light;
1787
1788
#if defined(DEBUG_RAINBOW)
1789
b.color = instance.color;
1790
#elif defined(DEBUG_NORMAL)
1791
b.color = vec4(norm, 1.);
1792
#else
1793
b.color = vec4(1.);
1794
#endif
1795
1796
return b;
1797
}
1798
#endif
1799
1800
in vec3 a_v_pos;
1801
in vec2 a_v_texCoords;
1802
in vec3 a_v_normal;
1803
in vec2 a_i_light;
1804
in vec4 a_i_color;
1805
in vec3 a_i_pos;
1806
in float a_i_speed;
1807
in float a_i_offset;
1808
in vec3 a_i_axis;
1809
out vec2 v2f_texCoords;
1810
out vec4 v2f_color;
1811
out float v2f_diffuse;
1812
out vec2 v2f_light;
1813
void main() {
1814
Vertex v;
1815
v.pos = a_v_pos;
1816
v.texCoords = a_v_texCoords;
1817
v.normal = a_v_normal;
1818
Rotating i;
1819
i.light = a_i_light;
1820
i.color = a_i_color;
1821
i.pos = a_i_pos;
1822
i.speed = a_i_speed;
1823
i.offset = a_i_offset;
1824
i.axis = a_i_axis;
1825
BlockFrag o = vertex(v, i);
1826
v2f_texCoords = o.texCoords;
1827
v2f_color = o.color;
1828
v2f_diffuse = o.diffuse;
1829
v2f_light = o.light;
1830
}
1831
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
1832
1833
[17:17:48] [Render thread/ERROR]: #version 150
1834
#extension GL_ARB_conservative_depth : enable
1835
#define FRAGMENT_SHADER
1836
#if defined(VERTEX_SHADER)
1837
out float FragDistance;
1838
#elif defined(FRAGMENT_SHADER)
1839
in float FragDistance;
1840
#endif
1841
uniform vec4 uFogColor;
1842
uniform vec2 uFogRange;
1843
1844
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
1845
float distXZ = length(worldPos.xz - cameraPos.xz);
1846
float distY = abs(worldPos.y - cameraPos.y);
1847
return max(distXZ, distY);
1848
}
1849
1850
float cylindrical_distance(vec3 worldPos) {
1851
float distXZ = length(worldPos.xz);
1852
float distY = abs(worldPos.y);
1853
return max(distXZ, distY);
1854
}
1855
1856
float FLWFogFactor() {
1857
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
1858
}
1859
1860
1861
uniform float uTime;
1862
uniform mat4 uViewProjection;
1863
uniform vec3 uCameraPos;
1864
1865
uniform vec2 uTextureScale;
1866
uniform sampler2D uBlockAtlas;
1867
uniform sampler2D uLightMap;
1868
uniform sampler2D uCrumbling;
1869
1870
uniform vec2 uWindowSize;
1871
1872
void FLWFinalizeNormal(inout vec3 normal) {
1873
// noop
1874
}
1875
1876
#if defined(VERTEX_SHADER)
1877
void FLWFinalizeWorldPos(inout vec4 worldPos) {
1878
#if defined(USE_FOG)
1879
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
1880
#endif
1881
1882
gl_Position = uViewProjection * worldPos;
1883
}
1884
1885
#elif defined(FRAGMENT_SHADER)
1886
1887
out vec4 fragColor;
1888
1889
vec4 FLWBlockTexture(vec2 texCoords) {
1890
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
1891
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
1892
cr.a = cr.a * diffuseAlpha;
1893
return cr;
1894
}
1895
1896
void FLWFinalizeColor(vec4 color) {
1897
#if defined(USE_FOG)
1898
float a = color.a;
1899
float fog = clamp(FLWFogFactor(), 0., 1.);
1900
1901
color = mix(uFogColor, color, fog);
1902
color.a = a;
1903
#endif
1904
1905
if (color.a < 0.1) {
1906
discard;
1907
}
1908
1909
fragColor = color;
1910
}
1911
1912
vec4 FLWLight(vec2 lightCoords) {
1913
return vec4(1.);
1914
}
1915
#endif
1916
1917
1918
mat4 rotate(vec3 axis, float angle) {
1919
float s = sin(angle);
1920
float c = cos(angle);
1921
float oc = 1. - c;
1922
1923
vec3 sa = axis * s;
1924
1925
mat4 mr = mat4(1.);
1926
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
1927
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
1928
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
1929
1930
return mr;
1931
}
1932
1933
mat4 rotation(vec3 rot) {
1934
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
1935
}
1936
1937
mat3 modelToNormal(mat4 mat) {
1938
// Discard the edges. This won't be accurate for scaled or skewed matrices,
1939
// but we don't have to work with those often.
1940
mat3 m;
1941
m[0] = mat[0].xyz;
1942
m[1] = mat[1].xyz;
1943
m[2] = mat[2].xyz;
1944
return m;
1945
}
1946
1947
float diffuse(vec3 normal) {
1948
vec3 n2 = normal * normal * vec3(.6, .25, .8);
1949
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
1950
}
1951
struct Vertex {
1952
vec3 pos;
1953
vec2 texCoords;
1954
vec3 normal;
1955
};
1956
1957
struct BlockFrag {
1958
vec2 texCoords;
1959
vec4 color;
1960
float diffuse;
1961
vec2 light;
1962
};
1963
1964
#if defined(FRAGMENT_SHADER)
1965
void fragment(BlockFrag r) {
1966
vec4 tex = FLWBlockTexture(r.texCoords);
1967
1968
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
1969
1970
FLWFinalizeColor(color);
1971
}
1972
#endif
1973
#define PI 3.1415926538
1974
1975
1976
1977
1978
struct Rotating {
1979
vec2 light;
1980
vec4 color;
1981
vec3 pos;
1982
float speed;
1983
float offset;
1984
vec3 axis;
1985
};
1986
1987
1988
1989
1990
mat4 kineticRotation(float offset, float speed, vec3 axis) {
1991
float degrees = offset + uTime * speed * 3./10.;
1992
float angle = fract(degrees / 360.) * PI * 2.;
1993
1994
return rotate(axis, angle);
1995
}
1996
1997
#if defined(VERTEX_SHADER)
1998
BlockFrag vertex(Vertex v, Rotating instance) {
1999
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
2000
2001
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
2002
worldPos += vec4(instance.pos + .5, 0.);
2003
2004
vec3 norm = modelToNormal(spin) * v.normal;
2005
2006
FLWFinalizeWorldPos(worldPos);
2007
FLWFinalizeNormal(norm);
2008
2009
BlockFrag b;
2010
b.diffuse = diffuse(norm);
2011
b.texCoords = v.texCoords;
2012
b.light = instance.light;
2013
2014
#if defined(DEBUG_RAINBOW)
2015
b.color = instance.color;
2016
#elif defined(DEBUG_NORMAL)
2017
b.color = vec4(norm, 1.);
2018
#else
2019
b.color = vec4(1.);
2020
#endif
2021
2022
return b;
2023
}
2024
#endif
2025
2026
in vec2 v2f_texCoords;
2027
in vec4 v2f_color;
2028
in float v2f_diffuse;
2029
in vec2 v2f_light;
2030
void main() {
2031
BlockFrag o;
2032
o.texCoords = v2f_texCoords;
2033
o.color = v2f_color;
2034
o.diffuse = v2f_diffuse;
2035
o.light = v2f_light;
2036
fragment(o);
2037
}
2038
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
2039
2040
[17:17:48] [Render thread/ERROR]: #version 150
2041
#extension GL_ARB_conservative_depth : enable
2042
#define VERTEX_SHADER
2043
#define DEBUG_RAINBOW
2044
#if defined(VERTEX_SHADER)
2045
out float FragDistance;
2046
#elif defined(FRAGMENT_SHADER)
2047
in float FragDistance;
2048
#endif
2049
uniform vec4 uFogColor;
2050
uniform vec2 uFogRange;
2051
2052
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
2053
float distXZ = length(worldPos.xz - cameraPos.xz);
2054
float distY = abs(worldPos.y - cameraPos.y);
2055
return max(distXZ, distY);
2056
}
2057
2058
float cylindrical_distance(vec3 worldPos) {
2059
float distXZ = length(worldPos.xz);
2060
float distY = abs(worldPos.y);
2061
return max(distXZ, distY);
2062
}
2063
2064
float FLWFogFactor() {
2065
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
2066
}
2067
2068
2069
uniform float uTime;
2070
uniform mat4 uViewProjection;
2071
uniform vec3 uCameraPos;
2072
2073
uniform vec2 uTextureScale;
2074
uniform sampler2D uBlockAtlas;
2075
uniform sampler2D uLightMap;
2076
uniform sampler2D uCrumbling;
2077
2078
uniform vec2 uWindowSize;
2079
2080
void FLWFinalizeNormal(inout vec3 normal) {
2081
// noop
2082
}
2083
2084
#if defined(VERTEX_SHADER)
2085
void FLWFinalizeWorldPos(inout vec4 worldPos) {
2086
#if defined(USE_FOG)
2087
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
2088
#endif
2089
2090
gl_Position = uViewProjection * worldPos;
2091
}
2092
2093
#elif defined(FRAGMENT_SHADER)
2094
2095
out vec4 fragColor;
2096
2097
vec4 FLWBlockTexture(vec2 texCoords) {
2098
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
2099
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
2100
cr.a = cr.a * diffuseAlpha;
2101
return cr;
2102
}
2103
2104
void FLWFinalizeColor(vec4 color) {
2105
#if defined(USE_FOG)
2106
float a = color.a;
2107
float fog = clamp(FLWFogFactor(), 0., 1.);
2108
2109
color = mix(uFogColor, color, fog);
2110
color.a = a;
2111
#endif
2112
2113
if (color.a < 0.1) {
2114
discard;
2115
}
2116
2117
fragColor = color;
2118
}
2119
2120
vec4 FLWLight(vec2 lightCoords) {
2121
return vec4(1.);
2122
}
2123
#endif
2124
2125
2126
mat4 rotate(vec3 axis, float angle) {
2127
float s = sin(angle);
2128
float c = cos(angle);
2129
float oc = 1. - c;
2130
2131
vec3 sa = axis * s;
2132
2133
mat4 mr = mat4(1.);
2134
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
2135
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
2136
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
2137
2138
return mr;
2139
}
2140
2141
mat4 rotation(vec3 rot) {
2142
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
2143
}
2144
2145
mat3 modelToNormal(mat4 mat) {
2146
// Discard the edges. This won't be accurate for scaled or skewed matrices,
2147
// but we don't have to work with those often.
2148
mat3 m;
2149
m[0] = mat[0].xyz;
2150
m[1] = mat[1].xyz;
2151
m[2] = mat[2].xyz;
2152
return m;
2153
}
2154
2155
float diffuse(vec3 normal) {
2156
vec3 n2 = normal * normal * vec3(.6, .25, .8);
2157
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
2158
}
2159
struct Vertex {
2160
vec3 pos;
2161
vec2 texCoords;
2162
vec3 normal;
2163
};
2164
2165
struct BlockFrag {
2166
vec2 texCoords;
2167
vec4 color;
2168
float diffuse;
2169
vec2 light;
2170
};
2171
2172
#if defined(FRAGMENT_SHADER)
2173
void fragment(BlockFrag r) {
2174
vec4 tex = FLWBlockTexture(r.texCoords);
2175
2176
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
2177
2178
FLWFinalizeColor(color);
2179
}
2180
#endif
2181
#define PI 3.1415926538
2182
2183
2184
2185
2186
struct Rotating {
2187
vec2 light;
2188
vec4 color;
2189
vec3 pos;
2190
float speed;
2191
float offset;
2192
vec3 axis;
2193
};
2194
2195
2196
2197
2198
mat4 kineticRotation(float offset, float speed, vec3 axis) {
2199
float degrees = offset + uTime * speed * 3./10.;
2200
float angle = fract(degrees / 360.) * PI * 2.;
2201
2202
return rotate(axis, angle);
2203
}
2204
2205
#if defined(VERTEX_SHADER)
2206
BlockFrag vertex(Vertex v, Rotating instance) {
2207
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
2208
2209
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
2210
worldPos += vec4(instance.pos + .5, 0.);
2211
2212
vec3 norm = modelToNormal(spin) * v.normal;
2213
2214
FLWFinalizeWorldPos(worldPos);
2215
FLWFinalizeNormal(norm);
2216
2217
BlockFrag b;
2218
b.diffuse = diffuse(norm);
2219
b.texCoords = v.texCoords;
2220
b.light = instance.light;
2221
2222
#if defined(DEBUG_RAINBOW)
2223
b.color = instance.color;
2224
#elif defined(DEBUG_NORMAL)
2225
b.color = vec4(norm, 1.);
2226
#else
2227
b.color = vec4(1.);
2228
#endif
2229
2230
return b;
2231
}
2232
#endif
2233
2234
in vec3 a_v_pos;
2235
in vec2 a_v_texCoords;
2236
in vec3 a_v_normal;
2237
in vec2 a_i_light;
2238
in vec4 a_i_color;
2239
in vec3 a_i_pos;
2240
in float a_i_speed;
2241
in float a_i_offset;
2242
in vec3 a_i_axis;
2243
out vec2 v2f_texCoords;
2244
out vec4 v2f_color;
2245
out float v2f_diffuse;
2246
out vec2 v2f_light;
2247
void main() {
2248
Vertex v;
2249
v.pos = a_v_pos;
2250
v.texCoords = a_v_texCoords;
2251
v.normal = a_v_normal;
2252
Rotating i;
2253
i.light = a_i_light;
2254
i.color = a_i_color;
2255
i.pos = a_i_pos;
2256
i.speed = a_i_speed;
2257
i.offset = a_i_offset;
2258
i.axis = a_i_axis;
2259
BlockFrag o = vertex(v, i);
2260
v2f_texCoords = o.texCoords;
2261
v2f_color = o.color;
2262
v2f_diffuse = o.diffuse;
2263
v2f_light = o.light;
2264
}
2265
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
2266
2267
[17:17:48] [Render thread/ERROR]: #version 150
2268
#extension GL_ARB_conservative_depth : enable
2269
#define FRAGMENT_SHADER
2270
#define DEBUG_RAINBOW
2271
#if defined(VERTEX_SHADER)
2272
out float FragDistance;
2273
#elif defined(FRAGMENT_SHADER)
2274
in float FragDistance;
2275
#endif
2276
uniform vec4 uFogColor;
2277
uniform vec2 uFogRange;
2278
2279
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
2280
float distXZ = length(worldPos.xz - cameraPos.xz);
2281
float distY = abs(worldPos.y - cameraPos.y);
2282
return max(distXZ, distY);
2283
}
2284
2285
float cylindrical_distance(vec3 worldPos) {
2286
float distXZ = length(worldPos.xz);
2287
float distY = abs(worldPos.y);
2288
return max(distXZ, distY);
2289
}
2290
2291
float FLWFogFactor() {
2292
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
2293
}
2294
2295
2296
uniform float uTime;
2297
uniform mat4 uViewProjection;
2298
uniform vec3 uCameraPos;
2299
2300
uniform vec2 uTextureScale;
2301
uniform sampler2D uBlockAtlas;
2302
uniform sampler2D uLightMap;
2303
uniform sampler2D uCrumbling;
2304
2305
uniform vec2 uWindowSize;
2306
2307
void FLWFinalizeNormal(inout vec3 normal) {
2308
// noop
2309
}
2310
2311
#if defined(VERTEX_SHADER)
2312
void FLWFinalizeWorldPos(inout vec4 worldPos) {
2313
#if defined(USE_FOG)
2314
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
2315
#endif
2316
2317
gl_Position = uViewProjection * worldPos;
2318
}
2319
2320
#elif defined(FRAGMENT_SHADER)
2321
2322
out vec4 fragColor;
2323
2324
vec4 FLWBlockTexture(vec2 texCoords) {
2325
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
2326
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
2327
cr.a = cr.a * diffuseAlpha;
2328
return cr;
2329
}
2330
2331
void FLWFinalizeColor(vec4 color) {
2332
#if defined(USE_FOG)
2333
float a = color.a;
2334
float fog = clamp(FLWFogFactor(), 0., 1.);
2335
2336
color = mix(uFogColor, color, fog);
2337
color.a = a;
2338
#endif
2339
2340
if (color.a < 0.1) {
2341
discard;
2342
}
2343
2344
fragColor = color;
2345
}
2346
2347
vec4 FLWLight(vec2 lightCoords) {
2348
return vec4(1.);
2349
}
2350
#endif
2351
2352
2353
mat4 rotate(vec3 axis, float angle) {
2354
float s = sin(angle);
2355
float c = cos(angle);
2356
float oc = 1. - c;
2357
2358
vec3 sa = axis * s;
2359
2360
mat4 mr = mat4(1.);
2361
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
2362
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
2363
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
2364
2365
return mr;
2366
}
2367
2368
mat4 rotation(vec3 rot) {
2369
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
2370
}
2371
2372
mat3 modelToNormal(mat4 mat) {
2373
// Discard the edges. This won't be accurate for scaled or skewed matrices,
2374
// but we don't have to work with those often.
2375
mat3 m;
2376
m[0] = mat[0].xyz;
2377
m[1] = mat[1].xyz;
2378
m[2] = mat[2].xyz;
2379
return m;
2380
}
2381
2382
float diffuse(vec3 normal) {
2383
vec3 n2 = normal * normal * vec3(.6, .25, .8);
2384
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
2385
}
2386
struct Vertex {
2387
vec3 pos;
2388
vec2 texCoords;
2389
vec3 normal;
2390
};
2391
2392
struct BlockFrag {
2393
vec2 texCoords;
2394
vec4 color;
2395
float diffuse;
2396
vec2 light;
2397
};
2398
2399
#if defined(FRAGMENT_SHADER)
2400
void fragment(BlockFrag r) {
2401
vec4 tex = FLWBlockTexture(r.texCoords);
2402
2403
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
2404
2405
FLWFinalizeColor(color);
2406
}
2407
#endif
2408
#define PI 3.1415926538
2409
2410
2411
2412
2413
struct Rotating {
2414
vec2 light;
2415
vec4 color;
2416
vec3 pos;
2417
float speed;
2418
float offset;
2419
vec3 axis;
2420
};
2421
2422
2423
2424
2425
mat4 kineticRotation(float offset, float speed, vec3 axis) {
2426
float degrees = offset + uTime * speed * 3./10.;
2427
float angle = fract(degrees / 360.) * PI * 2.;
2428
2429
return rotate(axis, angle);
2430
}
2431
2432
#if defined(VERTEX_SHADER)
2433
BlockFrag vertex(Vertex v, Rotating instance) {
2434
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
2435
2436
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
2437
worldPos += vec4(instance.pos + .5, 0.);
2438
2439
vec3 norm = modelToNormal(spin) * v.normal;
2440
2441
FLWFinalizeWorldPos(worldPos);
2442
FLWFinalizeNormal(norm);
2443
2444
BlockFrag b;
2445
b.diffuse = diffuse(norm);
2446
b.texCoords = v.texCoords;
2447
b.light = instance.light;
2448
2449
#if defined(DEBUG_RAINBOW)
2450
b.color = instance.color;
2451
#elif defined(DEBUG_NORMAL)
2452
b.color = vec4(norm, 1.);
2453
#else
2454
b.color = vec4(1.);
2455
#endif
2456
2457
return b;
2458
}
2459
#endif
2460
2461
in vec2 v2f_texCoords;
2462
in vec4 v2f_color;
2463
in float v2f_diffuse;
2464
in vec2 v2f_light;
2465
void main() {
2466
BlockFrag o;
2467
o.texCoords = v2f_texCoords;
2468
o.color = v2f_color;
2469
o.diffuse = v2f_diffuse;
2470
o.light = v2f_light;
2471
fragment(o);
2472
}
2473
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
2474
2475
[17:17:48] [Render thread/ERROR]: #version 150
2476
#extension GL_ARB_conservative_depth : enable
2477
#define VERTEX_SHADER
2478
#define DEBUG_NORMAL
2479
#if defined(VERTEX_SHADER)
2480
out float FragDistance;
2481
#elif defined(FRAGMENT_SHADER)
2482
in float FragDistance;
2483
#endif
2484
uniform vec4 uFogColor;
2485
uniform vec2 uFogRange;
2486
2487
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
2488
float distXZ = length(worldPos.xz - cameraPos.xz);
2489
float distY = abs(worldPos.y - cameraPos.y);
2490
return max(distXZ, distY);
2491
}
2492
2493
float cylindrical_distance(vec3 worldPos) {
2494
float distXZ = length(worldPos.xz);
2495
float distY = abs(worldPos.y);
2496
return max(distXZ, distY);
2497
}
2498
2499
float FLWFogFactor() {
2500
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
2501
}
2502
2503
2504
uniform float uTime;
2505
uniform mat4 uViewProjection;
2506
uniform vec3 uCameraPos;
2507
2508
uniform vec2 uTextureScale;
2509
uniform sampler2D uBlockAtlas;
2510
uniform sampler2D uLightMap;
2511
uniform sampler2D uCrumbling;
2512
2513
uniform vec2 uWindowSize;
2514
2515
void FLWFinalizeNormal(inout vec3 normal) {
2516
// noop
2517
}
2518
2519
#if defined(VERTEX_SHADER)
2520
void FLWFinalizeWorldPos(inout vec4 worldPos) {
2521
#if defined(USE_FOG)
2522
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
2523
#endif
2524
2525
gl_Position = uViewProjection * worldPos;
2526
}
2527
2528
#elif defined(FRAGMENT_SHADER)
2529
2530
out vec4 fragColor;
2531
2532
vec4 FLWBlockTexture(vec2 texCoords) {
2533
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
2534
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
2535
cr.a = cr.a * diffuseAlpha;
2536
return cr;
2537
}
2538
2539
void FLWFinalizeColor(vec4 color) {
2540
#if defined(USE_FOG)
2541
float a = color.a;
2542
float fog = clamp(FLWFogFactor(), 0., 1.);
2543
2544
color = mix(uFogColor, color, fog);
2545
color.a = a;
2546
#endif
2547
2548
if (color.a < 0.1) {
2549
discard;
2550
}
2551
2552
fragColor = color;
2553
}
2554
2555
vec4 FLWLight(vec2 lightCoords) {
2556
return vec4(1.);
2557
}
2558
#endif
2559
2560
2561
mat4 rotate(vec3 axis, float angle) {
2562
float s = sin(angle);
2563
float c = cos(angle);
2564
float oc = 1. - c;
2565
2566
vec3 sa = axis * s;
2567
2568
mat4 mr = mat4(1.);
2569
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
2570
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
2571
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
2572
2573
return mr;
2574
}
2575
2576
mat4 rotation(vec3 rot) {
2577
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
2578
}
2579
2580
mat3 modelToNormal(mat4 mat) {
2581
// Discard the edges. This won't be accurate for scaled or skewed matrices,
2582
// but we don't have to work with those often.
2583
mat3 m;
2584
m[0] = mat[0].xyz;
2585
m[1] = mat[1].xyz;
2586
m[2] = mat[2].xyz;
2587
return m;
2588
}
2589
2590
float diffuse(vec3 normal) {
2591
vec3 n2 = normal * normal * vec3(.6, .25, .8);
2592
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
2593
}
2594
struct Vertex {
2595
vec3 pos;
2596
vec2 texCoords;
2597
vec3 normal;
2598
};
2599
2600
struct BlockFrag {
2601
vec2 texCoords;
2602
vec4 color;
2603
float diffuse;
2604
vec2 light;
2605
};
2606
2607
#if defined(FRAGMENT_SHADER)
2608
void fragment(BlockFrag r) {
2609
vec4 tex = FLWBlockTexture(r.texCoords);
2610
2611
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
2612
2613
FLWFinalizeColor(color);
2614
}
2615
#endif
2616
#define PI 3.1415926538
2617
2618
2619
2620
2621
struct Rotating {
2622
vec2 light;
2623
vec4 color;
2624
vec3 pos;
2625
float speed;
2626
float offset;
2627
vec3 axis;
2628
};
2629
2630
2631
2632
2633
mat4 kineticRotation(float offset, float speed, vec3 axis) {
2634
float degrees = offset + uTime * speed * 3./10.;
2635
float angle = fract(degrees / 360.) * PI * 2.;
2636
2637
return rotate(axis, angle);
2638
}
2639
2640
#if defined(VERTEX_SHADER)
2641
BlockFrag vertex(Vertex v, Rotating instance) {
2642
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
2643
2644
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
2645
worldPos += vec4(instance.pos + .5, 0.);
2646
2647
vec3 norm = modelToNormal(spin) * v.normal;
2648
2649
FLWFinalizeWorldPos(worldPos);
2650
FLWFinalizeNormal(norm);
2651
2652
BlockFrag b;
2653
b.diffuse = diffuse(norm);
2654
b.texCoords = v.texCoords;
2655
b.light = instance.light;
2656
2657
#if defined(DEBUG_RAINBOW)
2658
b.color = instance.color;
2659
#elif defined(DEBUG_NORMAL)
2660
b.color = vec4(norm, 1.);
2661
#else
2662
b.color = vec4(1.);
2663
#endif
2664
2665
return b;
2666
}
2667
#endif
2668
2669
in vec3 a_v_pos;
2670
in vec2 a_v_texCoords;
2671
in vec3 a_v_normal;
2672
in vec2 a_i_light;
2673
in vec4 a_i_color;
2674
in vec3 a_i_pos;
2675
in float a_i_speed;
2676
in float a_i_offset;
2677
in vec3 a_i_axis;
2678
out vec2 v2f_texCoords;
2679
out vec4 v2f_color;
2680
out float v2f_diffuse;
2681
out vec2 v2f_light;
2682
void main() {
2683
Vertex v;
2684
v.pos = a_v_pos;
2685
v.texCoords = a_v_texCoords;
2686
v.normal = a_v_normal;
2687
Rotating i;
2688
i.light = a_i_light;
2689
i.color = a_i_color;
2690
i.pos = a_i_pos;
2691
i.speed = a_i_speed;
2692
i.offset = a_i_offset;
2693
i.axis = a_i_axis;
2694
BlockFrag o = vertex(v, i);
2695
v2f_texCoords = o.texCoords;
2696
v2f_color = o.color;
2697
v2f_diffuse = o.diffuse;
2698
v2f_light = o.light;
2699
}
2700
[17:17:48] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
2701
2702
[17:17:48] [Render thread/ERROR]: #version 150
2703
#extension GL_ARB_conservative_depth : enable
2704
#define FRAGMENT_SHADER
2705
#define DEBUG_NORMAL
2706
#if defined(VERTEX_SHADER)
2707
out float FragDistance;
2708
#elif defined(FRAGMENT_SHADER)
2709
in float FragDistance;
2710
#endif
2711
uniform vec4 uFogColor;
2712
uniform vec2 uFogRange;
2713
2714
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
2715
float distXZ = length(worldPos.xz - cameraPos.xz);
2716
float distY = abs(worldPos.y - cameraPos.y);
2717
return max(distXZ, distY);
2718
}
2719
2720
float cylindrical_distance(vec3 worldPos) {
2721
float distXZ = length(worldPos.xz);
2722
float distY = abs(worldPos.y);
2723
return max(distXZ, distY);
2724
}
2725
2726
float FLWFogFactor() {
2727
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
2728
}
2729
2730
2731
uniform float uTime;
2732
uniform mat4 uViewProjection;
2733
uniform vec3 uCameraPos;
2734
2735
uniform vec2 uTextureScale;
2736
uniform sampler2D uBlockAtlas;
2737
uniform sampler2D uLightMap;
2738
uniform sampler2D uCrumbling;
2739
2740
uniform vec2 uWindowSize;
2741
2742
void FLWFinalizeNormal(inout vec3 normal) {
2743
// noop
2744
}
2745
2746
#if defined(VERTEX_SHADER)
2747
void FLWFinalizeWorldPos(inout vec4 worldPos) {
2748
#if defined(USE_FOG)
2749
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
2750
#endif
2751
2752
gl_Position = uViewProjection * worldPos;
2753
}
2754
2755
#elif defined(FRAGMENT_SHADER)
2756
2757
out vec4 fragColor;
2758
2759
vec4 FLWBlockTexture(vec2 texCoords) {
2760
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
2761
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
2762
cr.a = cr.a * diffuseAlpha;
2763
return cr;
2764
}
2765
2766
void FLWFinalizeColor(vec4 color) {
2767
#if defined(USE_FOG)
2768
float a = color.a;
2769
float fog = clamp(FLWFogFactor(), 0., 1.);
2770
2771
color = mix(uFogColor, color, fog);
2772
color.a = a;
2773
#endif
2774
2775
if (color.a < 0.1) {
2776
discard;
2777
}
2778
2779
fragColor = color;
2780
}
2781
2782
vec4 FLWLight(vec2 lightCoords) {
2783
return vec4(1.);
2784
}
2785
#endif
2786
2787
2788
mat4 rotate(vec3 axis, float angle) {
2789
float s = sin(angle);
2790
float c = cos(angle);
2791
float oc = 1. - c;
2792
2793
vec3 sa = axis * s;
2794
2795
mat4 mr = mat4(1.);
2796
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
2797
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
2798
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
2799
2800
return mr;
2801
}
2802
2803
mat4 rotation(vec3 rot) {
2804
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
2805
}
2806
2807
mat3 modelToNormal(mat4 mat) {
2808
// Discard the edges. This won't be accurate for scaled or skewed matrices,
2809
// but we don't have to work with those often.
2810
mat3 m;
2811
m[0] = mat[0].xyz;
2812
m[1] = mat[1].xyz;
2813
m[2] = mat[2].xyz;
2814
return m;
2815
}
2816
2817
float diffuse(vec3 normal) {
2818
vec3 n2 = normal * normal * vec3(.6, .25, .8);
2819
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
2820
}
2821
struct Vertex {
2822
vec3 pos;
2823
vec2 texCoords;
2824
vec3 normal;
2825
};
2826
2827
struct BlockFrag {
2828
vec2 texCoords;
2829
vec4 color;
2830
float diffuse;
2831
vec2 light;
2832
};
2833
2834
#if defined(FRAGMENT_SHADER)
2835
void fragment(BlockFrag r) {
2836
vec4 tex = FLWBlockTexture(r.texCoords);
2837
2838
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
2839
2840
FLWFinalizeColor(color);
2841
}
2842
#endif
2843
#define PI 3.1415926538
2844
2845
2846
2847
2848
struct Rotating {
2849
vec2 light;
2850
vec4 color;
2851
vec3 pos;
2852
float speed;
2853
float offset;
2854
vec3 axis;
2855
};
2856
2857
2858
2859
2860
mat4 kineticRotation(float offset, float speed, vec3 axis) {
2861
float degrees = offset + uTime * speed * 3./10.;
2862
float angle = fract(degrees / 360.) * PI * 2.;
2863
2864
return rotate(axis, angle);
2865
}
2866
2867
#if defined(VERTEX_SHADER)
2868
BlockFrag vertex(Vertex v, Rotating instance) {
2869
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
2870
2871
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
2872
worldPos += vec4(instance.pos + .5, 0.);
2873
2874
vec3 norm = modelToNormal(spin) * v.normal;
2875
2876
FLWFinalizeWorldPos(worldPos);
2877
FLWFinalizeNormal(norm);
2878
2879
BlockFrag b;
2880
b.diffuse = diffuse(norm);
2881
b.texCoords = v.texCoords;
2882
b.light = instance.light;
2883
2884
#if defined(DEBUG_RAINBOW)
2885
b.color = instance.color;
2886
#elif defined(DEBUG_NORMAL)
2887
b.color = vec4(norm, 1.);
2888
#else
2889
b.color = vec4(1.);
2890
#endif
2891
2892
return b;
2893
}
2894
#endif
2895
2896
in vec2 v2f_texCoords;
2897
in vec4 v2f_color;
2898
in float v2f_diffuse;
2899
in vec2 v2f_light;
2900
void main() {
2901
BlockFrag o;
2902
o.texCoords = v2f_texCoords;
2903
o.color = v2f_color;
2904
o.diffuse = v2f_diffuse;
2905
o.light = v2f_light;
2906
fragment(o);
2907
}
2908
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
2909
2910
[17:17:49] [Render thread/ERROR]: #version 150
2911
#extension GL_ARB_conservative_depth : enable
2912
#define VERTEX_SHADER
2913
#if defined(VERTEX_SHADER)
2914
out float FragDistance;
2915
#elif defined(FRAGMENT_SHADER)
2916
in float FragDistance;
2917
#endif
2918
uniform vec4 uFogColor;
2919
uniform vec2 uFogRange;
2920
2921
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
2922
float distXZ = length(worldPos.xz - cameraPos.xz);
2923
float distY = abs(worldPos.y - cameraPos.y);
2924
return max(distXZ, distY);
2925
}
2926
2927
float cylindrical_distance(vec3 worldPos) {
2928
float distXZ = length(worldPos.xz);
2929
float distY = abs(worldPos.y);
2930
return max(distXZ, distY);
2931
}
2932
2933
float FLWFogFactor() {
2934
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
2935
}
2936
2937
2938
uniform float uTime;
2939
uniform mat4 uViewProjection;
2940
uniform vec3 uCameraPos;
2941
2942
uniform vec2 uTextureScale;
2943
uniform sampler2D uBlockAtlas;
2944
uniform sampler2D uLightMap;
2945
uniform sampler2D uCrumbling;
2946
2947
uniform vec2 uWindowSize;
2948
2949
void FLWFinalizeNormal(inout vec3 normal) {
2950
// noop
2951
}
2952
2953
#if defined(VERTEX_SHADER)
2954
void FLWFinalizeWorldPos(inout vec4 worldPos) {
2955
#if defined(USE_FOG)
2956
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
2957
#endif
2958
2959
gl_Position = uViewProjection * worldPos;
2960
}
2961
2962
#elif defined(FRAGMENT_SHADER)
2963
2964
out vec4 fragColor;
2965
2966
vec4 FLWBlockTexture(vec2 texCoords) {
2967
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
2968
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
2969
cr.a = cr.a * diffuseAlpha;
2970
return cr;
2971
}
2972
2973
void FLWFinalizeColor(vec4 color) {
2974
#if defined(USE_FOG)
2975
float a = color.a;
2976
float fog = clamp(FLWFogFactor(), 0., 1.);
2977
2978
color = mix(uFogColor, color, fog);
2979
color.a = a;
2980
#endif
2981
2982
if (color.a < 0.1) {
2983
discard;
2984
}
2985
2986
fragColor = color;
2987
}
2988
2989
vec4 FLWLight(vec2 lightCoords) {
2990
return vec4(1.);
2991
}
2992
#endif
2993
2994
2995
mat4 rotate(vec3 axis, float angle) {
2996
float s = sin(angle);
2997
float c = cos(angle);
2998
float oc = 1. - c;
2999
3000
vec3 sa = axis * s;
3001
3002
mat4 mr = mat4(1.);
3003
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
3004
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
3005
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
3006
3007
return mr;
3008
}
3009
3010
mat4 rotation(vec3 rot) {
3011
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
3012
}
3013
3014
mat3 modelToNormal(mat4 mat) {
3015
// Discard the edges. This won't be accurate for scaled or skewed matrices,
3016
// but we don't have to work with those often.
3017
mat3 m;
3018
m[0] = mat[0].xyz;
3019
m[1] = mat[1].xyz;
3020
m[2] = mat[2].xyz;
3021
return m;
3022
}
3023
3024
#define PIOVER2 1.5707963268
3025
3026
vec4 quat(vec3 axis, float angle) {
3027
float halfAngle = angle * PIOVER2 / 180.0;
3028
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
3029
return vec4(axis.xyz * cs.y, cs.x);
3030
}
3031
3032
vec4 quatMult(vec4 q1, vec4 q2) {
3033
// disgustingly vectorized quaternion multiplication
3034
vec4 a = q1.w * q2.xyzw;
3035
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
3036
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
3037
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
3038
3039
return a + b + c + d;
3040
}
3041
3042
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
3043
vec3 i = q.xyz;
3044
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
3045
}
3046
3047
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
3048
return rotateVertexByQuat(v, quat(axis, angle));
3049
}
3050
3051
float diffuse(vec3 normal) {
3052
vec3 n2 = normal * normal * vec3(.6, .25, .8);
3053
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
3054
}
3055
struct Vertex {
3056
vec3 pos;
3057
vec2 texCoords;
3058
vec3 normal;
3059
};
3060
3061
struct BlockFrag {
3062
vec2 texCoords;
3063
vec4 color;
3064
float diffuse;
3065
vec2 light;
3066
};
3067
3068
#if defined(FRAGMENT_SHADER)
3069
void fragment(BlockFrag r) {
3070
vec4 tex = FLWBlockTexture(r.texCoords);
3071
3072
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
3073
3074
FLWFinalizeColor(color);
3075
}
3076
#endif
3077
#define PI 3.1415926538
3078
3079
3080
3081
3082
3083
struct Actor {
3084
vec3 pos;
3085
vec2 light;
3086
float offset;
3087
vec3 axis;
3088
vec4 rotation;
3089
vec3 rotationCenter;
3090
float speed;
3091
};
3092
3093
3094
3095
3096
#if defined(VERTEX_SHADER)
3097
BlockFrag vertex(Vertex v, Actor instance) {
3098
float degrees = instance.offset + uTime * instance.speed / 20.;
3099
//float angle = fract(degrees / 360.) * PI * 2.;
3100
3101
vec4 kineticRot = quat(instance.axis, degrees);
3102
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
3103
3104
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
3105
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
3106
3107
FLWFinalizeWorldPos(worldPos);
3108
FLWFinalizeNormal(norm);
3109
3110
BlockFrag b;
3111
b.diffuse = diffuse(norm);
3112
b.texCoords = v.texCoords;
3113
b.light = instance.light;
3114
3115
#if defined(DEBUG_NORMAL)
3116
b.color = vec4(norm, 1.);
3117
#else
3118
b.color = vec4(1.);
3119
#endif
3120
3121
return b;
3122
}
3123
#endif
3124
3125
in vec3 a_v_pos;
3126
in vec2 a_v_texCoords;
3127
in vec3 a_v_normal;
3128
in vec3 a_i_pos;
3129
in vec2 a_i_light;
3130
in float a_i_offset;
3131
in vec3 a_i_axis;
3132
in vec4 a_i_rotation;
3133
in vec3 a_i_rotationCenter;
3134
in float a_i_speed;
3135
out vec2 v2f_texCoords;
3136
out vec4 v2f_color;
3137
out float v2f_diffuse;
3138
out vec2 v2f_light;
3139
void main() {
3140
Vertex v;
3141
v.pos = a_v_pos;
3142
v.texCoords = a_v_texCoords;
3143
v.normal = a_v_normal;
3144
Actor i;
3145
i.pos = a_i_pos;
3146
i.light = a_i_light;
3147
i.offset = a_i_offset;
3148
i.axis = a_i_axis;
3149
i.rotation = a_i_rotation;
3150
i.rotationCenter = a_i_rotationCenter;
3151
i.speed = a_i_speed;
3152
BlockFrag o = vertex(v, i);
3153
v2f_texCoords = o.texCoords;
3154
v2f_color = o.color;
3155
v2f_diffuse = o.diffuse;
3156
v2f_light = o.light;
3157
}
3158
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
3159
3160
[17:17:49] [Render thread/ERROR]: #version 150
3161
#extension GL_ARB_conservative_depth : enable
3162
#define FRAGMENT_SHADER
3163
#if defined(VERTEX_SHADER)
3164
out float FragDistance;
3165
#elif defined(FRAGMENT_SHADER)
3166
in float FragDistance;
3167
#endif
3168
uniform vec4 uFogColor;
3169
uniform vec2 uFogRange;
3170
3171
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
3172
float distXZ = length(worldPos.xz - cameraPos.xz);
3173
float distY = abs(worldPos.y - cameraPos.y);
3174
return max(distXZ, distY);
3175
}
3176
3177
float cylindrical_distance(vec3 worldPos) {
3178
float distXZ = length(worldPos.xz);
3179
float distY = abs(worldPos.y);
3180
return max(distXZ, distY);
3181
}
3182
3183
float FLWFogFactor() {
3184
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
3185
}
3186
3187
3188
uniform float uTime;
3189
uniform mat4 uViewProjection;
3190
uniform vec3 uCameraPos;
3191
3192
uniform vec2 uTextureScale;
3193
uniform sampler2D uBlockAtlas;
3194
uniform sampler2D uLightMap;
3195
uniform sampler2D uCrumbling;
3196
3197
uniform vec2 uWindowSize;
3198
3199
void FLWFinalizeNormal(inout vec3 normal) {
3200
// noop
3201
}
3202
3203
#if defined(VERTEX_SHADER)
3204
void FLWFinalizeWorldPos(inout vec4 worldPos) {
3205
#if defined(USE_FOG)
3206
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
3207
#endif
3208
3209
gl_Position = uViewProjection * worldPos;
3210
}
3211
3212
#elif defined(FRAGMENT_SHADER)
3213
3214
out vec4 fragColor;
3215
3216
vec4 FLWBlockTexture(vec2 texCoords) {
3217
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
3218
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
3219
cr.a = cr.a * diffuseAlpha;
3220
return cr;
3221
}
3222
3223
void FLWFinalizeColor(vec4 color) {
3224
#if defined(USE_FOG)
3225
float a = color.a;
3226
float fog = clamp(FLWFogFactor(), 0., 1.);
3227
3228
color = mix(uFogColor, color, fog);
3229
color.a = a;
3230
#endif
3231
3232
if (color.a < 0.1) {
3233
discard;
3234
}
3235
3236
fragColor = color;
3237
}
3238
3239
vec4 FLWLight(vec2 lightCoords) {
3240
return vec4(1.);
3241
}
3242
#endif
3243
3244
3245
mat4 rotate(vec3 axis, float angle) {
3246
float s = sin(angle);
3247
float c = cos(angle);
3248
float oc = 1. - c;
3249
3250
vec3 sa = axis * s;
3251
3252
mat4 mr = mat4(1.);
3253
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
3254
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
3255
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
3256
3257
return mr;
3258
}
3259
3260
mat4 rotation(vec3 rot) {
3261
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
3262
}
3263
3264
mat3 modelToNormal(mat4 mat) {
3265
// Discard the edges. This won't be accurate for scaled or skewed matrices,
3266
// but we don't have to work with those often.
3267
mat3 m;
3268
m[0] = mat[0].xyz;
3269
m[1] = mat[1].xyz;
3270
m[2] = mat[2].xyz;
3271
return m;
3272
}
3273
3274
#define PIOVER2 1.5707963268
3275
3276
vec4 quat(vec3 axis, float angle) {
3277
float halfAngle = angle * PIOVER2 / 180.0;
3278
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
3279
return vec4(axis.xyz * cs.y, cs.x);
3280
}
3281
3282
vec4 quatMult(vec4 q1, vec4 q2) {
3283
// disgustingly vectorized quaternion multiplication
3284
vec4 a = q1.w * q2.xyzw;
3285
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
3286
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
3287
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
3288
3289
return a + b + c + d;
3290
}
3291
3292
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
3293
vec3 i = q.xyz;
3294
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
3295
}
3296
3297
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
3298
return rotateVertexByQuat(v, quat(axis, angle));
3299
}
3300
3301
float diffuse(vec3 normal) {
3302
vec3 n2 = normal * normal * vec3(.6, .25, .8);
3303
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
3304
}
3305
struct Vertex {
3306
vec3 pos;
3307
vec2 texCoords;
3308
vec3 normal;
3309
};
3310
3311
struct BlockFrag {
3312
vec2 texCoords;
3313
vec4 color;
3314
float diffuse;
3315
vec2 light;
3316
};
3317
3318
#if defined(FRAGMENT_SHADER)
3319
void fragment(BlockFrag r) {
3320
vec4 tex = FLWBlockTexture(r.texCoords);
3321
3322
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
3323
3324
FLWFinalizeColor(color);
3325
}
3326
#endif
3327
#define PI 3.1415926538
3328
3329
3330
3331
3332
3333
struct Actor {
3334
vec3 pos;
3335
vec2 light;
3336
float offset;
3337
vec3 axis;
3338
vec4 rotation;
3339
vec3 rotationCenter;
3340
float speed;
3341
};
3342
3343
3344
3345
3346
#if defined(VERTEX_SHADER)
3347
BlockFrag vertex(Vertex v, Actor instance) {
3348
float degrees = instance.offset + uTime * instance.speed / 20.;
3349
//float angle = fract(degrees / 360.) * PI * 2.;
3350
3351
vec4 kineticRot = quat(instance.axis, degrees);
3352
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
3353
3354
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
3355
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
3356
3357
FLWFinalizeWorldPos(worldPos);
3358
FLWFinalizeNormal(norm);
3359
3360
BlockFrag b;
3361
b.diffuse = diffuse(norm);
3362
b.texCoords = v.texCoords;
3363
b.light = instance.light;
3364
3365
#if defined(DEBUG_NORMAL)
3366
b.color = vec4(norm, 1.);
3367
#else
3368
b.color = vec4(1.);
3369
#endif
3370
3371
return b;
3372
}
3373
#endif
3374
3375
in vec2 v2f_texCoords;
3376
in vec4 v2f_color;
3377
in float v2f_diffuse;
3378
in vec2 v2f_light;
3379
void main() {
3380
BlockFrag o;
3381
o.texCoords = v2f_texCoords;
3382
o.color = v2f_color;
3383
o.diffuse = v2f_diffuse;
3384
o.light = v2f_light;
3385
fragment(o);
3386
}
3387
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
3388
3389
[17:17:49] [Render thread/ERROR]: #version 150
3390
#extension GL_ARB_conservative_depth : enable
3391
#define VERTEX_SHADER
3392
#define DEBUG_NORMAL
3393
#if defined(VERTEX_SHADER)
3394
out float FragDistance;
3395
#elif defined(FRAGMENT_SHADER)
3396
in float FragDistance;
3397
#endif
3398
uniform vec4 uFogColor;
3399
uniform vec2 uFogRange;
3400
3401
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
3402
float distXZ = length(worldPos.xz - cameraPos.xz);
3403
float distY = abs(worldPos.y - cameraPos.y);
3404
return max(distXZ, distY);
3405
}
3406
3407
float cylindrical_distance(vec3 worldPos) {
3408
float distXZ = length(worldPos.xz);
3409
float distY = abs(worldPos.y);
3410
return max(distXZ, distY);
3411
}
3412
3413
float FLWFogFactor() {
3414
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
3415
}
3416
3417
3418
uniform float uTime;
3419
uniform mat4 uViewProjection;
3420
uniform vec3 uCameraPos;
3421
3422
uniform vec2 uTextureScale;
3423
uniform sampler2D uBlockAtlas;
3424
uniform sampler2D uLightMap;
3425
uniform sampler2D uCrumbling;
3426
3427
uniform vec2 uWindowSize;
3428
3429
void FLWFinalizeNormal(inout vec3 normal) {
3430
// noop
3431
}
3432
3433
#if defined(VERTEX_SHADER)
3434
void FLWFinalizeWorldPos(inout vec4 worldPos) {
3435
#if defined(USE_FOG)
3436
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
3437
#endif
3438
3439
gl_Position = uViewProjection * worldPos;
3440
}
3441
3442
#elif defined(FRAGMENT_SHADER)
3443
3444
out vec4 fragColor;
3445
3446
vec4 FLWBlockTexture(vec2 texCoords) {
3447
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
3448
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
3449
cr.a = cr.a * diffuseAlpha;
3450
return cr;
3451
}
3452
3453
void FLWFinalizeColor(vec4 color) {
3454
#if defined(USE_FOG)
3455
float a = color.a;
3456
float fog = clamp(FLWFogFactor(), 0., 1.);
3457
3458
color = mix(uFogColor, color, fog);
3459
color.a = a;
3460
#endif
3461
3462
if (color.a < 0.1) {
3463
discard;
3464
}
3465
3466
fragColor = color;
3467
}
3468
3469
vec4 FLWLight(vec2 lightCoords) {
3470
return vec4(1.);
3471
}
3472
#endif
3473
3474
3475
mat4 rotate(vec3 axis, float angle) {
3476
float s = sin(angle);
3477
float c = cos(angle);
3478
float oc = 1. - c;
3479
3480
vec3 sa = axis * s;
3481
3482
mat4 mr = mat4(1.);
3483
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
3484
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
3485
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
3486
3487
return mr;
3488
}
3489
3490
mat4 rotation(vec3 rot) {
3491
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
3492
}
3493
3494
mat3 modelToNormal(mat4 mat) {
3495
// Discard the edges. This won't be accurate for scaled or skewed matrices,
3496
// but we don't have to work with those often.
3497
mat3 m;
3498
m[0] = mat[0].xyz;
3499
m[1] = mat[1].xyz;
3500
m[2] = mat[2].xyz;
3501
return m;
3502
}
3503
3504
#define PIOVER2 1.5707963268
3505
3506
vec4 quat(vec3 axis, float angle) {
3507
float halfAngle = angle * PIOVER2 / 180.0;
3508
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
3509
return vec4(axis.xyz * cs.y, cs.x);
3510
}
3511
3512
vec4 quatMult(vec4 q1, vec4 q2) {
3513
// disgustingly vectorized quaternion multiplication
3514
vec4 a = q1.w * q2.xyzw;
3515
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
3516
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
3517
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
3518
3519
return a + b + c + d;
3520
}
3521
3522
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
3523
vec3 i = q.xyz;
3524
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
3525
}
3526
3527
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
3528
return rotateVertexByQuat(v, quat(axis, angle));
3529
}
3530
3531
float diffuse(vec3 normal) {
3532
vec3 n2 = normal * normal * vec3(.6, .25, .8);
3533
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
3534
}
3535
struct Vertex {
3536
vec3 pos;
3537
vec2 texCoords;
3538
vec3 normal;
3539
};
3540
3541
struct BlockFrag {
3542
vec2 texCoords;
3543
vec4 color;
3544
float diffuse;
3545
vec2 light;
3546
};
3547
3548
#if defined(FRAGMENT_SHADER)
3549
void fragment(BlockFrag r) {
3550
vec4 tex = FLWBlockTexture(r.texCoords);
3551
3552
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
3553
3554
FLWFinalizeColor(color);
3555
}
3556
#endif
3557
#define PI 3.1415926538
3558
3559
3560
3561
3562
3563
struct Actor {
3564
vec3 pos;
3565
vec2 light;
3566
float offset;
3567
vec3 axis;
3568
vec4 rotation;
3569
vec3 rotationCenter;
3570
float speed;
3571
};
3572
3573
3574
3575
3576
#if defined(VERTEX_SHADER)
3577
BlockFrag vertex(Vertex v, Actor instance) {
3578
float degrees = instance.offset + uTime * instance.speed / 20.;
3579
//float angle = fract(degrees / 360.) * PI * 2.;
3580
3581
vec4 kineticRot = quat(instance.axis, degrees);
3582
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
3583
3584
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
3585
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
3586
3587
FLWFinalizeWorldPos(worldPos);
3588
FLWFinalizeNormal(norm);
3589
3590
BlockFrag b;
3591
b.diffuse = diffuse(norm);
3592
b.texCoords = v.texCoords;
3593
b.light = instance.light;
3594
3595
#if defined(DEBUG_NORMAL)
3596
b.color = vec4(norm, 1.);
3597
#else
3598
b.color = vec4(1.);
3599
#endif
3600
3601
return b;
3602
}
3603
#endif
3604
3605
in vec3 a_v_pos;
3606
in vec2 a_v_texCoords;
3607
in vec3 a_v_normal;
3608
in vec3 a_i_pos;
3609
in vec2 a_i_light;
3610
in float a_i_offset;
3611
in vec3 a_i_axis;
3612
in vec4 a_i_rotation;
3613
in vec3 a_i_rotationCenter;
3614
in float a_i_speed;
3615
out vec2 v2f_texCoords;
3616
out vec4 v2f_color;
3617
out float v2f_diffuse;
3618
out vec2 v2f_light;
3619
void main() {
3620
Vertex v;
3621
v.pos = a_v_pos;
3622
v.texCoords = a_v_texCoords;
3623
v.normal = a_v_normal;
3624
Actor i;
3625
i.pos = a_i_pos;
3626
i.light = a_i_light;
3627
i.offset = a_i_offset;
3628
i.axis = a_i_axis;
3629
i.rotation = a_i_rotation;
3630
i.rotationCenter = a_i_rotationCenter;
3631
i.speed = a_i_speed;
3632
BlockFrag o = vertex(v, i);
3633
v2f_texCoords = o.texCoords;
3634
v2f_color = o.color;
3635
v2f_diffuse = o.diffuse;
3636
v2f_light = o.light;
3637
}
3638
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
3639
3640
[17:17:49] [Render thread/ERROR]: #version 150
3641
#extension GL_ARB_conservative_depth : enable
3642
#define FRAGMENT_SHADER
3643
#define DEBUG_NORMAL
3644
#if defined(VERTEX_SHADER)
3645
out float FragDistance;
3646
#elif defined(FRAGMENT_SHADER)
3647
in float FragDistance;
3648
#endif
3649
uniform vec4 uFogColor;
3650
uniform vec2 uFogRange;
3651
3652
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
3653
float distXZ = length(worldPos.xz - cameraPos.xz);
3654
float distY = abs(worldPos.y - cameraPos.y);
3655
return max(distXZ, distY);
3656
}
3657
3658
float cylindrical_distance(vec3 worldPos) {
3659
float distXZ = length(worldPos.xz);
3660
float distY = abs(worldPos.y);
3661
return max(distXZ, distY);
3662
}
3663
3664
float FLWFogFactor() {
3665
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
3666
}
3667
3668
3669
uniform float uTime;
3670
uniform mat4 uViewProjection;
3671
uniform vec3 uCameraPos;
3672
3673
uniform vec2 uTextureScale;
3674
uniform sampler2D uBlockAtlas;
3675
uniform sampler2D uLightMap;
3676
uniform sampler2D uCrumbling;
3677
3678
uniform vec2 uWindowSize;
3679
3680
void FLWFinalizeNormal(inout vec3 normal) {
3681
// noop
3682
}
3683
3684
#if defined(VERTEX_SHADER)
3685
void FLWFinalizeWorldPos(inout vec4 worldPos) {
3686
#if defined(USE_FOG)
3687
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
3688
#endif
3689
3690
gl_Position = uViewProjection * worldPos;
3691
}
3692
3693
#elif defined(FRAGMENT_SHADER)
3694
3695
out vec4 fragColor;
3696
3697
vec4 FLWBlockTexture(vec2 texCoords) {
3698
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
3699
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
3700
cr.a = cr.a * diffuseAlpha;
3701
return cr;
3702
}
3703
3704
void FLWFinalizeColor(vec4 color) {
3705
#if defined(USE_FOG)
3706
float a = color.a;
3707
float fog = clamp(FLWFogFactor(), 0., 1.);
3708
3709
color = mix(uFogColor, color, fog);
3710
color.a = a;
3711
#endif
3712
3713
if (color.a < 0.1) {
3714
discard;
3715
}
3716
3717
fragColor = color;
3718
}
3719
3720
vec4 FLWLight(vec2 lightCoords) {
3721
return vec4(1.);
3722
}
3723
#endif
3724
3725
3726
mat4 rotate(vec3 axis, float angle) {
3727
float s = sin(angle);
3728
float c = cos(angle);
3729
float oc = 1. - c;
3730
3731
vec3 sa = axis * s;
3732
3733
mat4 mr = mat4(1.);
3734
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
3735
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
3736
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
3737
3738
return mr;
3739
}
3740
3741
mat4 rotation(vec3 rot) {
3742
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
3743
}
3744
3745
mat3 modelToNormal(mat4 mat) {
3746
// Discard the edges. This won't be accurate for scaled or skewed matrices,
3747
// but we don't have to work with those often.
3748
mat3 m;
3749
m[0] = mat[0].xyz;
3750
m[1] = mat[1].xyz;
3751
m[2] = mat[2].xyz;
3752
return m;
3753
}
3754
3755
#define PIOVER2 1.5707963268
3756
3757
vec4 quat(vec3 axis, float angle) {
3758
float halfAngle = angle * PIOVER2 / 180.0;
3759
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
3760
return vec4(axis.xyz * cs.y, cs.x);
3761
}
3762
3763
vec4 quatMult(vec4 q1, vec4 q2) {
3764
// disgustingly vectorized quaternion multiplication
3765
vec4 a = q1.w * q2.xyzw;
3766
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
3767
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
3768
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
3769
3770
return a + b + c + d;
3771
}
3772
3773
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
3774
vec3 i = q.xyz;
3775
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
3776
}
3777
3778
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
3779
return rotateVertexByQuat(v, quat(axis, angle));
3780
}
3781
3782
float diffuse(vec3 normal) {
3783
vec3 n2 = normal * normal * vec3(.6, .25, .8);
3784
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
3785
}
3786
struct Vertex {
3787
vec3 pos;
3788
vec2 texCoords;
3789
vec3 normal;
3790
};
3791
3792
struct BlockFrag {
3793
vec2 texCoords;
3794
vec4 color;
3795
float diffuse;
3796
vec2 light;
3797
};
3798
3799
#if defined(FRAGMENT_SHADER)
3800
void fragment(BlockFrag r) {
3801
vec4 tex = FLWBlockTexture(r.texCoords);
3802
3803
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
3804
3805
FLWFinalizeColor(color);
3806
}
3807
#endif
3808
#define PI 3.1415926538
3809
3810
3811
3812
3813
3814
struct Actor {
3815
vec3 pos;
3816
vec2 light;
3817
float offset;
3818
vec3 axis;
3819
vec4 rotation;
3820
vec3 rotationCenter;
3821
float speed;
3822
};
3823
3824
3825
3826
3827
#if defined(VERTEX_SHADER)
3828
BlockFrag vertex(Vertex v, Actor instance) {
3829
float degrees = instance.offset + uTime * instance.speed / 20.;
3830
//float angle = fract(degrees / 360.) * PI * 2.;
3831
3832
vec4 kineticRot = quat(instance.axis, degrees);
3833
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
3834
3835
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
3836
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
3837
3838
FLWFinalizeWorldPos(worldPos);
3839
FLWFinalizeNormal(norm);
3840
3841
BlockFrag b;
3842
b.diffuse = diffuse(norm);
3843
b.texCoords = v.texCoords;
3844
b.light = instance.light;
3845
3846
#if defined(DEBUG_NORMAL)
3847
b.color = vec4(norm, 1.);
3848
#else
3849
b.color = vec4(1.);
3850
#endif
3851
3852
return b;
3853
}
3854
#endif
3855
3856
in vec2 v2f_texCoords;
3857
in vec4 v2f_color;
3858
in float v2f_diffuse;
3859
in vec2 v2f_light;
3860
void main() {
3861
BlockFrag o;
3862
o.texCoords = v2f_texCoords;
3863
o.color = v2f_color;
3864
o.diffuse = v2f_diffuse;
3865
o.light = v2f_light;
3866
fragment(o);
3867
}
3868
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
3869
3870
[17:17:49] [Render thread/ERROR]: #version 150
3871
#extension GL_ARB_conservative_depth : enable
3872
#define VERTEX_SHADER
3873
#if defined(VERTEX_SHADER)
3874
out float FragDistance;
3875
#elif defined(FRAGMENT_SHADER)
3876
in float FragDistance;
3877
#endif
3878
uniform vec4 uFogColor;
3879
uniform vec2 uFogRange;
3880
3881
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
3882
float distXZ = length(worldPos.xz - cameraPos.xz);
3883
float distY = abs(worldPos.y - cameraPos.y);
3884
return max(distXZ, distY);
3885
}
3886
3887
float cylindrical_distance(vec3 worldPos) {
3888
float distXZ = length(worldPos.xz);
3889
float distY = abs(worldPos.y);
3890
return max(distXZ, distY);
3891
}
3892
3893
float FLWFogFactor() {
3894
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
3895
}
3896
3897
3898
uniform float uTime;
3899
uniform mat4 uViewProjection;
3900
uniform vec3 uCameraPos;
3901
3902
uniform vec2 uTextureScale;
3903
uniform sampler2D uBlockAtlas;
3904
uniform sampler2D uLightMap;
3905
uniform sampler2D uCrumbling;
3906
3907
uniform vec2 uWindowSize;
3908
3909
void FLWFinalizeNormal(inout vec3 normal) {
3910
// noop
3911
}
3912
3913
#if defined(VERTEX_SHADER)
3914
void FLWFinalizeWorldPos(inout vec4 worldPos) {
3915
#if defined(USE_FOG)
3916
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
3917
#endif
3918
3919
gl_Position = uViewProjection * worldPos;
3920
}
3921
3922
#elif defined(FRAGMENT_SHADER)
3923
3924
out vec4 fragColor;
3925
3926
vec4 FLWBlockTexture(vec2 texCoords) {
3927
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
3928
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
3929
cr.a = cr.a * diffuseAlpha;
3930
return cr;
3931
}
3932
3933
void FLWFinalizeColor(vec4 color) {
3934
#if defined(USE_FOG)
3935
float a = color.a;
3936
float fog = clamp(FLWFogFactor(), 0., 1.);
3937
3938
color = mix(uFogColor, color, fog);
3939
color.a = a;
3940
#endif
3941
3942
if (color.a < 0.1) {
3943
discard;
3944
}
3945
3946
fragColor = color;
3947
}
3948
3949
vec4 FLWLight(vec2 lightCoords) {
3950
return vec4(1.);
3951
}
3952
#endif
3953
3954
3955
mat4 rotate(vec3 axis, float angle) {
3956
float s = sin(angle);
3957
float c = cos(angle);
3958
float oc = 1. - c;
3959
3960
vec3 sa = axis * s;
3961
3962
mat4 mr = mat4(1.);
3963
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
3964
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
3965
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
3966
3967
return mr;
3968
}
3969
3970
mat4 rotation(vec3 rot) {
3971
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
3972
}
3973
3974
mat3 modelToNormal(mat4 mat) {
3975
// Discard the edges. This won't be accurate for scaled or skewed matrices,
3976
// but we don't have to work with those often.
3977
mat3 m;
3978
m[0] = mat[0].xyz;
3979
m[1] = mat[1].xyz;
3980
m[2] = mat[2].xyz;
3981
return m;
3982
}
3983
3984
#define PIOVER2 1.5707963268
3985
3986
vec4 quat(vec3 axis, float angle) {
3987
float halfAngle = angle * PIOVER2 / 180.0;
3988
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
3989
return vec4(axis.xyz * cs.y, cs.x);
3990
}
3991
3992
vec4 quatMult(vec4 q1, vec4 q2) {
3993
// disgustingly vectorized quaternion multiplication
3994
vec4 a = q1.w * q2.xyzw;
3995
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
3996
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
3997
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
3998
3999
return a + b + c + d;
4000
}
4001
4002
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
4003
vec3 i = q.xyz;
4004
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
4005
}
4006
4007
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
4008
return rotateVertexByQuat(v, quat(axis, angle));
4009
}
4010
4011
float diffuse(vec3 normal) {
4012
vec3 n2 = normal * normal * vec3(.6, .25, .8);
4013
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
4014
}
4015
struct Vertex {
4016
vec3 pos;
4017
vec2 texCoords;
4018
vec3 normal;
4019
};
4020
4021
struct BlockFrag {
4022
vec2 texCoords;
4023
vec4 color;
4024
float diffuse;
4025
vec2 light;
4026
};
4027
4028
#if defined(FRAGMENT_SHADER)
4029
void fragment(BlockFrag r) {
4030
vec4 tex = FLWBlockTexture(r.texCoords);
4031
4032
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
4033
4034
FLWFinalizeColor(color);
4035
}
4036
#endif
4037
#define PI 3.1415926538
4038
4039
4040
4041
4042
4043
struct Flap {
4044
vec3 instancePos;
4045
vec2 light;
4046
vec3 segmentOffset;
4047
vec3 pivot;
4048
float horizontalAngle;
4049
float intensity;
4050
float flapScale;
4051
float flapness;
4052
};
4053
4054
4055
4056
4057
#if defined(VERTEX_SHADER)
4058
4059
float toRad(float degrees) {
4060
return fract(degrees / 360.) * PI * 2.;
4061
}
4062
4063
float getFlapAngle(float flapness, float intensity, float scale) {
4064
float absFlap = abs(flapness);
4065
4066
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
4067
4068
float halfAngle = angle * 0.5;
4069
4070
float which = step(0., flapness); // 0 if negative, 1 if positive
4071
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
4072
4073
return degrees;
4074
}
4075
4076
BlockFrag vertex(Vertex v, Flap flap) {
4077
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
4078
4079
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
4080
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
4081
4082
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
4083
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
4084
4085
vec4 worldPos = vec4(rotated, 1.);
4086
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
4087
4088
FLWFinalizeWorldPos(worldPos);
4089
FLWFinalizeNormal(norm);
4090
4091
BlockFrag b;
4092
b.diffuse = diffuse(norm);
4093
b.texCoords = v.texCoords;
4094
b.light = flap.light;
4095
#if defined(DEBUG_NORMAL)
4096
b.color = vec4(norm, 1.);
4097
#else
4098
b.color = vec4(1.);
4099
#endif
4100
return b;
4101
}
4102
#endif
4103
4104
in vec3 a_v_pos;
4105
in vec2 a_v_texCoords;
4106
in vec3 a_v_normal;
4107
in vec3 a_i_instancePos;
4108
in vec2 a_i_light;
4109
in vec3 a_i_segmentOffset;
4110
in vec3 a_i_pivot;
4111
in float a_i_horizontalAngle;
4112
in float a_i_intensity;
4113
in float a_i_flapScale;
4114
in float a_i_flapness;
4115
out vec2 v2f_texCoords;
4116
out vec4 v2f_color;
4117
out float v2f_diffuse;
4118
out vec2 v2f_light;
4119
void main() {
4120
Vertex v;
4121
v.pos = a_v_pos;
4122
v.texCoords = a_v_texCoords;
4123
v.normal = a_v_normal;
4124
Flap i;
4125
i.instancePos = a_i_instancePos;
4126
i.light = a_i_light;
4127
i.segmentOffset = a_i_segmentOffset;
4128
i.pivot = a_i_pivot;
4129
i.horizontalAngle = a_i_horizontalAngle;
4130
i.intensity = a_i_intensity;
4131
i.flapScale = a_i_flapScale;
4132
i.flapness = a_i_flapness;
4133
BlockFrag o = vertex(v, i);
4134
v2f_texCoords = o.texCoords;
4135
v2f_color = o.color;
4136
v2f_diffuse = o.diffuse;
4137
v2f_light = o.light;
4138
}
4139
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
4140
4141
[17:17:49] [Render thread/ERROR]: #version 150
4142
#extension GL_ARB_conservative_depth : enable
4143
#define FRAGMENT_SHADER
4144
#if defined(VERTEX_SHADER)
4145
out float FragDistance;
4146
#elif defined(FRAGMENT_SHADER)
4147
in float FragDistance;
4148
#endif
4149
uniform vec4 uFogColor;
4150
uniform vec2 uFogRange;
4151
4152
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
4153
float distXZ = length(worldPos.xz - cameraPos.xz);
4154
float distY = abs(worldPos.y - cameraPos.y);
4155
return max(distXZ, distY);
4156
}
4157
4158
float cylindrical_distance(vec3 worldPos) {
4159
float distXZ = length(worldPos.xz);
4160
float distY = abs(worldPos.y);
4161
return max(distXZ, distY);
4162
}
4163
4164
float FLWFogFactor() {
4165
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
4166
}
4167
4168
4169
uniform float uTime;
4170
uniform mat4 uViewProjection;
4171
uniform vec3 uCameraPos;
4172
4173
uniform vec2 uTextureScale;
4174
uniform sampler2D uBlockAtlas;
4175
uniform sampler2D uLightMap;
4176
uniform sampler2D uCrumbling;
4177
4178
uniform vec2 uWindowSize;
4179
4180
void FLWFinalizeNormal(inout vec3 normal) {
4181
// noop
4182
}
4183
4184
#if defined(VERTEX_SHADER)
4185
void FLWFinalizeWorldPos(inout vec4 worldPos) {
4186
#if defined(USE_FOG)
4187
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
4188
#endif
4189
4190
gl_Position = uViewProjection * worldPos;
4191
}
4192
4193
#elif defined(FRAGMENT_SHADER)
4194
4195
out vec4 fragColor;
4196
4197
vec4 FLWBlockTexture(vec2 texCoords) {
4198
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
4199
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
4200
cr.a = cr.a * diffuseAlpha;
4201
return cr;
4202
}
4203
4204
void FLWFinalizeColor(vec4 color) {
4205
#if defined(USE_FOG)
4206
float a = color.a;
4207
float fog = clamp(FLWFogFactor(), 0., 1.);
4208
4209
color = mix(uFogColor, color, fog);
4210
color.a = a;
4211
#endif
4212
4213
if (color.a < 0.1) {
4214
discard;
4215
}
4216
4217
fragColor = color;
4218
}
4219
4220
vec4 FLWLight(vec2 lightCoords) {
4221
return vec4(1.);
4222
}
4223
#endif
4224
4225
4226
mat4 rotate(vec3 axis, float angle) {
4227
float s = sin(angle);
4228
float c = cos(angle);
4229
float oc = 1. - c;
4230
4231
vec3 sa = axis * s;
4232
4233
mat4 mr = mat4(1.);
4234
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
4235
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
4236
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
4237
4238
return mr;
4239
}
4240
4241
mat4 rotation(vec3 rot) {
4242
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
4243
}
4244
4245
mat3 modelToNormal(mat4 mat) {
4246
// Discard the edges. This won't be accurate for scaled or skewed matrices,
4247
// but we don't have to work with those often.
4248
mat3 m;
4249
m[0] = mat[0].xyz;
4250
m[1] = mat[1].xyz;
4251
m[2] = mat[2].xyz;
4252
return m;
4253
}
4254
4255
#define PIOVER2 1.5707963268
4256
4257
vec4 quat(vec3 axis, float angle) {
4258
float halfAngle = angle * PIOVER2 / 180.0;
4259
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
4260
return vec4(axis.xyz * cs.y, cs.x);
4261
}
4262
4263
vec4 quatMult(vec4 q1, vec4 q2) {
4264
// disgustingly vectorized quaternion multiplication
4265
vec4 a = q1.w * q2.xyzw;
4266
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
4267
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
4268
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
4269
4270
return a + b + c + d;
4271
}
4272
4273
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
4274
vec3 i = q.xyz;
4275
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
4276
}
4277
4278
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
4279
return rotateVertexByQuat(v, quat(axis, angle));
4280
}
4281
4282
float diffuse(vec3 normal) {
4283
vec3 n2 = normal * normal * vec3(.6, .25, .8);
4284
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
4285
}
4286
struct Vertex {
4287
vec3 pos;
4288
vec2 texCoords;
4289
vec3 normal;
4290
};
4291
4292
struct BlockFrag {
4293
vec2 texCoords;
4294
vec4 color;
4295
float diffuse;
4296
vec2 light;
4297
};
4298
4299
#if defined(FRAGMENT_SHADER)
4300
void fragment(BlockFrag r) {
4301
vec4 tex = FLWBlockTexture(r.texCoords);
4302
4303
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
4304
4305
FLWFinalizeColor(color);
4306
}
4307
#endif
4308
#define PI 3.1415926538
4309
4310
4311
4312
4313
4314
struct Flap {
4315
vec3 instancePos;
4316
vec2 light;
4317
vec3 segmentOffset;
4318
vec3 pivot;
4319
float horizontalAngle;
4320
float intensity;
4321
float flapScale;
4322
float flapness;
4323
};
4324
4325
4326
4327
4328
#if defined(VERTEX_SHADER)
4329
4330
float toRad(float degrees) {
4331
return fract(degrees / 360.) * PI * 2.;
4332
}
4333
4334
float getFlapAngle(float flapness, float intensity, float scale) {
4335
float absFlap = abs(flapness);
4336
4337
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
4338
4339
float halfAngle = angle * 0.5;
4340
4341
float which = step(0., flapness); // 0 if negative, 1 if positive
4342
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
4343
4344
return degrees;
4345
}
4346
4347
BlockFrag vertex(Vertex v, Flap flap) {
4348
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
4349
4350
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
4351
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
4352
4353
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
4354
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
4355
4356
vec4 worldPos = vec4(rotated, 1.);
4357
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
4358
4359
FLWFinalizeWorldPos(worldPos);
4360
FLWFinalizeNormal(norm);
4361
4362
BlockFrag b;
4363
b.diffuse = diffuse(norm);
4364
b.texCoords = v.texCoords;
4365
b.light = flap.light;
4366
#if defined(DEBUG_NORMAL)
4367
b.color = vec4(norm, 1.);
4368
#else
4369
b.color = vec4(1.);
4370
#endif
4371
return b;
4372
}
4373
#endif
4374
4375
in vec2 v2f_texCoords;
4376
in vec4 v2f_color;
4377
in float v2f_diffuse;
4378
in vec2 v2f_light;
4379
void main() {
4380
BlockFrag o;
4381
o.texCoords = v2f_texCoords;
4382
o.color = v2f_color;
4383
o.diffuse = v2f_diffuse;
4384
o.light = v2f_light;
4385
fragment(o);
4386
}
4387
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
4388
4389
[17:17:49] [Render thread/ERROR]: #version 150
4390
#extension GL_ARB_conservative_depth : enable
4391
#define VERTEX_SHADER
4392
#define DEBUG_NORMAL
4393
#if defined(VERTEX_SHADER)
4394
out float FragDistance;
4395
#elif defined(FRAGMENT_SHADER)
4396
in float FragDistance;
4397
#endif
4398
uniform vec4 uFogColor;
4399
uniform vec2 uFogRange;
4400
4401
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
4402
float distXZ = length(worldPos.xz - cameraPos.xz);
4403
float distY = abs(worldPos.y - cameraPos.y);
4404
return max(distXZ, distY);
4405
}
4406
4407
float cylindrical_distance(vec3 worldPos) {
4408
float distXZ = length(worldPos.xz);
4409
float distY = abs(worldPos.y);
4410
return max(distXZ, distY);
4411
}
4412
4413
float FLWFogFactor() {
4414
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
4415
}
4416
4417
4418
uniform float uTime;
4419
uniform mat4 uViewProjection;
4420
uniform vec3 uCameraPos;
4421
4422
uniform vec2 uTextureScale;
4423
uniform sampler2D uBlockAtlas;
4424
uniform sampler2D uLightMap;
4425
uniform sampler2D uCrumbling;
4426
4427
uniform vec2 uWindowSize;
4428
4429
void FLWFinalizeNormal(inout vec3 normal) {
4430
// noop
4431
}
4432
4433
#if defined(VERTEX_SHADER)
4434
void FLWFinalizeWorldPos(inout vec4 worldPos) {
4435
#if defined(USE_FOG)
4436
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
4437
#endif
4438
4439
gl_Position = uViewProjection * worldPos;
4440
}
4441
4442
#elif defined(FRAGMENT_SHADER)
4443
4444
out vec4 fragColor;
4445
4446
vec4 FLWBlockTexture(vec2 texCoords) {
4447
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
4448
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
4449
cr.a = cr.a * diffuseAlpha;
4450
return cr;
4451
}
4452
4453
void FLWFinalizeColor(vec4 color) {
4454
#if defined(USE_FOG)
4455
float a = color.a;
4456
float fog = clamp(FLWFogFactor(), 0., 1.);
4457
4458
color = mix(uFogColor, color, fog);
4459
color.a = a;
4460
#endif
4461
4462
if (color.a < 0.1) {
4463
discard;
4464
}
4465
4466
fragColor = color;
4467
}
4468
4469
vec4 FLWLight(vec2 lightCoords) {
4470
return vec4(1.);
4471
}
4472
#endif
4473
4474
4475
mat4 rotate(vec3 axis, float angle) {
4476
float s = sin(angle);
4477
float c = cos(angle);
4478
float oc = 1. - c;
4479
4480
vec3 sa = axis * s;
4481
4482
mat4 mr = mat4(1.);
4483
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
4484
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
4485
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
4486
4487
return mr;
4488
}
4489
4490
mat4 rotation(vec3 rot) {
4491
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
4492
}
4493
4494
mat3 modelToNormal(mat4 mat) {
4495
// Discard the edges. This won't be accurate for scaled or skewed matrices,
4496
// but we don't have to work with those often.
4497
mat3 m;
4498
m[0] = mat[0].xyz;
4499
m[1] = mat[1].xyz;
4500
m[2] = mat[2].xyz;
4501
return m;
4502
}
4503
4504
#define PIOVER2 1.5707963268
4505
4506
vec4 quat(vec3 axis, float angle) {
4507
float halfAngle = angle * PIOVER2 / 180.0;
4508
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
4509
return vec4(axis.xyz * cs.y, cs.x);
4510
}
4511
4512
vec4 quatMult(vec4 q1, vec4 q2) {
4513
// disgustingly vectorized quaternion multiplication
4514
vec4 a = q1.w * q2.xyzw;
4515
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
4516
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
4517
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
4518
4519
return a + b + c + d;
4520
}
4521
4522
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
4523
vec3 i = q.xyz;
4524
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
4525
}
4526
4527
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
4528
return rotateVertexByQuat(v, quat(axis, angle));
4529
}
4530
4531
float diffuse(vec3 normal) {
4532
vec3 n2 = normal * normal * vec3(.6, .25, .8);
4533
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
4534
}
4535
struct Vertex {
4536
vec3 pos;
4537
vec2 texCoords;
4538
vec3 normal;
4539
};
4540
4541
struct BlockFrag {
4542
vec2 texCoords;
4543
vec4 color;
4544
float diffuse;
4545
vec2 light;
4546
};
4547
4548
#if defined(FRAGMENT_SHADER)
4549
void fragment(BlockFrag r) {
4550
vec4 tex = FLWBlockTexture(r.texCoords);
4551
4552
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
4553
4554
FLWFinalizeColor(color);
4555
}
4556
#endif
4557
#define PI 3.1415926538
4558
4559
4560
4561
4562
4563
struct Flap {
4564
vec3 instancePos;
4565
vec2 light;
4566
vec3 segmentOffset;
4567
vec3 pivot;
4568
float horizontalAngle;
4569
float intensity;
4570
float flapScale;
4571
float flapness;
4572
};
4573
4574
4575
4576
4577
#if defined(VERTEX_SHADER)
4578
4579
float toRad(float degrees) {
4580
return fract(degrees / 360.) * PI * 2.;
4581
}
4582
4583
float getFlapAngle(float flapness, float intensity, float scale) {
4584
float absFlap = abs(flapness);
4585
4586
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
4587
4588
float halfAngle = angle * 0.5;
4589
4590
float which = step(0., flapness); // 0 if negative, 1 if positive
4591
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
4592
4593
return degrees;
4594
}
4595
4596
BlockFrag vertex(Vertex v, Flap flap) {
4597
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
4598
4599
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
4600
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
4601
4602
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
4603
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
4604
4605
vec4 worldPos = vec4(rotated, 1.);
4606
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
4607
4608
FLWFinalizeWorldPos(worldPos);
4609
FLWFinalizeNormal(norm);
4610
4611
BlockFrag b;
4612
b.diffuse = diffuse(norm);
4613
b.texCoords = v.texCoords;
4614
b.light = flap.light;
4615
#if defined(DEBUG_NORMAL)
4616
b.color = vec4(norm, 1.);
4617
#else
4618
b.color = vec4(1.);
4619
#endif
4620
return b;
4621
}
4622
#endif
4623
4624
in vec3 a_v_pos;
4625
in vec2 a_v_texCoords;
4626
in vec3 a_v_normal;
4627
in vec3 a_i_instancePos;
4628
in vec2 a_i_light;
4629
in vec3 a_i_segmentOffset;
4630
in vec3 a_i_pivot;
4631
in float a_i_horizontalAngle;
4632
in float a_i_intensity;
4633
in float a_i_flapScale;
4634
in float a_i_flapness;
4635
out vec2 v2f_texCoords;
4636
out vec4 v2f_color;
4637
out float v2f_diffuse;
4638
out vec2 v2f_light;
4639
void main() {
4640
Vertex v;
4641
v.pos = a_v_pos;
4642
v.texCoords = a_v_texCoords;
4643
v.normal = a_v_normal;
4644
Flap i;
4645
i.instancePos = a_i_instancePos;
4646
i.light = a_i_light;
4647
i.segmentOffset = a_i_segmentOffset;
4648
i.pivot = a_i_pivot;
4649
i.horizontalAngle = a_i_horizontalAngle;
4650
i.intensity = a_i_intensity;
4651
i.flapScale = a_i_flapScale;
4652
i.flapness = a_i_flapness;
4653
BlockFrag o = vertex(v, i);
4654
v2f_texCoords = o.texCoords;
4655
v2f_color = o.color;
4656
v2f_diffuse = o.diffuse;
4657
v2f_light = o.light;
4658
}
4659
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
4660
4661
[17:17:49] [Render thread/ERROR]: #version 150
4662
#extension GL_ARB_conservative_depth : enable
4663
#define FRAGMENT_SHADER
4664
#define DEBUG_NORMAL
4665
#if defined(VERTEX_SHADER)
4666
out float FragDistance;
4667
#elif defined(FRAGMENT_SHADER)
4668
in float FragDistance;
4669
#endif
4670
uniform vec4 uFogColor;
4671
uniform vec2 uFogRange;
4672
4673
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
4674
float distXZ = length(worldPos.xz - cameraPos.xz);
4675
float distY = abs(worldPos.y - cameraPos.y);
4676
return max(distXZ, distY);
4677
}
4678
4679
float cylindrical_distance(vec3 worldPos) {
4680
float distXZ = length(worldPos.xz);
4681
float distY = abs(worldPos.y);
4682
return max(distXZ, distY);
4683
}
4684
4685
float FLWFogFactor() {
4686
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
4687
}
4688
4689
4690
uniform float uTime;
4691
uniform mat4 uViewProjection;
4692
uniform vec3 uCameraPos;
4693
4694
uniform vec2 uTextureScale;
4695
uniform sampler2D uBlockAtlas;
4696
uniform sampler2D uLightMap;
4697
uniform sampler2D uCrumbling;
4698
4699
uniform vec2 uWindowSize;
4700
4701
void FLWFinalizeNormal(inout vec3 normal) {
4702
// noop
4703
}
4704
4705
#if defined(VERTEX_SHADER)
4706
void FLWFinalizeWorldPos(inout vec4 worldPos) {
4707
#if defined(USE_FOG)
4708
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
4709
#endif
4710
4711
gl_Position = uViewProjection * worldPos;
4712
}
4713
4714
#elif defined(FRAGMENT_SHADER)
4715
4716
out vec4 fragColor;
4717
4718
vec4 FLWBlockTexture(vec2 texCoords) {
4719
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
4720
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
4721
cr.a = cr.a * diffuseAlpha;
4722
return cr;
4723
}
4724
4725
void FLWFinalizeColor(vec4 color) {
4726
#if defined(USE_FOG)
4727
float a = color.a;
4728
float fog = clamp(FLWFogFactor(), 0., 1.);
4729
4730
color = mix(uFogColor, color, fog);
4731
color.a = a;
4732
#endif
4733
4734
if (color.a < 0.1) {
4735
discard;
4736
}
4737
4738
fragColor = color;
4739
}
4740
4741
vec4 FLWLight(vec2 lightCoords) {
4742
return vec4(1.);
4743
}
4744
#endif
4745
4746
4747
mat4 rotate(vec3 axis, float angle) {
4748
float s = sin(angle);
4749
float c = cos(angle);
4750
float oc = 1. - c;
4751
4752
vec3 sa = axis * s;
4753
4754
mat4 mr = mat4(1.);
4755
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
4756
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
4757
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
4758
4759
return mr;
4760
}
4761
4762
mat4 rotation(vec3 rot) {
4763
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
4764
}
4765
4766
mat3 modelToNormal(mat4 mat) {
4767
// Discard the edges. This won't be accurate for scaled or skewed matrices,
4768
// but we don't have to work with those often.
4769
mat3 m;
4770
m[0] = mat[0].xyz;
4771
m[1] = mat[1].xyz;
4772
m[2] = mat[2].xyz;
4773
return m;
4774
}
4775
4776
#define PIOVER2 1.5707963268
4777
4778
vec4 quat(vec3 axis, float angle) {
4779
float halfAngle = angle * PIOVER2 / 180.0;
4780
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
4781
return vec4(axis.xyz * cs.y, cs.x);
4782
}
4783
4784
vec4 quatMult(vec4 q1, vec4 q2) {
4785
// disgustingly vectorized quaternion multiplication
4786
vec4 a = q1.w * q2.xyzw;
4787
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
4788
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
4789
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
4790
4791
return a + b + c + d;
4792
}
4793
4794
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
4795
vec3 i = q.xyz;
4796
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
4797
}
4798
4799
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
4800
return rotateVertexByQuat(v, quat(axis, angle));
4801
}
4802
4803
float diffuse(vec3 normal) {
4804
vec3 n2 = normal * normal * vec3(.6, .25, .8);
4805
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
4806
}
4807
struct Vertex {
4808
vec3 pos;
4809
vec2 texCoords;
4810
vec3 normal;
4811
};
4812
4813
struct BlockFrag {
4814
vec2 texCoords;
4815
vec4 color;
4816
float diffuse;
4817
vec2 light;
4818
};
4819
4820
#if defined(FRAGMENT_SHADER)
4821
void fragment(BlockFrag r) {
4822
vec4 tex = FLWBlockTexture(r.texCoords);
4823
4824
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
4825
4826
FLWFinalizeColor(color);
4827
}
4828
#endif
4829
#define PI 3.1415926538
4830
4831
4832
4833
4834
4835
struct Flap {
4836
vec3 instancePos;
4837
vec2 light;
4838
vec3 segmentOffset;
4839
vec3 pivot;
4840
float horizontalAngle;
4841
float intensity;
4842
float flapScale;
4843
float flapness;
4844
};
4845
4846
4847
4848
4849
#if defined(VERTEX_SHADER)
4850
4851
float toRad(float degrees) {
4852
return fract(degrees / 360.) * PI * 2.;
4853
}
4854
4855
float getFlapAngle(float flapness, float intensity, float scale) {
4856
float absFlap = abs(flapness);
4857
4858
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
4859
4860
float halfAngle = angle * 0.5;
4861
4862
float which = step(0., flapness); // 0 if negative, 1 if positive
4863
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
4864
4865
return degrees;
4866
}
4867
4868
BlockFrag vertex(Vertex v, Flap flap) {
4869
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
4870
4871
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
4872
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
4873
4874
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
4875
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
4876
4877
vec4 worldPos = vec4(rotated, 1.);
4878
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
4879
4880
FLWFinalizeWorldPos(worldPos);
4881
FLWFinalizeNormal(norm);
4882
4883
BlockFrag b;
4884
b.diffuse = diffuse(norm);
4885
b.texCoords = v.texCoords;
4886
b.light = flap.light;
4887
#if defined(DEBUG_NORMAL)
4888
b.color = vec4(norm, 1.);
4889
#else
4890
b.color = vec4(1.);
4891
#endif
4892
return b;
4893
}
4894
#endif
4895
4896
in vec2 v2f_texCoords;
4897
in vec4 v2f_color;
4898
in float v2f_diffuse;
4899
in vec2 v2f_light;
4900
void main() {
4901
BlockFrag o;
4902
o.texCoords = v2f_texCoords;
4903
o.color = v2f_color;
4904
o.diffuse = v2f_diffuse;
4905
o.light = v2f_light;
4906
fragment(o);
4907
}
4908
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
4909
4910
[17:17:49] [Render thread/ERROR]: #version 150
4911
#extension GL_ARB_conservative_depth : enable
4912
#define VERTEX_SHADER
4913
#if defined(VERTEX_SHADER)
4914
out float FragDistance;
4915
#elif defined(FRAGMENT_SHADER)
4916
in float FragDistance;
4917
#endif
4918
uniform vec4 uFogColor;
4919
uniform vec2 uFogRange;
4920
4921
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
4922
float distXZ = length(worldPos.xz - cameraPos.xz);
4923
float distY = abs(worldPos.y - cameraPos.y);
4924
return max(distXZ, distY);
4925
}
4926
4927
float cylindrical_distance(vec3 worldPos) {
4928
float distXZ = length(worldPos.xz);
4929
float distY = abs(worldPos.y);
4930
return max(distXZ, distY);
4931
}
4932
4933
float FLWFogFactor() {
4934
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
4935
}
4936
4937
4938
uniform float uTime;
4939
uniform mat4 uViewProjection;
4940
uniform vec3 uCameraPos;
4941
4942
uniform vec2 uTextureScale;
4943
uniform sampler2D uBlockAtlas;
4944
uniform sampler2D uLightMap;
4945
uniform sampler2D uCrumbling;
4946
4947
uniform vec2 uWindowSize;
4948
4949
void FLWFinalizeNormal(inout vec3 normal) {
4950
// noop
4951
}
4952
4953
#if defined(VERTEX_SHADER)
4954
void FLWFinalizeWorldPos(inout vec4 worldPos) {
4955
#if defined(USE_FOG)
4956
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
4957
#endif
4958
4959
gl_Position = uViewProjection * worldPos;
4960
}
4961
4962
#elif defined(FRAGMENT_SHADER)
4963
4964
out vec4 fragColor;
4965
4966
vec4 FLWBlockTexture(vec2 texCoords) {
4967
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
4968
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
4969
cr.a = cr.a * diffuseAlpha;
4970
return cr;
4971
}
4972
4973
void FLWFinalizeColor(vec4 color) {
4974
#if defined(USE_FOG)
4975
float a = color.a;
4976
float fog = clamp(FLWFogFactor(), 0., 1.);
4977
4978
color = mix(uFogColor, color, fog);
4979
color.a = a;
4980
#endif
4981
4982
if (color.a < 0.1) {
4983
discard;
4984
}
4985
4986
fragColor = color;
4987
}
4988
4989
vec4 FLWLight(vec2 lightCoords) {
4990
return vec4(1.);
4991
}
4992
#endif
4993
4994
4995
#define PIOVER2 1.5707963268
4996
4997
vec4 quat(vec3 axis, float angle) {
4998
float halfAngle = angle * PIOVER2 / 180.0;
4999
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
5000
return vec4(axis.xyz * cs.y, cs.x);
5001
}
5002
5003
vec4 quatMult(vec4 q1, vec4 q2) {
5004
// disgustingly vectorized quaternion multiplication
5005
vec4 a = q1.w * q2.xyzw;
5006
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
5007
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
5008
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
5009
5010
return a + b + c + d;
5011
}
5012
5013
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
5014
vec3 i = q.xyz;
5015
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
5016
}
5017
5018
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
5019
return rotateVertexByQuat(v, quat(axis, angle));
5020
}
5021
5022
mat4 rotate(vec3 axis, float angle) {
5023
float s = sin(angle);
5024
float c = cos(angle);
5025
float oc = 1. - c;
5026
5027
vec3 sa = axis * s;
5028
5029
mat4 mr = mat4(1.);
5030
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
5031
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
5032
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
5033
5034
return mr;
5035
}
5036
5037
mat4 rotation(vec3 rot) {
5038
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
5039
}
5040
5041
mat3 modelToNormal(mat4 mat) {
5042
// Discard the edges. This won't be accurate for scaled or skewed matrices,
5043
// but we don't have to work with those often.
5044
mat3 m;
5045
m[0] = mat[0].xyz;
5046
m[1] = mat[1].xyz;
5047
m[2] = mat[2].xyz;
5048
return m;
5049
}
5050
5051
float diffuse(vec3 normal) {
5052
vec3 n2 = normal * normal * vec3(.6, .25, .8);
5053
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
5054
}
5055
struct Vertex {
5056
vec3 pos;
5057
vec2 texCoords;
5058
vec3 normal;
5059
};
5060
5061
struct BlockFrag {
5062
vec2 texCoords;
5063
vec4 color;
5064
float diffuse;
5065
vec2 light;
5066
};
5067
5068
#if defined(FRAGMENT_SHADER)
5069
void fragment(BlockFrag r) {
5070
vec4 tex = FLWBlockTexture(r.texCoords);
5071
5072
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
5073
5074
FLWFinalizeColor(color);
5075
}
5076
#endif
5077
#define PI 3.1415926538
5078
5079
5080
5081
5082
5083
struct Belt {
5084
vec2 light;
5085
vec4 color;
5086
vec3 pos;
5087
float speed;
5088
float offset;
5089
vec4 rotation;
5090
vec2 sourceTexture;
5091
vec4 scrollTexture;
5092
float scrollMult;
5093
};
5094
5095
5096
5097
5098
#if defined(VERTEX_SHADER)
5099
BlockFrag vertex(Vertex v, Belt instance) {
5100
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
5101
5102
vec4 worldPos = vec4(rotated, 1.);
5103
5104
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
5105
5106
FLWFinalizeWorldPos(worldPos);
5107
FLWFinalizeNormal(norm);
5108
5109
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
5110
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
5111
5112
BlockFrag b;
5113
b.diffuse = diffuse(norm);
5114
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
5115
b.light = instance.light;
5116
5117
#if defined(DEBUG_RAINBOW)
5118
b.color = instance.color;
5119
#elif defined(DEBUG_NORMAL)
5120
b.color = vec4(norm, 1.);
5121
#else
5122
b.color = vec4(1.);
5123
#endif
5124
5125
return b;
5126
}
5127
#endif
5128
5129
in vec3 a_v_pos;
5130
in vec2 a_v_texCoords;
5131
in vec3 a_v_normal;
5132
in vec2 a_i_light;
5133
in vec4 a_i_color;
5134
in vec3 a_i_pos;
5135
in float a_i_speed;
5136
in float a_i_offset;
5137
in vec4 a_i_rotation;
5138
in vec2 a_i_sourceTexture;
5139
in vec4 a_i_scrollTexture;
5140
in float a_i_scrollMult;
5141
out vec2 v2f_texCoords;
5142
out vec4 v2f_color;
5143
out float v2f_diffuse;
5144
out vec2 v2f_light;
5145
void main() {
5146
Vertex v;
5147
v.pos = a_v_pos;
5148
v.texCoords = a_v_texCoords;
5149
v.normal = a_v_normal;
5150
Belt i;
5151
i.light = a_i_light;
5152
i.color = a_i_color;
5153
i.pos = a_i_pos;
5154
i.speed = a_i_speed;
5155
i.offset = a_i_offset;
5156
i.rotation = a_i_rotation;
5157
i.sourceTexture = a_i_sourceTexture;
5158
i.scrollTexture = a_i_scrollTexture;
5159
i.scrollMult = a_i_scrollMult;
5160
BlockFrag o = vertex(v, i);
5161
v2f_texCoords = o.texCoords;
5162
v2f_color = o.color;
5163
v2f_diffuse = o.diffuse;
5164
v2f_light = o.light;
5165
}
5166
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
5167
5168
[17:17:49] [Render thread/ERROR]: #version 150
5169
#extension GL_ARB_conservative_depth : enable
5170
#define FRAGMENT_SHADER
5171
#if defined(VERTEX_SHADER)
5172
out float FragDistance;
5173
#elif defined(FRAGMENT_SHADER)
5174
in float FragDistance;
5175
#endif
5176
uniform vec4 uFogColor;
5177
uniform vec2 uFogRange;
5178
5179
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
5180
float distXZ = length(worldPos.xz - cameraPos.xz);
5181
float distY = abs(worldPos.y - cameraPos.y);
5182
return max(distXZ, distY);
5183
}
5184
5185
float cylindrical_distance(vec3 worldPos) {
5186
float distXZ = length(worldPos.xz);
5187
float distY = abs(worldPos.y);
5188
return max(distXZ, distY);
5189
}
5190
5191
float FLWFogFactor() {
5192
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
5193
}
5194
5195
5196
uniform float uTime;
5197
uniform mat4 uViewProjection;
5198
uniform vec3 uCameraPos;
5199
5200
uniform vec2 uTextureScale;
5201
uniform sampler2D uBlockAtlas;
5202
uniform sampler2D uLightMap;
5203
uniform sampler2D uCrumbling;
5204
5205
uniform vec2 uWindowSize;
5206
5207
void FLWFinalizeNormal(inout vec3 normal) {
5208
// noop
5209
}
5210
5211
#if defined(VERTEX_SHADER)
5212
void FLWFinalizeWorldPos(inout vec4 worldPos) {
5213
#if defined(USE_FOG)
5214
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
5215
#endif
5216
5217
gl_Position = uViewProjection * worldPos;
5218
}
5219
5220
#elif defined(FRAGMENT_SHADER)
5221
5222
out vec4 fragColor;
5223
5224
vec4 FLWBlockTexture(vec2 texCoords) {
5225
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
5226
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
5227
cr.a = cr.a * diffuseAlpha;
5228
return cr;
5229
}
5230
5231
void FLWFinalizeColor(vec4 color) {
5232
#if defined(USE_FOG)
5233
float a = color.a;
5234
float fog = clamp(FLWFogFactor(), 0., 1.);
5235
5236
color = mix(uFogColor, color, fog);
5237
color.a = a;
5238
#endif
5239
5240
if (color.a < 0.1) {
5241
discard;
5242
}
5243
5244
fragColor = color;
5245
}
5246
5247
vec4 FLWLight(vec2 lightCoords) {
5248
return vec4(1.);
5249
}
5250
#endif
5251
5252
5253
#define PIOVER2 1.5707963268
5254
5255
vec4 quat(vec3 axis, float angle) {
5256
float halfAngle = angle * PIOVER2 / 180.0;
5257
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
5258
return vec4(axis.xyz * cs.y, cs.x);
5259
}
5260
5261
vec4 quatMult(vec4 q1, vec4 q2) {
5262
// disgustingly vectorized quaternion multiplication
5263
vec4 a = q1.w * q2.xyzw;
5264
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
5265
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
5266
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
5267
5268
return a + b + c + d;
5269
}
5270
5271
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
5272
vec3 i = q.xyz;
5273
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
5274
}
5275
5276
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
5277
return rotateVertexByQuat(v, quat(axis, angle));
5278
}
5279
5280
mat4 rotate(vec3 axis, float angle) {
5281
float s = sin(angle);
5282
float c = cos(angle);
5283
float oc = 1. - c;
5284
5285
vec3 sa = axis * s;
5286
5287
mat4 mr = mat4(1.);
5288
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
5289
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
5290
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
5291
5292
return mr;
5293
}
5294
5295
mat4 rotation(vec3 rot) {
5296
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
5297
}
5298
5299
mat3 modelToNormal(mat4 mat) {
5300
// Discard the edges. This won't be accurate for scaled or skewed matrices,
5301
// but we don't have to work with those often.
5302
mat3 m;
5303
m[0] = mat[0].xyz;
5304
m[1] = mat[1].xyz;
5305
m[2] = mat[2].xyz;
5306
return m;
5307
}
5308
5309
float diffuse(vec3 normal) {
5310
vec3 n2 = normal * normal * vec3(.6, .25, .8);
5311
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
5312
}
5313
struct Vertex {
5314
vec3 pos;
5315
vec2 texCoords;
5316
vec3 normal;
5317
};
5318
5319
struct BlockFrag {
5320
vec2 texCoords;
5321
vec4 color;
5322
float diffuse;
5323
vec2 light;
5324
};
5325
5326
#if defined(FRAGMENT_SHADER)
5327
void fragment(BlockFrag r) {
5328
vec4 tex = FLWBlockTexture(r.texCoords);
5329
5330
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
5331
5332
FLWFinalizeColor(color);
5333
}
5334
#endif
5335
#define PI 3.1415926538
5336
5337
5338
5339
5340
5341
struct Belt {
5342
vec2 light;
5343
vec4 color;
5344
vec3 pos;
5345
float speed;
5346
float offset;
5347
vec4 rotation;
5348
vec2 sourceTexture;
5349
vec4 scrollTexture;
5350
float scrollMult;
5351
};
5352
5353
5354
5355
5356
#if defined(VERTEX_SHADER)
5357
BlockFrag vertex(Vertex v, Belt instance) {
5358
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
5359
5360
vec4 worldPos = vec4(rotated, 1.);
5361
5362
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
5363
5364
FLWFinalizeWorldPos(worldPos);
5365
FLWFinalizeNormal(norm);
5366
5367
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
5368
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
5369
5370
BlockFrag b;
5371
b.diffuse = diffuse(norm);
5372
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
5373
b.light = instance.light;
5374
5375
#if defined(DEBUG_RAINBOW)
5376
b.color = instance.color;
5377
#elif defined(DEBUG_NORMAL)
5378
b.color = vec4(norm, 1.);
5379
#else
5380
b.color = vec4(1.);
5381
#endif
5382
5383
return b;
5384
}
5385
#endif
5386
5387
in vec2 v2f_texCoords;
5388
in vec4 v2f_color;
5389
in float v2f_diffuse;
5390
in vec2 v2f_light;
5391
void main() {
5392
BlockFrag o;
5393
o.texCoords = v2f_texCoords;
5394
o.color = v2f_color;
5395
o.diffuse = v2f_diffuse;
5396
o.light = v2f_light;
5397
fragment(o);
5398
}
5399
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
5400
5401
[17:17:49] [Render thread/ERROR]: #version 150
5402
#extension GL_ARB_conservative_depth : enable
5403
#define VERTEX_SHADER
5404
#define DEBUG_RAINBOW
5405
#if defined(VERTEX_SHADER)
5406
out float FragDistance;
5407
#elif defined(FRAGMENT_SHADER)
5408
in float FragDistance;
5409
#endif
5410
uniform vec4 uFogColor;
5411
uniform vec2 uFogRange;
5412
5413
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
5414
float distXZ = length(worldPos.xz - cameraPos.xz);
5415
float distY = abs(worldPos.y - cameraPos.y);
5416
return max(distXZ, distY);
5417
}
5418
5419
float cylindrical_distance(vec3 worldPos) {
5420
float distXZ = length(worldPos.xz);
5421
float distY = abs(worldPos.y);
5422
return max(distXZ, distY);
5423
}
5424
5425
float FLWFogFactor() {
5426
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
5427
}
5428
5429
5430
uniform float uTime;
5431
uniform mat4 uViewProjection;
5432
uniform vec3 uCameraPos;
5433
5434
uniform vec2 uTextureScale;
5435
uniform sampler2D uBlockAtlas;
5436
uniform sampler2D uLightMap;
5437
uniform sampler2D uCrumbling;
5438
5439
uniform vec2 uWindowSize;
5440
5441
void FLWFinalizeNormal(inout vec3 normal) {
5442
// noop
5443
}
5444
5445
#if defined(VERTEX_SHADER)
5446
void FLWFinalizeWorldPos(inout vec4 worldPos) {
5447
#if defined(USE_FOG)
5448
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
5449
#endif
5450
5451
gl_Position = uViewProjection * worldPos;
5452
}
5453
5454
#elif defined(FRAGMENT_SHADER)
5455
5456
out vec4 fragColor;
5457
5458
vec4 FLWBlockTexture(vec2 texCoords) {
5459
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
5460
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
5461
cr.a = cr.a * diffuseAlpha;
5462
return cr;
5463
}
5464
5465
void FLWFinalizeColor(vec4 color) {
5466
#if defined(USE_FOG)
5467
float a = color.a;
5468
float fog = clamp(FLWFogFactor(), 0., 1.);
5469
5470
color = mix(uFogColor, color, fog);
5471
color.a = a;
5472
#endif
5473
5474
if (color.a < 0.1) {
5475
discard;
5476
}
5477
5478
fragColor = color;
5479
}
5480
5481
vec4 FLWLight(vec2 lightCoords) {
5482
return vec4(1.);
5483
}
5484
#endif
5485
5486
5487
#define PIOVER2 1.5707963268
5488
5489
vec4 quat(vec3 axis, float angle) {
5490
float halfAngle = angle * PIOVER2 / 180.0;
5491
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
5492
return vec4(axis.xyz * cs.y, cs.x);
5493
}
5494
5495
vec4 quatMult(vec4 q1, vec4 q2) {
5496
// disgustingly vectorized quaternion multiplication
5497
vec4 a = q1.w * q2.xyzw;
5498
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
5499
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
5500
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
5501
5502
return a + b + c + d;
5503
}
5504
5505
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
5506
vec3 i = q.xyz;
5507
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
5508
}
5509
5510
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
5511
return rotateVertexByQuat(v, quat(axis, angle));
5512
}
5513
5514
mat4 rotate(vec3 axis, float angle) {
5515
float s = sin(angle);
5516
float c = cos(angle);
5517
float oc = 1. - c;
5518
5519
vec3 sa = axis * s;
5520
5521
mat4 mr = mat4(1.);
5522
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
5523
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
5524
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
5525
5526
return mr;
5527
}
5528
5529
mat4 rotation(vec3 rot) {
5530
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
5531
}
5532
5533
mat3 modelToNormal(mat4 mat) {
5534
// Discard the edges. This won't be accurate for scaled or skewed matrices,
5535
// but we don't have to work with those often.
5536
mat3 m;
5537
m[0] = mat[0].xyz;
5538
m[1] = mat[1].xyz;
5539
m[2] = mat[2].xyz;
5540
return m;
5541
}
5542
5543
float diffuse(vec3 normal) {
5544
vec3 n2 = normal * normal * vec3(.6, .25, .8);
5545
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
5546
}
5547
struct Vertex {
5548
vec3 pos;
5549
vec2 texCoords;
5550
vec3 normal;
5551
};
5552
5553
struct BlockFrag {
5554
vec2 texCoords;
5555
vec4 color;
5556
float diffuse;
5557
vec2 light;
5558
};
5559
5560
#if defined(FRAGMENT_SHADER)
5561
void fragment(BlockFrag r) {
5562
vec4 tex = FLWBlockTexture(r.texCoords);
5563
5564
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
5565
5566
FLWFinalizeColor(color);
5567
}
5568
#endif
5569
#define PI 3.1415926538
5570
5571
5572
5573
5574
5575
struct Belt {
5576
vec2 light;
5577
vec4 color;
5578
vec3 pos;
5579
float speed;
5580
float offset;
5581
vec4 rotation;
5582
vec2 sourceTexture;
5583
vec4 scrollTexture;
5584
float scrollMult;
5585
};
5586
5587
5588
5589
5590
#if defined(VERTEX_SHADER)
5591
BlockFrag vertex(Vertex v, Belt instance) {
5592
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
5593
5594
vec4 worldPos = vec4(rotated, 1.);
5595
5596
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
5597
5598
FLWFinalizeWorldPos(worldPos);
5599
FLWFinalizeNormal(norm);
5600
5601
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
5602
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
5603
5604
BlockFrag b;
5605
b.diffuse = diffuse(norm);
5606
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
5607
b.light = instance.light;
5608
5609
#if defined(DEBUG_RAINBOW)
5610
b.color = instance.color;
5611
#elif defined(DEBUG_NORMAL)
5612
b.color = vec4(norm, 1.);
5613
#else
5614
b.color = vec4(1.);
5615
#endif
5616
5617
return b;
5618
}
5619
#endif
5620
5621
in vec3 a_v_pos;
5622
in vec2 a_v_texCoords;
5623
in vec3 a_v_normal;
5624
in vec2 a_i_light;
5625
in vec4 a_i_color;
5626
in vec3 a_i_pos;
5627
in float a_i_speed;
5628
in float a_i_offset;
5629
in vec4 a_i_rotation;
5630
in vec2 a_i_sourceTexture;
5631
in vec4 a_i_scrollTexture;
5632
in float a_i_scrollMult;
5633
out vec2 v2f_texCoords;
5634
out vec4 v2f_color;
5635
out float v2f_diffuse;
5636
out vec2 v2f_light;
5637
void main() {
5638
Vertex v;
5639
v.pos = a_v_pos;
5640
v.texCoords = a_v_texCoords;
5641
v.normal = a_v_normal;
5642
Belt i;
5643
i.light = a_i_light;
5644
i.color = a_i_color;
5645
i.pos = a_i_pos;
5646
i.speed = a_i_speed;
5647
i.offset = a_i_offset;
5648
i.rotation = a_i_rotation;
5649
i.sourceTexture = a_i_sourceTexture;
5650
i.scrollTexture = a_i_scrollTexture;
5651
i.scrollMult = a_i_scrollMult;
5652
BlockFrag o = vertex(v, i);
5653
v2f_texCoords = o.texCoords;
5654
v2f_color = o.color;
5655
v2f_diffuse = o.diffuse;
5656
v2f_light = o.light;
5657
}
5658
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
5659
5660
[17:17:49] [Render thread/ERROR]: #version 150
5661
#extension GL_ARB_conservative_depth : enable
5662
#define FRAGMENT_SHADER
5663
#define DEBUG_RAINBOW
5664
#if defined(VERTEX_SHADER)
5665
out float FragDistance;
5666
#elif defined(FRAGMENT_SHADER)
5667
in float FragDistance;
5668
#endif
5669
uniform vec4 uFogColor;
5670
uniform vec2 uFogRange;
5671
5672
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
5673
float distXZ = length(worldPos.xz - cameraPos.xz);
5674
float distY = abs(worldPos.y - cameraPos.y);
5675
return max(distXZ, distY);
5676
}
5677
5678
float cylindrical_distance(vec3 worldPos) {
5679
float distXZ = length(worldPos.xz);
5680
float distY = abs(worldPos.y);
5681
return max(distXZ, distY);
5682
}
5683
5684
float FLWFogFactor() {
5685
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
5686
}
5687
5688
5689
uniform float uTime;
5690
uniform mat4 uViewProjection;
5691
uniform vec3 uCameraPos;
5692
5693
uniform vec2 uTextureScale;
5694
uniform sampler2D uBlockAtlas;
5695
uniform sampler2D uLightMap;
5696
uniform sampler2D uCrumbling;
5697
5698
uniform vec2 uWindowSize;
5699
5700
void FLWFinalizeNormal(inout vec3 normal) {
5701
// noop
5702
}
5703
5704
#if defined(VERTEX_SHADER)
5705
void FLWFinalizeWorldPos(inout vec4 worldPos) {
5706
#if defined(USE_FOG)
5707
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
5708
#endif
5709
5710
gl_Position = uViewProjection * worldPos;
5711
}
5712
5713
#elif defined(FRAGMENT_SHADER)
5714
5715
out vec4 fragColor;
5716
5717
vec4 FLWBlockTexture(vec2 texCoords) {
5718
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
5719
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
5720
cr.a = cr.a * diffuseAlpha;
5721
return cr;
5722
}
5723
5724
void FLWFinalizeColor(vec4 color) {
5725
#if defined(USE_FOG)
5726
float a = color.a;
5727
float fog = clamp(FLWFogFactor(), 0., 1.);
5728
5729
color = mix(uFogColor, color, fog);
5730
color.a = a;
5731
#endif
5732
5733
if (color.a < 0.1) {
5734
discard;
5735
}
5736
5737
fragColor = color;
5738
}
5739
5740
vec4 FLWLight(vec2 lightCoords) {
5741
return vec4(1.);
5742
}
5743
#endif
5744
5745
5746
#define PIOVER2 1.5707963268
5747
5748
vec4 quat(vec3 axis, float angle) {
5749
float halfAngle = angle * PIOVER2 / 180.0;
5750
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
5751
return vec4(axis.xyz * cs.y, cs.x);
5752
}
5753
5754
vec4 quatMult(vec4 q1, vec4 q2) {
5755
// disgustingly vectorized quaternion multiplication
5756
vec4 a = q1.w * q2.xyzw;
5757
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
5758
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
5759
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
5760
5761
return a + b + c + d;
5762
}
5763
5764
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
5765
vec3 i = q.xyz;
5766
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
5767
}
5768
5769
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
5770
return rotateVertexByQuat(v, quat(axis, angle));
5771
}
5772
5773
mat4 rotate(vec3 axis, float angle) {
5774
float s = sin(angle);
5775
float c = cos(angle);
5776
float oc = 1. - c;
5777
5778
vec3 sa = axis * s;
5779
5780
mat4 mr = mat4(1.);
5781
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
5782
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
5783
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
5784
5785
return mr;
5786
}
5787
5788
mat4 rotation(vec3 rot) {
5789
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
5790
}
5791
5792
mat3 modelToNormal(mat4 mat) {
5793
// Discard the edges. This won't be accurate for scaled or skewed matrices,
5794
// but we don't have to work with those often.
5795
mat3 m;
5796
m[0] = mat[0].xyz;
5797
m[1] = mat[1].xyz;
5798
m[2] = mat[2].xyz;
5799
return m;
5800
}
5801
5802
float diffuse(vec3 normal) {
5803
vec3 n2 = normal * normal * vec3(.6, .25, .8);
5804
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
5805
}
5806
struct Vertex {
5807
vec3 pos;
5808
vec2 texCoords;
5809
vec3 normal;
5810
};
5811
5812
struct BlockFrag {
5813
vec2 texCoords;
5814
vec4 color;
5815
float diffuse;
5816
vec2 light;
5817
};
5818
5819
#if defined(FRAGMENT_SHADER)
5820
void fragment(BlockFrag r) {
5821
vec4 tex = FLWBlockTexture(r.texCoords);
5822
5823
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
5824
5825
FLWFinalizeColor(color);
5826
}
5827
#endif
5828
#define PI 3.1415926538
5829
5830
5831
5832
5833
5834
struct Belt {
5835
vec2 light;
5836
vec4 color;
5837
vec3 pos;
5838
float speed;
5839
float offset;
5840
vec4 rotation;
5841
vec2 sourceTexture;
5842
vec4 scrollTexture;
5843
float scrollMult;
5844
};
5845
5846
5847
5848
5849
#if defined(VERTEX_SHADER)
5850
BlockFrag vertex(Vertex v, Belt instance) {
5851
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
5852
5853
vec4 worldPos = vec4(rotated, 1.);
5854
5855
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
5856
5857
FLWFinalizeWorldPos(worldPos);
5858
FLWFinalizeNormal(norm);
5859
5860
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
5861
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
5862
5863
BlockFrag b;
5864
b.diffuse = diffuse(norm);
5865
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
5866
b.light = instance.light;
5867
5868
#if defined(DEBUG_RAINBOW)
5869
b.color = instance.color;
5870
#elif defined(DEBUG_NORMAL)
5871
b.color = vec4(norm, 1.);
5872
#else
5873
b.color = vec4(1.);
5874
#endif
5875
5876
return b;
5877
}
5878
#endif
5879
5880
in vec2 v2f_texCoords;
5881
in vec4 v2f_color;
5882
in float v2f_diffuse;
5883
in vec2 v2f_light;
5884
void main() {
5885
BlockFrag o;
5886
o.texCoords = v2f_texCoords;
5887
o.color = v2f_color;
5888
o.diffuse = v2f_diffuse;
5889
o.light = v2f_light;
5890
fragment(o);
5891
}
5892
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
5893
5894
[17:17:49] [Render thread/ERROR]: #version 150
5895
#extension GL_ARB_conservative_depth : enable
5896
#define VERTEX_SHADER
5897
#define DEBUG_NORMAL
5898
#if defined(VERTEX_SHADER)
5899
out float FragDistance;
5900
#elif defined(FRAGMENT_SHADER)
5901
in float FragDistance;
5902
#endif
5903
uniform vec4 uFogColor;
5904
uniform vec2 uFogRange;
5905
5906
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
5907
float distXZ = length(worldPos.xz - cameraPos.xz);
5908
float distY = abs(worldPos.y - cameraPos.y);
5909
return max(distXZ, distY);
5910
}
5911
5912
float cylindrical_distance(vec3 worldPos) {
5913
float distXZ = length(worldPos.xz);
5914
float distY = abs(worldPos.y);
5915
return max(distXZ, distY);
5916
}
5917
5918
float FLWFogFactor() {
5919
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
5920
}
5921
5922
5923
uniform float uTime;
5924
uniform mat4 uViewProjection;
5925
uniform vec3 uCameraPos;
5926
5927
uniform vec2 uTextureScale;
5928
uniform sampler2D uBlockAtlas;
5929
uniform sampler2D uLightMap;
5930
uniform sampler2D uCrumbling;
5931
5932
uniform vec2 uWindowSize;
5933
5934
void FLWFinalizeNormal(inout vec3 normal) {
5935
// noop
5936
}
5937
5938
#if defined(VERTEX_SHADER)
5939
void FLWFinalizeWorldPos(inout vec4 worldPos) {
5940
#if defined(USE_FOG)
5941
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
5942
#endif
5943
5944
gl_Position = uViewProjection * worldPos;
5945
}
5946
5947
#elif defined(FRAGMENT_SHADER)
5948
5949
out vec4 fragColor;
5950
5951
vec4 FLWBlockTexture(vec2 texCoords) {
5952
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
5953
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
5954
cr.a = cr.a * diffuseAlpha;
5955
return cr;
5956
}
5957
5958
void FLWFinalizeColor(vec4 color) {
5959
#if defined(USE_FOG)
5960
float a = color.a;
5961
float fog = clamp(FLWFogFactor(), 0., 1.);
5962
5963
color = mix(uFogColor, color, fog);
5964
color.a = a;
5965
#endif
5966
5967
if (color.a < 0.1) {
5968
discard;
5969
}
5970
5971
fragColor = color;
5972
}
5973
5974
vec4 FLWLight(vec2 lightCoords) {
5975
return vec4(1.);
5976
}
5977
#endif
5978
5979
5980
#define PIOVER2 1.5707963268
5981
5982
vec4 quat(vec3 axis, float angle) {
5983
float halfAngle = angle * PIOVER2 / 180.0;
5984
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
5985
return vec4(axis.xyz * cs.y, cs.x);
5986
}
5987
5988
vec4 quatMult(vec4 q1, vec4 q2) {
5989
// disgustingly vectorized quaternion multiplication
5990
vec4 a = q1.w * q2.xyzw;
5991
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
5992
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
5993
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
5994
5995
return a + b + c + d;
5996
}
5997
5998
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
5999
vec3 i = q.xyz;
6000
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
6001
}
6002
6003
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
6004
return rotateVertexByQuat(v, quat(axis, angle));
6005
}
6006
6007
mat4 rotate(vec3 axis, float angle) {
6008
float s = sin(angle);
6009
float c = cos(angle);
6010
float oc = 1. - c;
6011
6012
vec3 sa = axis * s;
6013
6014
mat4 mr = mat4(1.);
6015
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
6016
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
6017
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
6018
6019
return mr;
6020
}
6021
6022
mat4 rotation(vec3 rot) {
6023
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
6024
}
6025
6026
mat3 modelToNormal(mat4 mat) {
6027
// Discard the edges. This won't be accurate for scaled or skewed matrices,
6028
// but we don't have to work with those often.
6029
mat3 m;
6030
m[0] = mat[0].xyz;
6031
m[1] = mat[1].xyz;
6032
m[2] = mat[2].xyz;
6033
return m;
6034
}
6035
6036
float diffuse(vec3 normal) {
6037
vec3 n2 = normal * normal * vec3(.6, .25, .8);
6038
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
6039
}
6040
struct Vertex {
6041
vec3 pos;
6042
vec2 texCoords;
6043
vec3 normal;
6044
};
6045
6046
struct BlockFrag {
6047
vec2 texCoords;
6048
vec4 color;
6049
float diffuse;
6050
vec2 light;
6051
};
6052
6053
#if defined(FRAGMENT_SHADER)
6054
void fragment(BlockFrag r) {
6055
vec4 tex = FLWBlockTexture(r.texCoords);
6056
6057
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
6058
6059
FLWFinalizeColor(color);
6060
}
6061
#endif
6062
#define PI 3.1415926538
6063
6064
6065
6066
6067
6068
struct Belt {
6069
vec2 light;
6070
vec4 color;
6071
vec3 pos;
6072
float speed;
6073
float offset;
6074
vec4 rotation;
6075
vec2 sourceTexture;
6076
vec4 scrollTexture;
6077
float scrollMult;
6078
};
6079
6080
6081
6082
6083
#if defined(VERTEX_SHADER)
6084
BlockFrag vertex(Vertex v, Belt instance) {
6085
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
6086
6087
vec4 worldPos = vec4(rotated, 1.);
6088
6089
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
6090
6091
FLWFinalizeWorldPos(worldPos);
6092
FLWFinalizeNormal(norm);
6093
6094
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
6095
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
6096
6097
BlockFrag b;
6098
b.diffuse = diffuse(norm);
6099
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
6100
b.light = instance.light;
6101
6102
#if defined(DEBUG_RAINBOW)
6103
b.color = instance.color;
6104
#elif defined(DEBUG_NORMAL)
6105
b.color = vec4(norm, 1.);
6106
#else
6107
b.color = vec4(1.);
6108
#endif
6109
6110
return b;
6111
}
6112
#endif
6113
6114
in vec3 a_v_pos;
6115
in vec2 a_v_texCoords;
6116
in vec3 a_v_normal;
6117
in vec2 a_i_light;
6118
in vec4 a_i_color;
6119
in vec3 a_i_pos;
6120
in float a_i_speed;
6121
in float a_i_offset;
6122
in vec4 a_i_rotation;
6123
in vec2 a_i_sourceTexture;
6124
in vec4 a_i_scrollTexture;
6125
in float a_i_scrollMult;
6126
out vec2 v2f_texCoords;
6127
out vec4 v2f_color;
6128
out float v2f_diffuse;
6129
out vec2 v2f_light;
6130
void main() {
6131
Vertex v;
6132
v.pos = a_v_pos;
6133
v.texCoords = a_v_texCoords;
6134
v.normal = a_v_normal;
6135
Belt i;
6136
i.light = a_i_light;
6137
i.color = a_i_color;
6138
i.pos = a_i_pos;
6139
i.speed = a_i_speed;
6140
i.offset = a_i_offset;
6141
i.rotation = a_i_rotation;
6142
i.sourceTexture = a_i_sourceTexture;
6143
i.scrollTexture = a_i_scrollTexture;
6144
i.scrollMult = a_i_scrollMult;
6145
BlockFrag o = vertex(v, i);
6146
v2f_texCoords = o.texCoords;
6147
v2f_color = o.color;
6148
v2f_diffuse = o.diffuse;
6149
v2f_light = o.light;
6150
}
6151
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
6152
6153
[17:17:49] [Render thread/ERROR]: #version 150
6154
#extension GL_ARB_conservative_depth : enable
6155
#define FRAGMENT_SHADER
6156
#define DEBUG_NORMAL
6157
#if defined(VERTEX_SHADER)
6158
out float FragDistance;
6159
#elif defined(FRAGMENT_SHADER)
6160
in float FragDistance;
6161
#endif
6162
uniform vec4 uFogColor;
6163
uniform vec2 uFogRange;
6164
6165
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
6166
float distXZ = length(worldPos.xz - cameraPos.xz);
6167
float distY = abs(worldPos.y - cameraPos.y);
6168
return max(distXZ, distY);
6169
}
6170
6171
float cylindrical_distance(vec3 worldPos) {
6172
float distXZ = length(worldPos.xz);
6173
float distY = abs(worldPos.y);
6174
return max(distXZ, distY);
6175
}
6176
6177
float FLWFogFactor() {
6178
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
6179
}
6180
6181
6182
uniform float uTime;
6183
uniform mat4 uViewProjection;
6184
uniform vec3 uCameraPos;
6185
6186
uniform vec2 uTextureScale;
6187
uniform sampler2D uBlockAtlas;
6188
uniform sampler2D uLightMap;
6189
uniform sampler2D uCrumbling;
6190
6191
uniform vec2 uWindowSize;
6192
6193
void FLWFinalizeNormal(inout vec3 normal) {
6194
// noop
6195
}
6196
6197
#if defined(VERTEX_SHADER)
6198
void FLWFinalizeWorldPos(inout vec4 worldPos) {
6199
#if defined(USE_FOG)
6200
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
6201
#endif
6202
6203
gl_Position = uViewProjection * worldPos;
6204
}
6205
6206
#elif defined(FRAGMENT_SHADER)
6207
6208
out vec4 fragColor;
6209
6210
vec4 FLWBlockTexture(vec2 texCoords) {
6211
vec4 cr = texture(uCrumbling, texCoords * uTextureScale);
6212
float diffuseAlpha = texture(uBlockAtlas, texCoords).a;
6213
cr.a = cr.a * diffuseAlpha;
6214
return cr;
6215
}
6216
6217
void FLWFinalizeColor(vec4 color) {
6218
#if defined(USE_FOG)
6219
float a = color.a;
6220
float fog = clamp(FLWFogFactor(), 0., 1.);
6221
6222
color = mix(uFogColor, color, fog);
6223
color.a = a;
6224
#endif
6225
6226
if (color.a < 0.1) {
6227
discard;
6228
}
6229
6230
fragColor = color;
6231
}
6232
6233
vec4 FLWLight(vec2 lightCoords) {
6234
return vec4(1.);
6235
}
6236
#endif
6237
6238
6239
#define PIOVER2 1.5707963268
6240
6241
vec4 quat(vec3 axis, float angle) {
6242
float halfAngle = angle * PIOVER2 / 180.0;
6243
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
6244
return vec4(axis.xyz * cs.y, cs.x);
6245
}
6246
6247
vec4 quatMult(vec4 q1, vec4 q2) {
6248
// disgustingly vectorized quaternion multiplication
6249
vec4 a = q1.w * q2.xyzw;
6250
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
6251
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
6252
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
6253
6254
return a + b + c + d;
6255
}
6256
6257
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
6258
vec3 i = q.xyz;
6259
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
6260
}
6261
6262
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
6263
return rotateVertexByQuat(v, quat(axis, angle));
6264
}
6265
6266
mat4 rotate(vec3 axis, float angle) {
6267
float s = sin(angle);
6268
float c = cos(angle);
6269
float oc = 1. - c;
6270
6271
vec3 sa = axis * s;
6272
6273
mat4 mr = mat4(1.);
6274
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
6275
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
6276
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
6277
6278
return mr;
6279
}
6280
6281
mat4 rotation(vec3 rot) {
6282
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
6283
}
6284
6285
mat3 modelToNormal(mat4 mat) {
6286
// Discard the edges. This won't be accurate for scaled or skewed matrices,
6287
// but we don't have to work with those often.
6288
mat3 m;
6289
m[0] = mat[0].xyz;
6290
m[1] = mat[1].xyz;
6291
m[2] = mat[2].xyz;
6292
return m;
6293
}
6294
6295
float diffuse(vec3 normal) {
6296
vec3 n2 = normal * normal * vec3(.6, .25, .8);
6297
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
6298
}
6299
struct Vertex {
6300
vec3 pos;
6301
vec2 texCoords;
6302
vec3 normal;
6303
};
6304
6305
struct BlockFrag {
6306
vec2 texCoords;
6307
vec4 color;
6308
float diffuse;
6309
vec2 light;
6310
};
6311
6312
#if defined(FRAGMENT_SHADER)
6313
void fragment(BlockFrag r) {
6314
vec4 tex = FLWBlockTexture(r.texCoords);
6315
6316
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
6317
6318
FLWFinalizeColor(color);
6319
}
6320
#endif
6321
#define PI 3.1415926538
6322
6323
6324
6325
6326
6327
struct Belt {
6328
vec2 light;
6329
vec4 color;
6330
vec3 pos;
6331
float speed;
6332
float offset;
6333
vec4 rotation;
6334
vec2 sourceTexture;
6335
vec4 scrollTexture;
6336
float scrollMult;
6337
};
6338
6339
6340
6341
6342
#if defined(VERTEX_SHADER)
6343
BlockFrag vertex(Vertex v, Belt instance) {
6344
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
6345
6346
vec4 worldPos = vec4(rotated, 1.);
6347
6348
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
6349
6350
FLWFinalizeWorldPos(worldPos);
6351
FLWFinalizeNormal(norm);
6352
6353
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
6354
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
6355
6356
BlockFrag b;
6357
b.diffuse = diffuse(norm);
6358
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
6359
b.light = instance.light;
6360
6361
#if defined(DEBUG_RAINBOW)
6362
b.color = instance.color;
6363
#elif defined(DEBUG_NORMAL)
6364
b.color = vec4(norm, 1.);
6365
#else
6366
b.color = vec4(1.);
6367
#endif
6368
6369
return b;
6370
}
6371
#endif
6372
6373
in vec2 v2f_texCoords;
6374
in vec4 v2f_color;
6375
in float v2f_diffuse;
6376
in vec2 v2f_light;
6377
void main() {
6378
BlockFrag o;
6379
o.texCoords = v2f_texCoords;
6380
o.color = v2f_color;
6381
o.diffuse = v2f_diffuse;
6382
o.light = v2f_light;
6383
fragment(o);
6384
}
6385
[17:17:49] [Render thread/INFO]: Loading context 'flywheel:context/world'
6386
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
6387
6388
[17:17:49] [Render thread/ERROR]: #version 150
6389
#extension GL_ARB_conservative_depth : enable
6390
#define VERTEX_SHADER
6391
#if defined(VERTEX_SHADER)
6392
out float FragDistance;
6393
#elif defined(FRAGMENT_SHADER)
6394
in float FragDistance;
6395
#endif
6396
uniform vec4 uFogColor;
6397
uniform vec2 uFogRange;
6398
6399
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
6400
float distXZ = length(worldPos.xz - cameraPos.xz);
6401
float distY = abs(worldPos.y - cameraPos.y);
6402
return max(distXZ, distY);
6403
}
6404
6405
float cylindrical_distance(vec3 worldPos) {
6406
float distXZ = length(worldPos.xz);
6407
float distY = abs(worldPos.y);
6408
return max(distXZ, distY);
6409
}
6410
6411
float FLWFogFactor() {
6412
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
6413
}
6414
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
6415
vec2 shiftLight(vec2 lm) {
6416
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
6417
}
6418
6419
6420
uniform float uTime;
6421
uniform mat4 uViewProjection;
6422
uniform vec3 uCameraPos;
6423
6424
uniform vec2 uTextureScale;
6425
uniform sampler2D uBlockAtlas;
6426
uniform sampler2D uLightMap;
6427
6428
uniform vec2 uWindowSize;
6429
6430
void FLWFinalizeNormal(inout vec3 normal) {
6431
// noop
6432
}
6433
6434
#if defined(VERTEX_SHADER)
6435
void FLWFinalizeWorldPos(inout vec4 worldPos) {
6436
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
6437
6438
gl_Position = uViewProjection * worldPos;
6439
}
6440
6441
#elif defined(FRAGMENT_SHADER)
6442
6443
6444
#define ALPHA_DISCARD 0.1
6445
// optimize discard usage
6446
#if defined(ALPHA_DISCARD)
6447
#if defined(GL_ARB_conservative_depth)
6448
layout (depth_greater) out float gl_FragDepth;
6449
#endif
6450
#endif
6451
out vec4 fragColor;
6452
6453
vec4 FLWBlockTexture(vec2 texCoords) {
6454
return texture(uBlockAtlas, texCoords);
6455
}
6456
6457
void FLWFinalizeColor(vec4 color) {
6458
float a = color.a;
6459
float fog = clamp(FLWFogFactor(), 0., 1.);
6460
6461
color = mix(uFogColor, color, fog);
6462
color.a = a;
6463
6464
#if defined(ALPHA_DISCARD)
6465
if (color.a < ALPHA_DISCARD) {
6466
discard;
6467
}
6468
#endif
6469
6470
fragColor = color;
6471
}
6472
6473
vec4 FLWLight(vec2 lightCoords) {
6474
return texture(uLightMap, shiftLight(lightCoords));
6475
}
6476
#endif
6477
6478
6479
float diffuse(vec3 normal) {
6480
vec3 n2 = normal * normal * vec3(.6, .25, .8);
6481
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
6482
}
6483
struct Vertex {
6484
vec3 pos;
6485
vec2 texCoords;
6486
vec3 normal;
6487
};
6488
6489
struct BlockFrag {
6490
vec2 texCoords;
6491
vec4 color;
6492
float diffuse;
6493
vec2 light;
6494
};
6495
6496
#if defined(FRAGMENT_SHADER)
6497
void fragment(BlockFrag r) {
6498
vec4 tex = FLWBlockTexture(r.texCoords);
6499
6500
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
6501
6502
FLWFinalizeColor(color);
6503
}
6504
#endif
6505
6506
6507
6508
6509
struct Instance {
6510
vec2 light;
6511
vec4 color;
6512
mat4 transform;
6513
mat3 normalMat;
6514
};
6515
6516
#if defined(VERTEX_SHADER)
6517
BlockFrag vertex(Vertex v, Instance i) {
6518
vec4 worldPos = i.transform * vec4(v.pos, 1.);
6519
6520
vec3 norm = i.normalMat * v.normal;
6521
6522
FLWFinalizeWorldPos(worldPos);
6523
FLWFinalizeNormal(norm);
6524
6525
norm = normalize(norm);
6526
6527
BlockFrag b;
6528
b.diffuse = diffuse(norm);
6529
b.texCoords = v.texCoords;
6530
b.light = i.light;
6531
#if defined(DEBUG_NORMAL)
6532
b.color = vec4(norm, 1.);
6533
#else
6534
b.color = i.color;
6535
#endif
6536
return b;
6537
}
6538
#endif
6539
6540
in vec3 a_v_pos;
6541
in vec2 a_v_texCoords;
6542
in vec3 a_v_normal;
6543
in vec2 a_i_light;
6544
in vec4 a_i_color;
6545
in mat4 a_i_transform;
6546
in mat3 a_i_normalMat;
6547
out vec2 v2f_texCoords;
6548
out vec4 v2f_color;
6549
out float v2f_diffuse;
6550
out vec2 v2f_light;
6551
void main() {
6552
Vertex v;
6553
v.pos = a_v_pos;
6554
v.texCoords = a_v_texCoords;
6555
v.normal = a_v_normal;
6556
Instance i;
6557
i.light = a_i_light;
6558
i.color = a_i_color;
6559
i.transform = a_i_transform;
6560
i.normalMat = a_i_normalMat;
6561
BlockFrag o = vertex(v, i);
6562
v2f_texCoords = o.texCoords;
6563
v2f_color = o.color;
6564
v2f_diffuse = o.diffuse;
6565
v2f_light = o.light;
6566
}
6567
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
6568
6569
[17:17:49] [Render thread/ERROR]: #version 150
6570
#extension GL_ARB_conservative_depth : enable
6571
#define FRAGMENT_SHADER
6572
#if defined(VERTEX_SHADER)
6573
out float FragDistance;
6574
#elif defined(FRAGMENT_SHADER)
6575
in float FragDistance;
6576
#endif
6577
uniform vec4 uFogColor;
6578
uniform vec2 uFogRange;
6579
6580
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
6581
float distXZ = length(worldPos.xz - cameraPos.xz);
6582
float distY = abs(worldPos.y - cameraPos.y);
6583
return max(distXZ, distY);
6584
}
6585
6586
float cylindrical_distance(vec3 worldPos) {
6587
float distXZ = length(worldPos.xz);
6588
float distY = abs(worldPos.y);
6589
return max(distXZ, distY);
6590
}
6591
6592
float FLWFogFactor() {
6593
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
6594
}
6595
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
6596
vec2 shiftLight(vec2 lm) {
6597
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
6598
}
6599
6600
6601
uniform float uTime;
6602
uniform mat4 uViewProjection;
6603
uniform vec3 uCameraPos;
6604
6605
uniform vec2 uTextureScale;
6606
uniform sampler2D uBlockAtlas;
6607
uniform sampler2D uLightMap;
6608
6609
uniform vec2 uWindowSize;
6610
6611
void FLWFinalizeNormal(inout vec3 normal) {
6612
// noop
6613
}
6614
6615
#if defined(VERTEX_SHADER)
6616
void FLWFinalizeWorldPos(inout vec4 worldPos) {
6617
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
6618
6619
gl_Position = uViewProjection * worldPos;
6620
}
6621
6622
#elif defined(FRAGMENT_SHADER)
6623
6624
6625
#define ALPHA_DISCARD 0.1
6626
// optimize discard usage
6627
#if defined(ALPHA_DISCARD)
6628
#if defined(GL_ARB_conservative_depth)
6629
layout (depth_greater) out float gl_FragDepth;
6630
#endif
6631
#endif
6632
out vec4 fragColor;
6633
6634
vec4 FLWBlockTexture(vec2 texCoords) {
6635
return texture(uBlockAtlas, texCoords);
6636
}
6637
6638
void FLWFinalizeColor(vec4 color) {
6639
float a = color.a;
6640
float fog = clamp(FLWFogFactor(), 0., 1.);
6641
6642
color = mix(uFogColor, color, fog);
6643
color.a = a;
6644
6645
#if defined(ALPHA_DISCARD)
6646
if (color.a < ALPHA_DISCARD) {
6647
discard;
6648
}
6649
#endif
6650
6651
fragColor = color;
6652
}
6653
6654
vec4 FLWLight(vec2 lightCoords) {
6655
return texture(uLightMap, shiftLight(lightCoords));
6656
}
6657
#endif
6658
6659
6660
float diffuse(vec3 normal) {
6661
vec3 n2 = normal * normal * vec3(.6, .25, .8);
6662
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
6663
}
6664
struct Vertex {
6665
vec3 pos;
6666
vec2 texCoords;
6667
vec3 normal;
6668
};
6669
6670
struct BlockFrag {
6671
vec2 texCoords;
6672
vec4 color;
6673
float diffuse;
6674
vec2 light;
6675
};
6676
6677
#if defined(FRAGMENT_SHADER)
6678
void fragment(BlockFrag r) {
6679
vec4 tex = FLWBlockTexture(r.texCoords);
6680
6681
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
6682
6683
FLWFinalizeColor(color);
6684
}
6685
#endif
6686
6687
6688
6689
6690
struct Instance {
6691
vec2 light;
6692
vec4 color;
6693
mat4 transform;
6694
mat3 normalMat;
6695
};
6696
6697
#if defined(VERTEX_SHADER)
6698
BlockFrag vertex(Vertex v, Instance i) {
6699
vec4 worldPos = i.transform * vec4(v.pos, 1.);
6700
6701
vec3 norm = i.normalMat * v.normal;
6702
6703
FLWFinalizeWorldPos(worldPos);
6704
FLWFinalizeNormal(norm);
6705
6706
norm = normalize(norm);
6707
6708
BlockFrag b;
6709
b.diffuse = diffuse(norm);
6710
b.texCoords = v.texCoords;
6711
b.light = i.light;
6712
#if defined(DEBUG_NORMAL)
6713
b.color = vec4(norm, 1.);
6714
#else
6715
b.color = i.color;
6716
#endif
6717
return b;
6718
}
6719
#endif
6720
6721
in vec2 v2f_texCoords;
6722
in vec4 v2f_color;
6723
in float v2f_diffuse;
6724
in vec2 v2f_light;
6725
void main() {
6726
BlockFrag o;
6727
o.texCoords = v2f_texCoords;
6728
o.color = v2f_color;
6729
o.diffuse = v2f_diffuse;
6730
o.light = v2f_light;
6731
fragment(o);
6732
}
6733
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
6734
6735
[17:17:49] [Render thread/ERROR]: #version 150
6736
#extension GL_ARB_conservative_depth : enable
6737
#define VERTEX_SHADER
6738
#define DEBUG_NORMAL
6739
#if defined(VERTEX_SHADER)
6740
out float FragDistance;
6741
#elif defined(FRAGMENT_SHADER)
6742
in float FragDistance;
6743
#endif
6744
uniform vec4 uFogColor;
6745
uniform vec2 uFogRange;
6746
6747
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
6748
float distXZ = length(worldPos.xz - cameraPos.xz);
6749
float distY = abs(worldPos.y - cameraPos.y);
6750
return max(distXZ, distY);
6751
}
6752
6753
float cylindrical_distance(vec3 worldPos) {
6754
float distXZ = length(worldPos.xz);
6755
float distY = abs(worldPos.y);
6756
return max(distXZ, distY);
6757
}
6758
6759
float FLWFogFactor() {
6760
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
6761
}
6762
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
6763
vec2 shiftLight(vec2 lm) {
6764
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
6765
}
6766
6767
6768
uniform float uTime;
6769
uniform mat4 uViewProjection;
6770
uniform vec3 uCameraPos;
6771
6772
uniform vec2 uTextureScale;
6773
uniform sampler2D uBlockAtlas;
6774
uniform sampler2D uLightMap;
6775
6776
uniform vec2 uWindowSize;
6777
6778
void FLWFinalizeNormal(inout vec3 normal) {
6779
// noop
6780
}
6781
6782
#if defined(VERTEX_SHADER)
6783
void FLWFinalizeWorldPos(inout vec4 worldPos) {
6784
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
6785
6786
gl_Position = uViewProjection * worldPos;
6787
}
6788
6789
#elif defined(FRAGMENT_SHADER)
6790
6791
6792
#define ALPHA_DISCARD 0.1
6793
// optimize discard usage
6794
#if defined(ALPHA_DISCARD)
6795
#if defined(GL_ARB_conservative_depth)
6796
layout (depth_greater) out float gl_FragDepth;
6797
#endif
6798
#endif
6799
out vec4 fragColor;
6800
6801
vec4 FLWBlockTexture(vec2 texCoords) {
6802
return texture(uBlockAtlas, texCoords);
6803
}
6804
6805
void FLWFinalizeColor(vec4 color) {
6806
float a = color.a;
6807
float fog = clamp(FLWFogFactor(), 0., 1.);
6808
6809
color = mix(uFogColor, color, fog);
6810
color.a = a;
6811
6812
#if defined(ALPHA_DISCARD)
6813
if (color.a < ALPHA_DISCARD) {
6814
discard;
6815
}
6816
#endif
6817
6818
fragColor = color;
6819
}
6820
6821
vec4 FLWLight(vec2 lightCoords) {
6822
return texture(uLightMap, shiftLight(lightCoords));
6823
}
6824
#endif
6825
6826
6827
float diffuse(vec3 normal) {
6828
vec3 n2 = normal * normal * vec3(.6, .25, .8);
6829
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
6830
}
6831
struct Vertex {
6832
vec3 pos;
6833
vec2 texCoords;
6834
vec3 normal;
6835
};
6836
6837
struct BlockFrag {
6838
vec2 texCoords;
6839
vec4 color;
6840
float diffuse;
6841
vec2 light;
6842
};
6843
6844
#if defined(FRAGMENT_SHADER)
6845
void fragment(BlockFrag r) {
6846
vec4 tex = FLWBlockTexture(r.texCoords);
6847
6848
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
6849
6850
FLWFinalizeColor(color);
6851
}
6852
#endif
6853
6854
6855
6856
6857
struct Instance {
6858
vec2 light;
6859
vec4 color;
6860
mat4 transform;
6861
mat3 normalMat;
6862
};
6863
6864
#if defined(VERTEX_SHADER)
6865
BlockFrag vertex(Vertex v, Instance i) {
6866
vec4 worldPos = i.transform * vec4(v.pos, 1.);
6867
6868
vec3 norm = i.normalMat * v.normal;
6869
6870
FLWFinalizeWorldPos(worldPos);
6871
FLWFinalizeNormal(norm);
6872
6873
norm = normalize(norm);
6874
6875
BlockFrag b;
6876
b.diffuse = diffuse(norm);
6877
b.texCoords = v.texCoords;
6878
b.light = i.light;
6879
#if defined(DEBUG_NORMAL)
6880
b.color = vec4(norm, 1.);
6881
#else
6882
b.color = i.color;
6883
#endif
6884
return b;
6885
}
6886
#endif
6887
6888
in vec3 a_v_pos;
6889
in vec2 a_v_texCoords;
6890
in vec3 a_v_normal;
6891
in vec2 a_i_light;
6892
in vec4 a_i_color;
6893
in mat4 a_i_transform;
6894
in mat3 a_i_normalMat;
6895
out vec2 v2f_texCoords;
6896
out vec4 v2f_color;
6897
out float v2f_diffuse;
6898
out vec2 v2f_light;
6899
void main() {
6900
Vertex v;
6901
v.pos = a_v_pos;
6902
v.texCoords = a_v_texCoords;
6903
v.normal = a_v_normal;
6904
Instance i;
6905
i.light = a_i_light;
6906
i.color = a_i_color;
6907
i.transform = a_i_transform;
6908
i.normalMat = a_i_normalMat;
6909
BlockFrag o = vertex(v, i);
6910
v2f_texCoords = o.texCoords;
6911
v2f_color = o.color;
6912
v2f_diffuse = o.diffuse;
6913
v2f_light = o.light;
6914
}
6915
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
6916
6917
[17:17:49] [Render thread/ERROR]: #version 150
6918
#extension GL_ARB_conservative_depth : enable
6919
#define FRAGMENT_SHADER
6920
#define DEBUG_NORMAL
6921
#if defined(VERTEX_SHADER)
6922
out float FragDistance;
6923
#elif defined(FRAGMENT_SHADER)
6924
in float FragDistance;
6925
#endif
6926
uniform vec4 uFogColor;
6927
uniform vec2 uFogRange;
6928
6929
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
6930
float distXZ = length(worldPos.xz - cameraPos.xz);
6931
float distY = abs(worldPos.y - cameraPos.y);
6932
return max(distXZ, distY);
6933
}
6934
6935
float cylindrical_distance(vec3 worldPos) {
6936
float distXZ = length(worldPos.xz);
6937
float distY = abs(worldPos.y);
6938
return max(distXZ, distY);
6939
}
6940
6941
float FLWFogFactor() {
6942
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
6943
}
6944
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
6945
vec2 shiftLight(vec2 lm) {
6946
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
6947
}
6948
6949
6950
uniform float uTime;
6951
uniform mat4 uViewProjection;
6952
uniform vec3 uCameraPos;
6953
6954
uniform vec2 uTextureScale;
6955
uniform sampler2D uBlockAtlas;
6956
uniform sampler2D uLightMap;
6957
6958
uniform vec2 uWindowSize;
6959
6960
void FLWFinalizeNormal(inout vec3 normal) {
6961
// noop
6962
}
6963
6964
#if defined(VERTEX_SHADER)
6965
void FLWFinalizeWorldPos(inout vec4 worldPos) {
6966
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
6967
6968
gl_Position = uViewProjection * worldPos;
6969
}
6970
6971
#elif defined(FRAGMENT_SHADER)
6972
6973
6974
#define ALPHA_DISCARD 0.1
6975
// optimize discard usage
6976
#if defined(ALPHA_DISCARD)
6977
#if defined(GL_ARB_conservative_depth)
6978
layout (depth_greater) out float gl_FragDepth;
6979
#endif
6980
#endif
6981
out vec4 fragColor;
6982
6983
vec4 FLWBlockTexture(vec2 texCoords) {
6984
return texture(uBlockAtlas, texCoords);
6985
}
6986
6987
void FLWFinalizeColor(vec4 color) {
6988
float a = color.a;
6989
float fog = clamp(FLWFogFactor(), 0., 1.);
6990
6991
color = mix(uFogColor, color, fog);
6992
color.a = a;
6993
6994
#if defined(ALPHA_DISCARD)
6995
if (color.a < ALPHA_DISCARD) {
6996
discard;
6997
}
6998
#endif
6999
7000
fragColor = color;
7001
}
7002
7003
vec4 FLWLight(vec2 lightCoords) {
7004
return texture(uLightMap, shiftLight(lightCoords));
7005
}
7006
#endif
7007
7008
7009
float diffuse(vec3 normal) {
7010
vec3 n2 = normal * normal * vec3(.6, .25, .8);
7011
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
7012
}
7013
struct Vertex {
7014
vec3 pos;
7015
vec2 texCoords;
7016
vec3 normal;
7017
};
7018
7019
struct BlockFrag {
7020
vec2 texCoords;
7021
vec4 color;
7022
float diffuse;
7023
vec2 light;
7024
};
7025
7026
#if defined(FRAGMENT_SHADER)
7027
void fragment(BlockFrag r) {
7028
vec4 tex = FLWBlockTexture(r.texCoords);
7029
7030
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
7031
7032
FLWFinalizeColor(color);
7033
}
7034
#endif
7035
7036
7037
7038
7039
struct Instance {
7040
vec2 light;
7041
vec4 color;
7042
mat4 transform;
7043
mat3 normalMat;
7044
};
7045
7046
#if defined(VERTEX_SHADER)
7047
BlockFrag vertex(Vertex v, Instance i) {
7048
vec4 worldPos = i.transform * vec4(v.pos, 1.);
7049
7050
vec3 norm = i.normalMat * v.normal;
7051
7052
FLWFinalizeWorldPos(worldPos);
7053
FLWFinalizeNormal(norm);
7054
7055
norm = normalize(norm);
7056
7057
BlockFrag b;
7058
b.diffuse = diffuse(norm);
7059
b.texCoords = v.texCoords;
7060
b.light = i.light;
7061
#if defined(DEBUG_NORMAL)
7062
b.color = vec4(norm, 1.);
7063
#else
7064
b.color = i.color;
7065
#endif
7066
return b;
7067
}
7068
#endif
7069
7070
in vec2 v2f_texCoords;
7071
in vec4 v2f_color;
7072
in float v2f_diffuse;
7073
in vec2 v2f_light;
7074
void main() {
7075
BlockFrag o;
7076
o.texCoords = v2f_texCoords;
7077
o.color = v2f_color;
7078
o.diffuse = v2f_diffuse;
7079
o.light = v2f_light;
7080
fragment(o);
7081
}
7082
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
7083
7084
[17:17:49] [Render thread/ERROR]: #version 150
7085
#extension GL_ARB_conservative_depth : enable
7086
#define VERTEX_SHADER
7087
#if defined(VERTEX_SHADER)
7088
out float FragDistance;
7089
#elif defined(FRAGMENT_SHADER)
7090
in float FragDistance;
7091
#endif
7092
uniform vec4 uFogColor;
7093
uniform vec2 uFogRange;
7094
7095
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
7096
float distXZ = length(worldPos.xz - cameraPos.xz);
7097
float distY = abs(worldPos.y - cameraPos.y);
7098
return max(distXZ, distY);
7099
}
7100
7101
float cylindrical_distance(vec3 worldPos) {
7102
float distXZ = length(worldPos.xz);
7103
float distY = abs(worldPos.y);
7104
return max(distXZ, distY);
7105
}
7106
7107
float FLWFogFactor() {
7108
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
7109
}
7110
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
7111
vec2 shiftLight(vec2 lm) {
7112
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
7113
}
7114
7115
7116
uniform float uTime;
7117
uniform mat4 uViewProjection;
7118
uniform vec3 uCameraPos;
7119
7120
uniform vec2 uTextureScale;
7121
uniform sampler2D uBlockAtlas;
7122
uniform sampler2D uLightMap;
7123
7124
uniform vec2 uWindowSize;
7125
7126
void FLWFinalizeNormal(inout vec3 normal) {
7127
// noop
7128
}
7129
7130
#if defined(VERTEX_SHADER)
7131
void FLWFinalizeWorldPos(inout vec4 worldPos) {
7132
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
7133
7134
gl_Position = uViewProjection * worldPos;
7135
}
7136
7137
#elif defined(FRAGMENT_SHADER)
7138
7139
7140
#define ALPHA_DISCARD 0.1
7141
// optimize discard usage
7142
#if defined(ALPHA_DISCARD)
7143
#if defined(GL_ARB_conservative_depth)
7144
layout (depth_greater) out float gl_FragDepth;
7145
#endif
7146
#endif
7147
out vec4 fragColor;
7148
7149
vec4 FLWBlockTexture(vec2 texCoords) {
7150
return texture(uBlockAtlas, texCoords);
7151
}
7152
7153
void FLWFinalizeColor(vec4 color) {
7154
float a = color.a;
7155
float fog = clamp(FLWFogFactor(), 0., 1.);
7156
7157
color = mix(uFogColor, color, fog);
7158
color.a = a;
7159
7160
#if defined(ALPHA_DISCARD)
7161
if (color.a < ALPHA_DISCARD) {
7162
discard;
7163
}
7164
#endif
7165
7166
fragColor = color;
7167
}
7168
7169
vec4 FLWLight(vec2 lightCoords) {
7170
return texture(uLightMap, shiftLight(lightCoords));
7171
}
7172
#endif
7173
7174
7175
#define PIOVER2 1.5707963268
7176
7177
vec4 quat(vec3 axis, float angle) {
7178
float halfAngle = angle * PIOVER2 / 180.0;
7179
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
7180
return vec4(axis.xyz * cs.y, cs.x);
7181
}
7182
7183
vec4 quatMult(vec4 q1, vec4 q2) {
7184
// disgustingly vectorized quaternion multiplication
7185
vec4 a = q1.w * q2.xyzw;
7186
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
7187
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
7188
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
7189
7190
return a + b + c + d;
7191
}
7192
7193
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
7194
vec3 i = q.xyz;
7195
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
7196
}
7197
7198
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
7199
return rotateVertexByQuat(v, quat(axis, angle));
7200
}
7201
7202
float diffuse(vec3 normal) {
7203
vec3 n2 = normal * normal * vec3(.6, .25, .8);
7204
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
7205
}
7206
struct Vertex {
7207
vec3 pos;
7208
vec2 texCoords;
7209
vec3 normal;
7210
};
7211
7212
struct BlockFrag {
7213
vec2 texCoords;
7214
vec4 color;
7215
float diffuse;
7216
vec2 light;
7217
};
7218
7219
#if defined(FRAGMENT_SHADER)
7220
void fragment(BlockFrag r) {
7221
vec4 tex = FLWBlockTexture(r.texCoords);
7222
7223
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
7224
7225
FLWFinalizeColor(color);
7226
}
7227
#endif
7228
7229
7230
7231
7232
7233
7234
struct Oriented {
7235
vec2 light;
7236
vec4 color;
7237
vec3 pos;
7238
vec3 pivot;
7239
vec4 rotation;
7240
};
7241
7242
#if defined(VERTEX_SHADER)
7243
BlockFrag vertex(Vertex v, Oriented o) {
7244
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
7245
7246
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
7247
7248
FLWFinalizeWorldPos(worldPos);
7249
FLWFinalizeNormal(norm);
7250
7251
BlockFrag b;
7252
b.diffuse = diffuse(norm);
7253
b.texCoords = v.texCoords;
7254
b.light = o.light;
7255
#if defined(DEBUG_NORMAL)
7256
b.color = vec4(norm, 1.);
7257
#else
7258
b.color = o.color;
7259
#endif
7260
return b;
7261
}
7262
#endif
7263
7264
in vec3 a_v_pos;
7265
in vec2 a_v_texCoords;
7266
in vec3 a_v_normal;
7267
in vec2 a_i_light;
7268
in vec4 a_i_color;
7269
in vec3 a_i_pos;
7270
in vec3 a_i_pivot;
7271
in vec4 a_i_rotation;
7272
out vec2 v2f_texCoords;
7273
out vec4 v2f_color;
7274
out float v2f_diffuse;
7275
out vec2 v2f_light;
7276
void main() {
7277
Vertex v;
7278
v.pos = a_v_pos;
7279
v.texCoords = a_v_texCoords;
7280
v.normal = a_v_normal;
7281
Oriented i;
7282
i.light = a_i_light;
7283
i.color = a_i_color;
7284
i.pos = a_i_pos;
7285
i.pivot = a_i_pivot;
7286
i.rotation = a_i_rotation;
7287
BlockFrag o = vertex(v, i);
7288
v2f_texCoords = o.texCoords;
7289
v2f_color = o.color;
7290
v2f_diffuse = o.diffuse;
7291
v2f_light = o.light;
7292
}
7293
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
7294
7295
[17:17:49] [Render thread/ERROR]: #version 150
7296
#extension GL_ARB_conservative_depth : enable
7297
#define FRAGMENT_SHADER
7298
#if defined(VERTEX_SHADER)
7299
out float FragDistance;
7300
#elif defined(FRAGMENT_SHADER)
7301
in float FragDistance;
7302
#endif
7303
uniform vec4 uFogColor;
7304
uniform vec2 uFogRange;
7305
7306
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
7307
float distXZ = length(worldPos.xz - cameraPos.xz);
7308
float distY = abs(worldPos.y - cameraPos.y);
7309
return max(distXZ, distY);
7310
}
7311
7312
float cylindrical_distance(vec3 worldPos) {
7313
float distXZ = length(worldPos.xz);
7314
float distY = abs(worldPos.y);
7315
return max(distXZ, distY);
7316
}
7317
7318
float FLWFogFactor() {
7319
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
7320
}
7321
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
7322
vec2 shiftLight(vec2 lm) {
7323
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
7324
}
7325
7326
7327
uniform float uTime;
7328
uniform mat4 uViewProjection;
7329
uniform vec3 uCameraPos;
7330
7331
uniform vec2 uTextureScale;
7332
uniform sampler2D uBlockAtlas;
7333
uniform sampler2D uLightMap;
7334
7335
uniform vec2 uWindowSize;
7336
7337
void FLWFinalizeNormal(inout vec3 normal) {
7338
// noop
7339
}
7340
7341
#if defined(VERTEX_SHADER)
7342
void FLWFinalizeWorldPos(inout vec4 worldPos) {
7343
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
7344
7345
gl_Position = uViewProjection * worldPos;
7346
}
7347
7348
#elif defined(FRAGMENT_SHADER)
7349
7350
7351
#define ALPHA_DISCARD 0.1
7352
// optimize discard usage
7353
#if defined(ALPHA_DISCARD)
7354
#if defined(GL_ARB_conservative_depth)
7355
layout (depth_greater) out float gl_FragDepth;
7356
#endif
7357
#endif
7358
out vec4 fragColor;
7359
7360
vec4 FLWBlockTexture(vec2 texCoords) {
7361
return texture(uBlockAtlas, texCoords);
7362
}
7363
7364
void FLWFinalizeColor(vec4 color) {
7365
float a = color.a;
7366
float fog = clamp(FLWFogFactor(), 0., 1.);
7367
7368
color = mix(uFogColor, color, fog);
7369
color.a = a;
7370
7371
#if defined(ALPHA_DISCARD)
7372
if (color.a < ALPHA_DISCARD) {
7373
discard;
7374
}
7375
#endif
7376
7377
fragColor = color;
7378
}
7379
7380
vec4 FLWLight(vec2 lightCoords) {
7381
return texture(uLightMap, shiftLight(lightCoords));
7382
}
7383
#endif
7384
7385
7386
#define PIOVER2 1.5707963268
7387
7388
vec4 quat(vec3 axis, float angle) {
7389
float halfAngle = angle * PIOVER2 / 180.0;
7390
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
7391
return vec4(axis.xyz * cs.y, cs.x);
7392
}
7393
7394
vec4 quatMult(vec4 q1, vec4 q2) {
7395
// disgustingly vectorized quaternion multiplication
7396
vec4 a = q1.w * q2.xyzw;
7397
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
7398
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
7399
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
7400
7401
return a + b + c + d;
7402
}
7403
7404
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
7405
vec3 i = q.xyz;
7406
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
7407
}
7408
7409
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
7410
return rotateVertexByQuat(v, quat(axis, angle));
7411
}
7412
7413
float diffuse(vec3 normal) {
7414
vec3 n2 = normal * normal * vec3(.6, .25, .8);
7415
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
7416
}
7417
struct Vertex {
7418
vec3 pos;
7419
vec2 texCoords;
7420
vec3 normal;
7421
};
7422
7423
struct BlockFrag {
7424
vec2 texCoords;
7425
vec4 color;
7426
float diffuse;
7427
vec2 light;
7428
};
7429
7430
#if defined(FRAGMENT_SHADER)
7431
void fragment(BlockFrag r) {
7432
vec4 tex = FLWBlockTexture(r.texCoords);
7433
7434
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
7435
7436
FLWFinalizeColor(color);
7437
}
7438
#endif
7439
7440
7441
7442
7443
7444
7445
struct Oriented {
7446
vec2 light;
7447
vec4 color;
7448
vec3 pos;
7449
vec3 pivot;
7450
vec4 rotation;
7451
};
7452
7453
#if defined(VERTEX_SHADER)
7454
BlockFrag vertex(Vertex v, Oriented o) {
7455
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
7456
7457
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
7458
7459
FLWFinalizeWorldPos(worldPos);
7460
FLWFinalizeNormal(norm);
7461
7462
BlockFrag b;
7463
b.diffuse = diffuse(norm);
7464
b.texCoords = v.texCoords;
7465
b.light = o.light;
7466
#if defined(DEBUG_NORMAL)
7467
b.color = vec4(norm, 1.);
7468
#else
7469
b.color = o.color;
7470
#endif
7471
return b;
7472
}
7473
#endif
7474
7475
in vec2 v2f_texCoords;
7476
in vec4 v2f_color;
7477
in float v2f_diffuse;
7478
in vec2 v2f_light;
7479
void main() {
7480
BlockFrag o;
7481
o.texCoords = v2f_texCoords;
7482
o.color = v2f_color;
7483
o.diffuse = v2f_diffuse;
7484
o.light = v2f_light;
7485
fragment(o);
7486
}
7487
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
7488
7489
[17:17:49] [Render thread/ERROR]: #version 150
7490
#extension GL_ARB_conservative_depth : enable
7491
#define VERTEX_SHADER
7492
#define DEBUG_NORMAL
7493
#if defined(VERTEX_SHADER)
7494
out float FragDistance;
7495
#elif defined(FRAGMENT_SHADER)
7496
in float FragDistance;
7497
#endif
7498
uniform vec4 uFogColor;
7499
uniform vec2 uFogRange;
7500
7501
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
7502
float distXZ = length(worldPos.xz - cameraPos.xz);
7503
float distY = abs(worldPos.y - cameraPos.y);
7504
return max(distXZ, distY);
7505
}
7506
7507
float cylindrical_distance(vec3 worldPos) {
7508
float distXZ = length(worldPos.xz);
7509
float distY = abs(worldPos.y);
7510
return max(distXZ, distY);
7511
}
7512
7513
float FLWFogFactor() {
7514
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
7515
}
7516
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
7517
vec2 shiftLight(vec2 lm) {
7518
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
7519
}
7520
7521
7522
uniform float uTime;
7523
uniform mat4 uViewProjection;
7524
uniform vec3 uCameraPos;
7525
7526
uniform vec2 uTextureScale;
7527
uniform sampler2D uBlockAtlas;
7528
uniform sampler2D uLightMap;
7529
7530
uniform vec2 uWindowSize;
7531
7532
void FLWFinalizeNormal(inout vec3 normal) {
7533
// noop
7534
}
7535
7536
#if defined(VERTEX_SHADER)
7537
void FLWFinalizeWorldPos(inout vec4 worldPos) {
7538
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
7539
7540
gl_Position = uViewProjection * worldPos;
7541
}
7542
7543
#elif defined(FRAGMENT_SHADER)
7544
7545
7546
#define ALPHA_DISCARD 0.1
7547
// optimize discard usage
7548
#if defined(ALPHA_DISCARD)
7549
#if defined(GL_ARB_conservative_depth)
7550
layout (depth_greater) out float gl_FragDepth;
7551
#endif
7552
#endif
7553
out vec4 fragColor;
7554
7555
vec4 FLWBlockTexture(vec2 texCoords) {
7556
return texture(uBlockAtlas, texCoords);
7557
}
7558
7559
void FLWFinalizeColor(vec4 color) {
7560
float a = color.a;
7561
float fog = clamp(FLWFogFactor(), 0., 1.);
7562
7563
color = mix(uFogColor, color, fog);
7564
color.a = a;
7565
7566
#if defined(ALPHA_DISCARD)
7567
if (color.a < ALPHA_DISCARD) {
7568
discard;
7569
}
7570
#endif
7571
7572
fragColor = color;
7573
}
7574
7575
vec4 FLWLight(vec2 lightCoords) {
7576
return texture(uLightMap, shiftLight(lightCoords));
7577
}
7578
#endif
7579
7580
7581
#define PIOVER2 1.5707963268
7582
7583
vec4 quat(vec3 axis, float angle) {
7584
float halfAngle = angle * PIOVER2 / 180.0;
7585
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
7586
return vec4(axis.xyz * cs.y, cs.x);
7587
}
7588
7589
vec4 quatMult(vec4 q1, vec4 q2) {
7590
// disgustingly vectorized quaternion multiplication
7591
vec4 a = q1.w * q2.xyzw;
7592
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
7593
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
7594
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
7595
7596
return a + b + c + d;
7597
}
7598
7599
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
7600
vec3 i = q.xyz;
7601
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
7602
}
7603
7604
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
7605
return rotateVertexByQuat(v, quat(axis, angle));
7606
}
7607
7608
float diffuse(vec3 normal) {
7609
vec3 n2 = normal * normal * vec3(.6, .25, .8);
7610
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
7611
}
7612
struct Vertex {
7613
vec3 pos;
7614
vec2 texCoords;
7615
vec3 normal;
7616
};
7617
7618
struct BlockFrag {
7619
vec2 texCoords;
7620
vec4 color;
7621
float diffuse;
7622
vec2 light;
7623
};
7624
7625
#if defined(FRAGMENT_SHADER)
7626
void fragment(BlockFrag r) {
7627
vec4 tex = FLWBlockTexture(r.texCoords);
7628
7629
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
7630
7631
FLWFinalizeColor(color);
7632
}
7633
#endif
7634
7635
7636
7637
7638
7639
7640
struct Oriented {
7641
vec2 light;
7642
vec4 color;
7643
vec3 pos;
7644
vec3 pivot;
7645
vec4 rotation;
7646
};
7647
7648
#if defined(VERTEX_SHADER)
7649
BlockFrag vertex(Vertex v, Oriented o) {
7650
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
7651
7652
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
7653
7654
FLWFinalizeWorldPos(worldPos);
7655
FLWFinalizeNormal(norm);
7656
7657
BlockFrag b;
7658
b.diffuse = diffuse(norm);
7659
b.texCoords = v.texCoords;
7660
b.light = o.light;
7661
#if defined(DEBUG_NORMAL)
7662
b.color = vec4(norm, 1.);
7663
#else
7664
b.color = o.color;
7665
#endif
7666
return b;
7667
}
7668
#endif
7669
7670
in vec3 a_v_pos;
7671
in vec2 a_v_texCoords;
7672
in vec3 a_v_normal;
7673
in vec2 a_i_light;
7674
in vec4 a_i_color;
7675
in vec3 a_i_pos;
7676
in vec3 a_i_pivot;
7677
in vec4 a_i_rotation;
7678
out vec2 v2f_texCoords;
7679
out vec4 v2f_color;
7680
out float v2f_diffuse;
7681
out vec2 v2f_light;
7682
void main() {
7683
Vertex v;
7684
v.pos = a_v_pos;
7685
v.texCoords = a_v_texCoords;
7686
v.normal = a_v_normal;
7687
Oriented i;
7688
i.light = a_i_light;
7689
i.color = a_i_color;
7690
i.pos = a_i_pos;
7691
i.pivot = a_i_pivot;
7692
i.rotation = a_i_rotation;
7693
BlockFrag o = vertex(v, i);
7694
v2f_texCoords = o.texCoords;
7695
v2f_color = o.color;
7696
v2f_diffuse = o.diffuse;
7697
v2f_light = o.light;
7698
}
7699
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
7700
7701
[17:17:49] [Render thread/ERROR]: #version 150
7702
#extension GL_ARB_conservative_depth : enable
7703
#define FRAGMENT_SHADER
7704
#define DEBUG_NORMAL
7705
#if defined(VERTEX_SHADER)
7706
out float FragDistance;
7707
#elif defined(FRAGMENT_SHADER)
7708
in float FragDistance;
7709
#endif
7710
uniform vec4 uFogColor;
7711
uniform vec2 uFogRange;
7712
7713
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
7714
float distXZ = length(worldPos.xz - cameraPos.xz);
7715
float distY = abs(worldPos.y - cameraPos.y);
7716
return max(distXZ, distY);
7717
}
7718
7719
float cylindrical_distance(vec3 worldPos) {
7720
float distXZ = length(worldPos.xz);
7721
float distY = abs(worldPos.y);
7722
return max(distXZ, distY);
7723
}
7724
7725
float FLWFogFactor() {
7726
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
7727
}
7728
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
7729
vec2 shiftLight(vec2 lm) {
7730
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
7731
}
7732
7733
7734
uniform float uTime;
7735
uniform mat4 uViewProjection;
7736
uniform vec3 uCameraPos;
7737
7738
uniform vec2 uTextureScale;
7739
uniform sampler2D uBlockAtlas;
7740
uniform sampler2D uLightMap;
7741
7742
uniform vec2 uWindowSize;
7743
7744
void FLWFinalizeNormal(inout vec3 normal) {
7745
// noop
7746
}
7747
7748
#if defined(VERTEX_SHADER)
7749
void FLWFinalizeWorldPos(inout vec4 worldPos) {
7750
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
7751
7752
gl_Position = uViewProjection * worldPos;
7753
}
7754
7755
#elif defined(FRAGMENT_SHADER)
7756
7757
7758
#define ALPHA_DISCARD 0.1
7759
// optimize discard usage
7760
#if defined(ALPHA_DISCARD)
7761
#if defined(GL_ARB_conservative_depth)
7762
layout (depth_greater) out float gl_FragDepth;
7763
#endif
7764
#endif
7765
out vec4 fragColor;
7766
7767
vec4 FLWBlockTexture(vec2 texCoords) {
7768
return texture(uBlockAtlas, texCoords);
7769
}
7770
7771
void FLWFinalizeColor(vec4 color) {
7772
float a = color.a;
7773
float fog = clamp(FLWFogFactor(), 0., 1.);
7774
7775
color = mix(uFogColor, color, fog);
7776
color.a = a;
7777
7778
#if defined(ALPHA_DISCARD)
7779
if (color.a < ALPHA_DISCARD) {
7780
discard;
7781
}
7782
#endif
7783
7784
fragColor = color;
7785
}
7786
7787
vec4 FLWLight(vec2 lightCoords) {
7788
return texture(uLightMap, shiftLight(lightCoords));
7789
}
7790
#endif
7791
7792
7793
#define PIOVER2 1.5707963268
7794
7795
vec4 quat(vec3 axis, float angle) {
7796
float halfAngle = angle * PIOVER2 / 180.0;
7797
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
7798
return vec4(axis.xyz * cs.y, cs.x);
7799
}
7800
7801
vec4 quatMult(vec4 q1, vec4 q2) {
7802
// disgustingly vectorized quaternion multiplication
7803
vec4 a = q1.w * q2.xyzw;
7804
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
7805
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
7806
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
7807
7808
return a + b + c + d;
7809
}
7810
7811
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
7812
vec3 i = q.xyz;
7813
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
7814
}
7815
7816
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
7817
return rotateVertexByQuat(v, quat(axis, angle));
7818
}
7819
7820
float diffuse(vec3 normal) {
7821
vec3 n2 = normal * normal * vec3(.6, .25, .8);
7822
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
7823
}
7824
struct Vertex {
7825
vec3 pos;
7826
vec2 texCoords;
7827
vec3 normal;
7828
};
7829
7830
struct BlockFrag {
7831
vec2 texCoords;
7832
vec4 color;
7833
float diffuse;
7834
vec2 light;
7835
};
7836
7837
#if defined(FRAGMENT_SHADER)
7838
void fragment(BlockFrag r) {
7839
vec4 tex = FLWBlockTexture(r.texCoords);
7840
7841
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
7842
7843
FLWFinalizeColor(color);
7844
}
7845
#endif
7846
7847
7848
7849
7850
7851
7852
struct Oriented {
7853
vec2 light;
7854
vec4 color;
7855
vec3 pos;
7856
vec3 pivot;
7857
vec4 rotation;
7858
};
7859
7860
#if defined(VERTEX_SHADER)
7861
BlockFrag vertex(Vertex v, Oriented o) {
7862
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
7863
7864
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
7865
7866
FLWFinalizeWorldPos(worldPos);
7867
FLWFinalizeNormal(norm);
7868
7869
BlockFrag b;
7870
b.diffuse = diffuse(norm);
7871
b.texCoords = v.texCoords;
7872
b.light = o.light;
7873
#if defined(DEBUG_NORMAL)
7874
b.color = vec4(norm, 1.);
7875
#else
7876
b.color = o.color;
7877
#endif
7878
return b;
7879
}
7880
#endif
7881
7882
in vec2 v2f_texCoords;
7883
in vec4 v2f_color;
7884
in float v2f_diffuse;
7885
in vec2 v2f_light;
7886
void main() {
7887
BlockFrag o;
7888
o.texCoords = v2f_texCoords;
7889
o.color = v2f_color;
7890
o.diffuse = v2f_diffuse;
7891
o.light = v2f_light;
7892
fragment(o);
7893
}
7894
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
7895
7896
[17:17:49] [Render thread/ERROR]: #version 150
7897
#extension GL_ARB_conservative_depth : enable
7898
#define VERTEX_SHADER
7899
#if defined(VERTEX_SHADER)
7900
out float FragDistance;
7901
#elif defined(FRAGMENT_SHADER)
7902
in float FragDistance;
7903
#endif
7904
uniform vec4 uFogColor;
7905
uniform vec2 uFogRange;
7906
7907
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
7908
float distXZ = length(worldPos.xz - cameraPos.xz);
7909
float distY = abs(worldPos.y - cameraPos.y);
7910
return max(distXZ, distY);
7911
}
7912
7913
float cylindrical_distance(vec3 worldPos) {
7914
float distXZ = length(worldPos.xz);
7915
float distY = abs(worldPos.y);
7916
return max(distXZ, distY);
7917
}
7918
7919
float FLWFogFactor() {
7920
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
7921
}
7922
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
7923
vec2 shiftLight(vec2 lm) {
7924
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
7925
}
7926
7927
7928
uniform float uTime;
7929
uniform mat4 uViewProjection;
7930
uniform vec3 uCameraPos;
7931
7932
uniform vec2 uTextureScale;
7933
uniform sampler2D uBlockAtlas;
7934
uniform sampler2D uLightMap;
7935
7936
uniform vec2 uWindowSize;
7937
7938
void FLWFinalizeNormal(inout vec3 normal) {
7939
// noop
7940
}
7941
7942
#if defined(VERTEX_SHADER)
7943
void FLWFinalizeWorldPos(inout vec4 worldPos) {
7944
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
7945
7946
gl_Position = uViewProjection * worldPos;
7947
}
7948
7949
#elif defined(FRAGMENT_SHADER)
7950
7951
7952
#define ALPHA_DISCARD 0.1
7953
// optimize discard usage
7954
#if defined(ALPHA_DISCARD)
7955
#if defined(GL_ARB_conservative_depth)
7956
layout (depth_greater) out float gl_FragDepth;
7957
#endif
7958
#endif
7959
out vec4 fragColor;
7960
7961
vec4 FLWBlockTexture(vec2 texCoords) {
7962
return texture(uBlockAtlas, texCoords);
7963
}
7964
7965
void FLWFinalizeColor(vec4 color) {
7966
float a = color.a;
7967
float fog = clamp(FLWFogFactor(), 0., 1.);
7968
7969
color = mix(uFogColor, color, fog);
7970
color.a = a;
7971
7972
#if defined(ALPHA_DISCARD)
7973
if (color.a < ALPHA_DISCARD) {
7974
discard;
7975
}
7976
#endif
7977
7978
fragColor = color;
7979
}
7980
7981
vec4 FLWLight(vec2 lightCoords) {
7982
return texture(uLightMap, shiftLight(lightCoords));
7983
}
7984
#endif
7985
7986
7987
mat4 rotate(vec3 axis, float angle) {
7988
float s = sin(angle);
7989
float c = cos(angle);
7990
float oc = 1. - c;
7991
7992
vec3 sa = axis * s;
7993
7994
mat4 mr = mat4(1.);
7995
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
7996
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
7997
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
7998
7999
return mr;
8000
}
8001
8002
mat4 rotation(vec3 rot) {
8003
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
8004
}
8005
8006
mat3 modelToNormal(mat4 mat) {
8007
// Discard the edges. This won't be accurate for scaled or skewed matrices,
8008
// but we don't have to work with those often.
8009
mat3 m;
8010
m[0] = mat[0].xyz;
8011
m[1] = mat[1].xyz;
8012
m[2] = mat[2].xyz;
8013
return m;
8014
}
8015
8016
float diffuse(vec3 normal) {
8017
vec3 n2 = normal * normal * vec3(.6, .25, .8);
8018
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
8019
}
8020
struct Vertex {
8021
vec3 pos;
8022
vec2 texCoords;
8023
vec3 normal;
8024
};
8025
8026
struct BlockFrag {
8027
vec2 texCoords;
8028
vec4 color;
8029
float diffuse;
8030
vec2 light;
8031
};
8032
8033
#if defined(FRAGMENT_SHADER)
8034
void fragment(BlockFrag r) {
8035
vec4 tex = FLWBlockTexture(r.texCoords);
8036
8037
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
8038
8039
FLWFinalizeColor(color);
8040
}
8041
#endif
8042
#define PI 3.1415926538
8043
8044
8045
8046
8047
struct Rotating {
8048
vec2 light;
8049
vec4 color;
8050
vec3 pos;
8051
float speed;
8052
float offset;
8053
vec3 axis;
8054
};
8055
8056
8057
8058
8059
mat4 kineticRotation(float offset, float speed, vec3 axis) {
8060
float degrees = offset + uTime * speed * 3./10.;
8061
float angle = fract(degrees / 360.) * PI * 2.;
8062
8063
return rotate(axis, angle);
8064
}
8065
8066
#if defined(VERTEX_SHADER)
8067
BlockFrag vertex(Vertex v, Rotating instance) {
8068
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
8069
8070
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
8071
worldPos += vec4(instance.pos + .5, 0.);
8072
8073
vec3 norm = modelToNormal(spin) * v.normal;
8074
8075
FLWFinalizeWorldPos(worldPos);
8076
FLWFinalizeNormal(norm);
8077
8078
BlockFrag b;
8079
b.diffuse = diffuse(norm);
8080
b.texCoords = v.texCoords;
8081
b.light = instance.light;
8082
8083
#if defined(DEBUG_RAINBOW)
8084
b.color = instance.color;
8085
#elif defined(DEBUG_NORMAL)
8086
b.color = vec4(norm, 1.);
8087
#else
8088
b.color = vec4(1.);
8089
#endif
8090
8091
return b;
8092
}
8093
#endif
8094
8095
in vec3 a_v_pos;
8096
in vec2 a_v_texCoords;
8097
in vec3 a_v_normal;
8098
in vec2 a_i_light;
8099
in vec4 a_i_color;
8100
in vec3 a_i_pos;
8101
in float a_i_speed;
8102
in float a_i_offset;
8103
in vec3 a_i_axis;
8104
out vec2 v2f_texCoords;
8105
out vec4 v2f_color;
8106
out float v2f_diffuse;
8107
out vec2 v2f_light;
8108
void main() {
8109
Vertex v;
8110
v.pos = a_v_pos;
8111
v.texCoords = a_v_texCoords;
8112
v.normal = a_v_normal;
8113
Rotating i;
8114
i.light = a_i_light;
8115
i.color = a_i_color;
8116
i.pos = a_i_pos;
8117
i.speed = a_i_speed;
8118
i.offset = a_i_offset;
8119
i.axis = a_i_axis;
8120
BlockFrag o = vertex(v, i);
8121
v2f_texCoords = o.texCoords;
8122
v2f_color = o.color;
8123
v2f_diffuse = o.diffuse;
8124
v2f_light = o.light;
8125
}
8126
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
8127
8128
[17:17:49] [Render thread/ERROR]: #version 150
8129
#extension GL_ARB_conservative_depth : enable
8130
#define FRAGMENT_SHADER
8131
#if defined(VERTEX_SHADER)
8132
out float FragDistance;
8133
#elif defined(FRAGMENT_SHADER)
8134
in float FragDistance;
8135
#endif
8136
uniform vec4 uFogColor;
8137
uniform vec2 uFogRange;
8138
8139
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
8140
float distXZ = length(worldPos.xz - cameraPos.xz);
8141
float distY = abs(worldPos.y - cameraPos.y);
8142
return max(distXZ, distY);
8143
}
8144
8145
float cylindrical_distance(vec3 worldPos) {
8146
float distXZ = length(worldPos.xz);
8147
float distY = abs(worldPos.y);
8148
return max(distXZ, distY);
8149
}
8150
8151
float FLWFogFactor() {
8152
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
8153
}
8154
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
8155
vec2 shiftLight(vec2 lm) {
8156
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
8157
}
8158
8159
8160
uniform float uTime;
8161
uniform mat4 uViewProjection;
8162
uniform vec3 uCameraPos;
8163
8164
uniform vec2 uTextureScale;
8165
uniform sampler2D uBlockAtlas;
8166
uniform sampler2D uLightMap;
8167
8168
uniform vec2 uWindowSize;
8169
8170
void FLWFinalizeNormal(inout vec3 normal) {
8171
// noop
8172
}
8173
8174
#if defined(VERTEX_SHADER)
8175
void FLWFinalizeWorldPos(inout vec4 worldPos) {
8176
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
8177
8178
gl_Position = uViewProjection * worldPos;
8179
}
8180
8181
#elif defined(FRAGMENT_SHADER)
8182
8183
8184
#define ALPHA_DISCARD 0.1
8185
// optimize discard usage
8186
#if defined(ALPHA_DISCARD)
8187
#if defined(GL_ARB_conservative_depth)
8188
layout (depth_greater) out float gl_FragDepth;
8189
#endif
8190
#endif
8191
out vec4 fragColor;
8192
8193
vec4 FLWBlockTexture(vec2 texCoords) {
8194
return texture(uBlockAtlas, texCoords);
8195
}
8196
8197
void FLWFinalizeColor(vec4 color) {
8198
float a = color.a;
8199
float fog = clamp(FLWFogFactor(), 0., 1.);
8200
8201
color = mix(uFogColor, color, fog);
8202
color.a = a;
8203
8204
#if defined(ALPHA_DISCARD)
8205
if (color.a < ALPHA_DISCARD) {
8206
discard;
8207
}
8208
#endif
8209
8210
fragColor = color;
8211
}
8212
8213
vec4 FLWLight(vec2 lightCoords) {
8214
return texture(uLightMap, shiftLight(lightCoords));
8215
}
8216
#endif
8217
8218
8219
mat4 rotate(vec3 axis, float angle) {
8220
float s = sin(angle);
8221
float c = cos(angle);
8222
float oc = 1. - c;
8223
8224
vec3 sa = axis * s;
8225
8226
mat4 mr = mat4(1.);
8227
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
8228
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
8229
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
8230
8231
return mr;
8232
}
8233
8234
mat4 rotation(vec3 rot) {
8235
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
8236
}
8237
8238
mat3 modelToNormal(mat4 mat) {
8239
// Discard the edges. This won't be accurate for scaled or skewed matrices,
8240
// but we don't have to work with those often.
8241
mat3 m;
8242
m[0] = mat[0].xyz;
8243
m[1] = mat[1].xyz;
8244
m[2] = mat[2].xyz;
8245
return m;
8246
}
8247
8248
float diffuse(vec3 normal) {
8249
vec3 n2 = normal * normal * vec3(.6, .25, .8);
8250
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
8251
}
8252
struct Vertex {
8253
vec3 pos;
8254
vec2 texCoords;
8255
vec3 normal;
8256
};
8257
8258
struct BlockFrag {
8259
vec2 texCoords;
8260
vec4 color;
8261
float diffuse;
8262
vec2 light;
8263
};
8264
8265
#if defined(FRAGMENT_SHADER)
8266
void fragment(BlockFrag r) {
8267
vec4 tex = FLWBlockTexture(r.texCoords);
8268
8269
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
8270
8271
FLWFinalizeColor(color);
8272
}
8273
#endif
8274
#define PI 3.1415926538
8275
8276
8277
8278
8279
struct Rotating {
8280
vec2 light;
8281
vec4 color;
8282
vec3 pos;
8283
float speed;
8284
float offset;
8285
vec3 axis;
8286
};
8287
8288
8289
8290
8291
mat4 kineticRotation(float offset, float speed, vec3 axis) {
8292
float degrees = offset + uTime * speed * 3./10.;
8293
float angle = fract(degrees / 360.) * PI * 2.;
8294
8295
return rotate(axis, angle);
8296
}
8297
8298
#if defined(VERTEX_SHADER)
8299
BlockFrag vertex(Vertex v, Rotating instance) {
8300
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
8301
8302
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
8303
worldPos += vec4(instance.pos + .5, 0.);
8304
8305
vec3 norm = modelToNormal(spin) * v.normal;
8306
8307
FLWFinalizeWorldPos(worldPos);
8308
FLWFinalizeNormal(norm);
8309
8310
BlockFrag b;
8311
b.diffuse = diffuse(norm);
8312
b.texCoords = v.texCoords;
8313
b.light = instance.light;
8314
8315
#if defined(DEBUG_RAINBOW)
8316
b.color = instance.color;
8317
#elif defined(DEBUG_NORMAL)
8318
b.color = vec4(norm, 1.);
8319
#else
8320
b.color = vec4(1.);
8321
#endif
8322
8323
return b;
8324
}
8325
#endif
8326
8327
in vec2 v2f_texCoords;
8328
in vec4 v2f_color;
8329
in float v2f_diffuse;
8330
in vec2 v2f_light;
8331
void main() {
8332
BlockFrag o;
8333
o.texCoords = v2f_texCoords;
8334
o.color = v2f_color;
8335
o.diffuse = v2f_diffuse;
8336
o.light = v2f_light;
8337
fragment(o);
8338
}
8339
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
8340
8341
[17:17:49] [Render thread/ERROR]: #version 150
8342
#extension GL_ARB_conservative_depth : enable
8343
#define VERTEX_SHADER
8344
#define DEBUG_RAINBOW
8345
#if defined(VERTEX_SHADER)
8346
out float FragDistance;
8347
#elif defined(FRAGMENT_SHADER)
8348
in float FragDistance;
8349
#endif
8350
uniform vec4 uFogColor;
8351
uniform vec2 uFogRange;
8352
8353
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
8354
float distXZ = length(worldPos.xz - cameraPos.xz);
8355
float distY = abs(worldPos.y - cameraPos.y);
8356
return max(distXZ, distY);
8357
}
8358
8359
float cylindrical_distance(vec3 worldPos) {
8360
float distXZ = length(worldPos.xz);
8361
float distY = abs(worldPos.y);
8362
return max(distXZ, distY);
8363
}
8364
8365
float FLWFogFactor() {
8366
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
8367
}
8368
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
8369
vec2 shiftLight(vec2 lm) {
8370
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
8371
}
8372
8373
8374
uniform float uTime;
8375
uniform mat4 uViewProjection;
8376
uniform vec3 uCameraPos;
8377
8378
uniform vec2 uTextureScale;
8379
uniform sampler2D uBlockAtlas;
8380
uniform sampler2D uLightMap;
8381
8382
uniform vec2 uWindowSize;
8383
8384
void FLWFinalizeNormal(inout vec3 normal) {
8385
// noop
8386
}
8387
8388
#if defined(VERTEX_SHADER)
8389
void FLWFinalizeWorldPos(inout vec4 worldPos) {
8390
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
8391
8392
gl_Position = uViewProjection * worldPos;
8393
}
8394
8395
#elif defined(FRAGMENT_SHADER)
8396
8397
8398
#define ALPHA_DISCARD 0.1
8399
// optimize discard usage
8400
#if defined(ALPHA_DISCARD)
8401
#if defined(GL_ARB_conservative_depth)
8402
layout (depth_greater) out float gl_FragDepth;
8403
#endif
8404
#endif
8405
out vec4 fragColor;
8406
8407
vec4 FLWBlockTexture(vec2 texCoords) {
8408
return texture(uBlockAtlas, texCoords);
8409
}
8410
8411
void FLWFinalizeColor(vec4 color) {
8412
float a = color.a;
8413
float fog = clamp(FLWFogFactor(), 0., 1.);
8414
8415
color = mix(uFogColor, color, fog);
8416
color.a = a;
8417
8418
#if defined(ALPHA_DISCARD)
8419
if (color.a < ALPHA_DISCARD) {
8420
discard;
8421
}
8422
#endif
8423
8424
fragColor = color;
8425
}
8426
8427
vec4 FLWLight(vec2 lightCoords) {
8428
return texture(uLightMap, shiftLight(lightCoords));
8429
}
8430
#endif
8431
8432
8433
mat4 rotate(vec3 axis, float angle) {
8434
float s = sin(angle);
8435
float c = cos(angle);
8436
float oc = 1. - c;
8437
8438
vec3 sa = axis * s;
8439
8440
mat4 mr = mat4(1.);
8441
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
8442
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
8443
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
8444
8445
return mr;
8446
}
8447
8448
mat4 rotation(vec3 rot) {
8449
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
8450
}
8451
8452
mat3 modelToNormal(mat4 mat) {
8453
// Discard the edges. This won't be accurate for scaled or skewed matrices,
8454
// but we don't have to work with those often.
8455
mat3 m;
8456
m[0] = mat[0].xyz;
8457
m[1] = mat[1].xyz;
8458
m[2] = mat[2].xyz;
8459
return m;
8460
}
8461
8462
float diffuse(vec3 normal) {
8463
vec3 n2 = normal * normal * vec3(.6, .25, .8);
8464
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
8465
}
8466
struct Vertex {
8467
vec3 pos;
8468
vec2 texCoords;
8469
vec3 normal;
8470
};
8471
8472
struct BlockFrag {
8473
vec2 texCoords;
8474
vec4 color;
8475
float diffuse;
8476
vec2 light;
8477
};
8478
8479
#if defined(FRAGMENT_SHADER)
8480
void fragment(BlockFrag r) {
8481
vec4 tex = FLWBlockTexture(r.texCoords);
8482
8483
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
8484
8485
FLWFinalizeColor(color);
8486
}
8487
#endif
8488
#define PI 3.1415926538
8489
8490
8491
8492
8493
struct Rotating {
8494
vec2 light;
8495
vec4 color;
8496
vec3 pos;
8497
float speed;
8498
float offset;
8499
vec3 axis;
8500
};
8501
8502
8503
8504
8505
mat4 kineticRotation(float offset, float speed, vec3 axis) {
8506
float degrees = offset + uTime * speed * 3./10.;
8507
float angle = fract(degrees / 360.) * PI * 2.;
8508
8509
return rotate(axis, angle);
8510
}
8511
8512
#if defined(VERTEX_SHADER)
8513
BlockFrag vertex(Vertex v, Rotating instance) {
8514
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
8515
8516
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
8517
worldPos += vec4(instance.pos + .5, 0.);
8518
8519
vec3 norm = modelToNormal(spin) * v.normal;
8520
8521
FLWFinalizeWorldPos(worldPos);
8522
FLWFinalizeNormal(norm);
8523
8524
BlockFrag b;
8525
b.diffuse = diffuse(norm);
8526
b.texCoords = v.texCoords;
8527
b.light = instance.light;
8528
8529
#if defined(DEBUG_RAINBOW)
8530
b.color = instance.color;
8531
#elif defined(DEBUG_NORMAL)
8532
b.color = vec4(norm, 1.);
8533
#else
8534
b.color = vec4(1.);
8535
#endif
8536
8537
return b;
8538
}
8539
#endif
8540
8541
in vec3 a_v_pos;
8542
in vec2 a_v_texCoords;
8543
in vec3 a_v_normal;
8544
in vec2 a_i_light;
8545
in vec4 a_i_color;
8546
in vec3 a_i_pos;
8547
in float a_i_speed;
8548
in float a_i_offset;
8549
in vec3 a_i_axis;
8550
out vec2 v2f_texCoords;
8551
out vec4 v2f_color;
8552
out float v2f_diffuse;
8553
out vec2 v2f_light;
8554
void main() {
8555
Vertex v;
8556
v.pos = a_v_pos;
8557
v.texCoords = a_v_texCoords;
8558
v.normal = a_v_normal;
8559
Rotating i;
8560
i.light = a_i_light;
8561
i.color = a_i_color;
8562
i.pos = a_i_pos;
8563
i.speed = a_i_speed;
8564
i.offset = a_i_offset;
8565
i.axis = a_i_axis;
8566
BlockFrag o = vertex(v, i);
8567
v2f_texCoords = o.texCoords;
8568
v2f_color = o.color;
8569
v2f_diffuse = o.diffuse;
8570
v2f_light = o.light;
8571
}
8572
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
8573
8574
[17:17:49] [Render thread/ERROR]: #version 150
8575
#extension GL_ARB_conservative_depth : enable
8576
#define FRAGMENT_SHADER
8577
#define DEBUG_RAINBOW
8578
#if defined(VERTEX_SHADER)
8579
out float FragDistance;
8580
#elif defined(FRAGMENT_SHADER)
8581
in float FragDistance;
8582
#endif
8583
uniform vec4 uFogColor;
8584
uniform vec2 uFogRange;
8585
8586
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
8587
float distXZ = length(worldPos.xz - cameraPos.xz);
8588
float distY = abs(worldPos.y - cameraPos.y);
8589
return max(distXZ, distY);
8590
}
8591
8592
float cylindrical_distance(vec3 worldPos) {
8593
float distXZ = length(worldPos.xz);
8594
float distY = abs(worldPos.y);
8595
return max(distXZ, distY);
8596
}
8597
8598
float FLWFogFactor() {
8599
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
8600
}
8601
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
8602
vec2 shiftLight(vec2 lm) {
8603
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
8604
}
8605
8606
8607
uniform float uTime;
8608
uniform mat4 uViewProjection;
8609
uniform vec3 uCameraPos;
8610
8611
uniform vec2 uTextureScale;
8612
uniform sampler2D uBlockAtlas;
8613
uniform sampler2D uLightMap;
8614
8615
uniform vec2 uWindowSize;
8616
8617
void FLWFinalizeNormal(inout vec3 normal) {
8618
// noop
8619
}
8620
8621
#if defined(VERTEX_SHADER)
8622
void FLWFinalizeWorldPos(inout vec4 worldPos) {
8623
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
8624
8625
gl_Position = uViewProjection * worldPos;
8626
}
8627
8628
#elif defined(FRAGMENT_SHADER)
8629
8630
8631
#define ALPHA_DISCARD 0.1
8632
// optimize discard usage
8633
#if defined(ALPHA_DISCARD)
8634
#if defined(GL_ARB_conservative_depth)
8635
layout (depth_greater) out float gl_FragDepth;
8636
#endif
8637
#endif
8638
out vec4 fragColor;
8639
8640
vec4 FLWBlockTexture(vec2 texCoords) {
8641
return texture(uBlockAtlas, texCoords);
8642
}
8643
8644
void FLWFinalizeColor(vec4 color) {
8645
float a = color.a;
8646
float fog = clamp(FLWFogFactor(), 0., 1.);
8647
8648
color = mix(uFogColor, color, fog);
8649
color.a = a;
8650
8651
#if defined(ALPHA_DISCARD)
8652
if (color.a < ALPHA_DISCARD) {
8653
discard;
8654
}
8655
#endif
8656
8657
fragColor = color;
8658
}
8659
8660
vec4 FLWLight(vec2 lightCoords) {
8661
return texture(uLightMap, shiftLight(lightCoords));
8662
}
8663
#endif
8664
8665
8666
mat4 rotate(vec3 axis, float angle) {
8667
float s = sin(angle);
8668
float c = cos(angle);
8669
float oc = 1. - c;
8670
8671
vec3 sa = axis * s;
8672
8673
mat4 mr = mat4(1.);
8674
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
8675
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
8676
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
8677
8678
return mr;
8679
}
8680
8681
mat4 rotation(vec3 rot) {
8682
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
8683
}
8684
8685
mat3 modelToNormal(mat4 mat) {
8686
// Discard the edges. This won't be accurate for scaled or skewed matrices,
8687
// but we don't have to work with those often.
8688
mat3 m;
8689
m[0] = mat[0].xyz;
8690
m[1] = mat[1].xyz;
8691
m[2] = mat[2].xyz;
8692
return m;
8693
}
8694
8695
float diffuse(vec3 normal) {
8696
vec3 n2 = normal * normal * vec3(.6, .25, .8);
8697
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
8698
}
8699
struct Vertex {
8700
vec3 pos;
8701
vec2 texCoords;
8702
vec3 normal;
8703
};
8704
8705
struct BlockFrag {
8706
vec2 texCoords;
8707
vec4 color;
8708
float diffuse;
8709
vec2 light;
8710
};
8711
8712
#if defined(FRAGMENT_SHADER)
8713
void fragment(BlockFrag r) {
8714
vec4 tex = FLWBlockTexture(r.texCoords);
8715
8716
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
8717
8718
FLWFinalizeColor(color);
8719
}
8720
#endif
8721
#define PI 3.1415926538
8722
8723
8724
8725
8726
struct Rotating {
8727
vec2 light;
8728
vec4 color;
8729
vec3 pos;
8730
float speed;
8731
float offset;
8732
vec3 axis;
8733
};
8734
8735
8736
8737
8738
mat4 kineticRotation(float offset, float speed, vec3 axis) {
8739
float degrees = offset + uTime * speed * 3./10.;
8740
float angle = fract(degrees / 360.) * PI * 2.;
8741
8742
return rotate(axis, angle);
8743
}
8744
8745
#if defined(VERTEX_SHADER)
8746
BlockFrag vertex(Vertex v, Rotating instance) {
8747
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
8748
8749
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
8750
worldPos += vec4(instance.pos + .5, 0.);
8751
8752
vec3 norm = modelToNormal(spin) * v.normal;
8753
8754
FLWFinalizeWorldPos(worldPos);
8755
FLWFinalizeNormal(norm);
8756
8757
BlockFrag b;
8758
b.diffuse = diffuse(norm);
8759
b.texCoords = v.texCoords;
8760
b.light = instance.light;
8761
8762
#if defined(DEBUG_RAINBOW)
8763
b.color = instance.color;
8764
#elif defined(DEBUG_NORMAL)
8765
b.color = vec4(norm, 1.);
8766
#else
8767
b.color = vec4(1.);
8768
#endif
8769
8770
return b;
8771
}
8772
#endif
8773
8774
in vec2 v2f_texCoords;
8775
in vec4 v2f_color;
8776
in float v2f_diffuse;
8777
in vec2 v2f_light;
8778
void main() {
8779
BlockFrag o;
8780
o.texCoords = v2f_texCoords;
8781
o.color = v2f_color;
8782
o.diffuse = v2f_diffuse;
8783
o.light = v2f_light;
8784
fragment(o);
8785
}
8786
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
8787
8788
[17:17:49] [Render thread/ERROR]: #version 150
8789
#extension GL_ARB_conservative_depth : enable
8790
#define VERTEX_SHADER
8791
#define DEBUG_NORMAL
8792
#if defined(VERTEX_SHADER)
8793
out float FragDistance;
8794
#elif defined(FRAGMENT_SHADER)
8795
in float FragDistance;
8796
#endif
8797
uniform vec4 uFogColor;
8798
uniform vec2 uFogRange;
8799
8800
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
8801
float distXZ = length(worldPos.xz - cameraPos.xz);
8802
float distY = abs(worldPos.y - cameraPos.y);
8803
return max(distXZ, distY);
8804
}
8805
8806
float cylindrical_distance(vec3 worldPos) {
8807
float distXZ = length(worldPos.xz);
8808
float distY = abs(worldPos.y);
8809
return max(distXZ, distY);
8810
}
8811
8812
float FLWFogFactor() {
8813
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
8814
}
8815
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
8816
vec2 shiftLight(vec2 lm) {
8817
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
8818
}
8819
8820
8821
uniform float uTime;
8822
uniform mat4 uViewProjection;
8823
uniform vec3 uCameraPos;
8824
8825
uniform vec2 uTextureScale;
8826
uniform sampler2D uBlockAtlas;
8827
uniform sampler2D uLightMap;
8828
8829
uniform vec2 uWindowSize;
8830
8831
void FLWFinalizeNormal(inout vec3 normal) {
8832
// noop
8833
}
8834
8835
#if defined(VERTEX_SHADER)
8836
void FLWFinalizeWorldPos(inout vec4 worldPos) {
8837
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
8838
8839
gl_Position = uViewProjection * worldPos;
8840
}
8841
8842
#elif defined(FRAGMENT_SHADER)
8843
8844
8845
#define ALPHA_DISCARD 0.1
8846
// optimize discard usage
8847
#if defined(ALPHA_DISCARD)
8848
#if defined(GL_ARB_conservative_depth)
8849
layout (depth_greater) out float gl_FragDepth;
8850
#endif
8851
#endif
8852
out vec4 fragColor;
8853
8854
vec4 FLWBlockTexture(vec2 texCoords) {
8855
return texture(uBlockAtlas, texCoords);
8856
}
8857
8858
void FLWFinalizeColor(vec4 color) {
8859
float a = color.a;
8860
float fog = clamp(FLWFogFactor(), 0., 1.);
8861
8862
color = mix(uFogColor, color, fog);
8863
color.a = a;
8864
8865
#if defined(ALPHA_DISCARD)
8866
if (color.a < ALPHA_DISCARD) {
8867
discard;
8868
}
8869
#endif
8870
8871
fragColor = color;
8872
}
8873
8874
vec4 FLWLight(vec2 lightCoords) {
8875
return texture(uLightMap, shiftLight(lightCoords));
8876
}
8877
#endif
8878
8879
8880
mat4 rotate(vec3 axis, float angle) {
8881
float s = sin(angle);
8882
float c = cos(angle);
8883
float oc = 1. - c;
8884
8885
vec3 sa = axis * s;
8886
8887
mat4 mr = mat4(1.);
8888
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
8889
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
8890
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
8891
8892
return mr;
8893
}
8894
8895
mat4 rotation(vec3 rot) {
8896
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
8897
}
8898
8899
mat3 modelToNormal(mat4 mat) {
8900
// Discard the edges. This won't be accurate for scaled or skewed matrices,
8901
// but we don't have to work with those often.
8902
mat3 m;
8903
m[0] = mat[0].xyz;
8904
m[1] = mat[1].xyz;
8905
m[2] = mat[2].xyz;
8906
return m;
8907
}
8908
8909
float diffuse(vec3 normal) {
8910
vec3 n2 = normal * normal * vec3(.6, .25, .8);
8911
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
8912
}
8913
struct Vertex {
8914
vec3 pos;
8915
vec2 texCoords;
8916
vec3 normal;
8917
};
8918
8919
struct BlockFrag {
8920
vec2 texCoords;
8921
vec4 color;
8922
float diffuse;
8923
vec2 light;
8924
};
8925
8926
#if defined(FRAGMENT_SHADER)
8927
void fragment(BlockFrag r) {
8928
vec4 tex = FLWBlockTexture(r.texCoords);
8929
8930
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
8931
8932
FLWFinalizeColor(color);
8933
}
8934
#endif
8935
#define PI 3.1415926538
8936
8937
8938
8939
8940
struct Rotating {
8941
vec2 light;
8942
vec4 color;
8943
vec3 pos;
8944
float speed;
8945
float offset;
8946
vec3 axis;
8947
};
8948
8949
8950
8951
8952
mat4 kineticRotation(float offset, float speed, vec3 axis) {
8953
float degrees = offset + uTime * speed * 3./10.;
8954
float angle = fract(degrees / 360.) * PI * 2.;
8955
8956
return rotate(axis, angle);
8957
}
8958
8959
#if defined(VERTEX_SHADER)
8960
BlockFrag vertex(Vertex v, Rotating instance) {
8961
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
8962
8963
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
8964
worldPos += vec4(instance.pos + .5, 0.);
8965
8966
vec3 norm = modelToNormal(spin) * v.normal;
8967
8968
FLWFinalizeWorldPos(worldPos);
8969
FLWFinalizeNormal(norm);
8970
8971
BlockFrag b;
8972
b.diffuse = diffuse(norm);
8973
b.texCoords = v.texCoords;
8974
b.light = instance.light;
8975
8976
#if defined(DEBUG_RAINBOW)
8977
b.color = instance.color;
8978
#elif defined(DEBUG_NORMAL)
8979
b.color = vec4(norm, 1.);
8980
#else
8981
b.color = vec4(1.);
8982
#endif
8983
8984
return b;
8985
}
8986
#endif
8987
8988
in vec3 a_v_pos;
8989
in vec2 a_v_texCoords;
8990
in vec3 a_v_normal;
8991
in vec2 a_i_light;
8992
in vec4 a_i_color;
8993
in vec3 a_i_pos;
8994
in float a_i_speed;
8995
in float a_i_offset;
8996
in vec3 a_i_axis;
8997
out vec2 v2f_texCoords;
8998
out vec4 v2f_color;
8999
out float v2f_diffuse;
9000
out vec2 v2f_light;
9001
void main() {
9002
Vertex v;
9003
v.pos = a_v_pos;
9004
v.texCoords = a_v_texCoords;
9005
v.normal = a_v_normal;
9006
Rotating i;
9007
i.light = a_i_light;
9008
i.color = a_i_color;
9009
i.pos = a_i_pos;
9010
i.speed = a_i_speed;
9011
i.offset = a_i_offset;
9012
i.axis = a_i_axis;
9013
BlockFrag o = vertex(v, i);
9014
v2f_texCoords = o.texCoords;
9015
v2f_color = o.color;
9016
v2f_diffuse = o.diffuse;
9017
v2f_light = o.light;
9018
}
9019
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
9020
9021
[17:17:49] [Render thread/ERROR]: #version 150
9022
#extension GL_ARB_conservative_depth : enable
9023
#define FRAGMENT_SHADER
9024
#define DEBUG_NORMAL
9025
#if defined(VERTEX_SHADER)
9026
out float FragDistance;
9027
#elif defined(FRAGMENT_SHADER)
9028
in float FragDistance;
9029
#endif
9030
uniform vec4 uFogColor;
9031
uniform vec2 uFogRange;
9032
9033
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
9034
float distXZ = length(worldPos.xz - cameraPos.xz);
9035
float distY = abs(worldPos.y - cameraPos.y);
9036
return max(distXZ, distY);
9037
}
9038
9039
float cylindrical_distance(vec3 worldPos) {
9040
float distXZ = length(worldPos.xz);
9041
float distY = abs(worldPos.y);
9042
return max(distXZ, distY);
9043
}
9044
9045
float FLWFogFactor() {
9046
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
9047
}
9048
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
9049
vec2 shiftLight(vec2 lm) {
9050
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
9051
}
9052
9053
9054
uniform float uTime;
9055
uniform mat4 uViewProjection;
9056
uniform vec3 uCameraPos;
9057
9058
uniform vec2 uTextureScale;
9059
uniform sampler2D uBlockAtlas;
9060
uniform sampler2D uLightMap;
9061
9062
uniform vec2 uWindowSize;
9063
9064
void FLWFinalizeNormal(inout vec3 normal) {
9065
// noop
9066
}
9067
9068
#if defined(VERTEX_SHADER)
9069
void FLWFinalizeWorldPos(inout vec4 worldPos) {
9070
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
9071
9072
gl_Position = uViewProjection * worldPos;
9073
}
9074
9075
#elif defined(FRAGMENT_SHADER)
9076
9077
9078
#define ALPHA_DISCARD 0.1
9079
// optimize discard usage
9080
#if defined(ALPHA_DISCARD)
9081
#if defined(GL_ARB_conservative_depth)
9082
layout (depth_greater) out float gl_FragDepth;
9083
#endif
9084
#endif
9085
out vec4 fragColor;
9086
9087
vec4 FLWBlockTexture(vec2 texCoords) {
9088
return texture(uBlockAtlas, texCoords);
9089
}
9090
9091
void FLWFinalizeColor(vec4 color) {
9092
float a = color.a;
9093
float fog = clamp(FLWFogFactor(), 0., 1.);
9094
9095
color = mix(uFogColor, color, fog);
9096
color.a = a;
9097
9098
#if defined(ALPHA_DISCARD)
9099
if (color.a < ALPHA_DISCARD) {
9100
discard;
9101
}
9102
#endif
9103
9104
fragColor = color;
9105
}
9106
9107
vec4 FLWLight(vec2 lightCoords) {
9108
return texture(uLightMap, shiftLight(lightCoords));
9109
}
9110
#endif
9111
9112
9113
mat4 rotate(vec3 axis, float angle) {
9114
float s = sin(angle);
9115
float c = cos(angle);
9116
float oc = 1. - c;
9117
9118
vec3 sa = axis * s;
9119
9120
mat4 mr = mat4(1.);
9121
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
9122
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
9123
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
9124
9125
return mr;
9126
}
9127
9128
mat4 rotation(vec3 rot) {
9129
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
9130
}
9131
9132
mat3 modelToNormal(mat4 mat) {
9133
// Discard the edges. This won't be accurate for scaled or skewed matrices,
9134
// but we don't have to work with those often.
9135
mat3 m;
9136
m[0] = mat[0].xyz;
9137
m[1] = mat[1].xyz;
9138
m[2] = mat[2].xyz;
9139
return m;
9140
}
9141
9142
float diffuse(vec3 normal) {
9143
vec3 n2 = normal * normal * vec3(.6, .25, .8);
9144
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
9145
}
9146
struct Vertex {
9147
vec3 pos;
9148
vec2 texCoords;
9149
vec3 normal;
9150
};
9151
9152
struct BlockFrag {
9153
vec2 texCoords;
9154
vec4 color;
9155
float diffuse;
9156
vec2 light;
9157
};
9158
9159
#if defined(FRAGMENT_SHADER)
9160
void fragment(BlockFrag r) {
9161
vec4 tex = FLWBlockTexture(r.texCoords);
9162
9163
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
9164
9165
FLWFinalizeColor(color);
9166
}
9167
#endif
9168
#define PI 3.1415926538
9169
9170
9171
9172
9173
struct Rotating {
9174
vec2 light;
9175
vec4 color;
9176
vec3 pos;
9177
float speed;
9178
float offset;
9179
vec3 axis;
9180
};
9181
9182
9183
9184
9185
mat4 kineticRotation(float offset, float speed, vec3 axis) {
9186
float degrees = offset + uTime * speed * 3./10.;
9187
float angle = fract(degrees / 360.) * PI * 2.;
9188
9189
return rotate(axis, angle);
9190
}
9191
9192
#if defined(VERTEX_SHADER)
9193
BlockFrag vertex(Vertex v, Rotating instance) {
9194
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
9195
9196
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
9197
worldPos += vec4(instance.pos + .5, 0.);
9198
9199
vec3 norm = modelToNormal(spin) * v.normal;
9200
9201
FLWFinalizeWorldPos(worldPos);
9202
FLWFinalizeNormal(norm);
9203
9204
BlockFrag b;
9205
b.diffuse = diffuse(norm);
9206
b.texCoords = v.texCoords;
9207
b.light = instance.light;
9208
9209
#if defined(DEBUG_RAINBOW)
9210
b.color = instance.color;
9211
#elif defined(DEBUG_NORMAL)
9212
b.color = vec4(norm, 1.);
9213
#else
9214
b.color = vec4(1.);
9215
#endif
9216
9217
return b;
9218
}
9219
#endif
9220
9221
in vec2 v2f_texCoords;
9222
in vec4 v2f_color;
9223
in float v2f_diffuse;
9224
in vec2 v2f_light;
9225
void main() {
9226
BlockFrag o;
9227
o.texCoords = v2f_texCoords;
9228
o.color = v2f_color;
9229
o.diffuse = v2f_diffuse;
9230
o.light = v2f_light;
9231
fragment(o);
9232
}
9233
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
9234
9235
[17:17:49] [Render thread/ERROR]: #version 150
9236
#extension GL_ARB_conservative_depth : enable
9237
#define VERTEX_SHADER
9238
#if defined(VERTEX_SHADER)
9239
out float FragDistance;
9240
#elif defined(FRAGMENT_SHADER)
9241
in float FragDistance;
9242
#endif
9243
uniform vec4 uFogColor;
9244
uniform vec2 uFogRange;
9245
9246
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
9247
float distXZ = length(worldPos.xz - cameraPos.xz);
9248
float distY = abs(worldPos.y - cameraPos.y);
9249
return max(distXZ, distY);
9250
}
9251
9252
float cylindrical_distance(vec3 worldPos) {
9253
float distXZ = length(worldPos.xz);
9254
float distY = abs(worldPos.y);
9255
return max(distXZ, distY);
9256
}
9257
9258
float FLWFogFactor() {
9259
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
9260
}
9261
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
9262
vec2 shiftLight(vec2 lm) {
9263
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
9264
}
9265
9266
9267
uniform float uTime;
9268
uniform mat4 uViewProjection;
9269
uniform vec3 uCameraPos;
9270
9271
uniform vec2 uTextureScale;
9272
uniform sampler2D uBlockAtlas;
9273
uniform sampler2D uLightMap;
9274
9275
uniform vec2 uWindowSize;
9276
9277
void FLWFinalizeNormal(inout vec3 normal) {
9278
// noop
9279
}
9280
9281
#if defined(VERTEX_SHADER)
9282
void FLWFinalizeWorldPos(inout vec4 worldPos) {
9283
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
9284
9285
gl_Position = uViewProjection * worldPos;
9286
}
9287
9288
#elif defined(FRAGMENT_SHADER)
9289
9290
9291
#define ALPHA_DISCARD 0.1
9292
// optimize discard usage
9293
#if defined(ALPHA_DISCARD)
9294
#if defined(GL_ARB_conservative_depth)
9295
layout (depth_greater) out float gl_FragDepth;
9296
#endif
9297
#endif
9298
out vec4 fragColor;
9299
9300
vec4 FLWBlockTexture(vec2 texCoords) {
9301
return texture(uBlockAtlas, texCoords);
9302
}
9303
9304
void FLWFinalizeColor(vec4 color) {
9305
float a = color.a;
9306
float fog = clamp(FLWFogFactor(), 0., 1.);
9307
9308
color = mix(uFogColor, color, fog);
9309
color.a = a;
9310
9311
#if defined(ALPHA_DISCARD)
9312
if (color.a < ALPHA_DISCARD) {
9313
discard;
9314
}
9315
#endif
9316
9317
fragColor = color;
9318
}
9319
9320
vec4 FLWLight(vec2 lightCoords) {
9321
return texture(uLightMap, shiftLight(lightCoords));
9322
}
9323
#endif
9324
9325
9326
mat4 rotate(vec3 axis, float angle) {
9327
float s = sin(angle);
9328
float c = cos(angle);
9329
float oc = 1. - c;
9330
9331
vec3 sa = axis * s;
9332
9333
mat4 mr = mat4(1.);
9334
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
9335
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
9336
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
9337
9338
return mr;
9339
}
9340
9341
mat4 rotation(vec3 rot) {
9342
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
9343
}
9344
9345
mat3 modelToNormal(mat4 mat) {
9346
// Discard the edges. This won't be accurate for scaled or skewed matrices,
9347
// but we don't have to work with those often.
9348
mat3 m;
9349
m[0] = mat[0].xyz;
9350
m[1] = mat[1].xyz;
9351
m[2] = mat[2].xyz;
9352
return m;
9353
}
9354
9355
#define PIOVER2 1.5707963268
9356
9357
vec4 quat(vec3 axis, float angle) {
9358
float halfAngle = angle * PIOVER2 / 180.0;
9359
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
9360
return vec4(axis.xyz * cs.y, cs.x);
9361
}
9362
9363
vec4 quatMult(vec4 q1, vec4 q2) {
9364
// disgustingly vectorized quaternion multiplication
9365
vec4 a = q1.w * q2.xyzw;
9366
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
9367
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
9368
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
9369
9370
return a + b + c + d;
9371
}
9372
9373
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
9374
vec3 i = q.xyz;
9375
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
9376
}
9377
9378
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
9379
return rotateVertexByQuat(v, quat(axis, angle));
9380
}
9381
9382
float diffuse(vec3 normal) {
9383
vec3 n2 = normal * normal * vec3(.6, .25, .8);
9384
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
9385
}
9386
struct Vertex {
9387
vec3 pos;
9388
vec2 texCoords;
9389
vec3 normal;
9390
};
9391
9392
struct BlockFrag {
9393
vec2 texCoords;
9394
vec4 color;
9395
float diffuse;
9396
vec2 light;
9397
};
9398
9399
#if defined(FRAGMENT_SHADER)
9400
void fragment(BlockFrag r) {
9401
vec4 tex = FLWBlockTexture(r.texCoords);
9402
9403
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
9404
9405
FLWFinalizeColor(color);
9406
}
9407
#endif
9408
#define PI 3.1415926538
9409
9410
9411
9412
9413
9414
struct Actor {
9415
vec3 pos;
9416
vec2 light;
9417
float offset;
9418
vec3 axis;
9419
vec4 rotation;
9420
vec3 rotationCenter;
9421
float speed;
9422
};
9423
9424
9425
9426
9427
#if defined(VERTEX_SHADER)
9428
BlockFrag vertex(Vertex v, Actor instance) {
9429
float degrees = instance.offset + uTime * instance.speed / 20.;
9430
//float angle = fract(degrees / 360.) * PI * 2.;
9431
9432
vec4 kineticRot = quat(instance.axis, degrees);
9433
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
9434
9435
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
9436
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
9437
9438
FLWFinalizeWorldPos(worldPos);
9439
FLWFinalizeNormal(norm);
9440
9441
BlockFrag b;
9442
b.diffuse = diffuse(norm);
9443
b.texCoords = v.texCoords;
9444
b.light = instance.light;
9445
9446
#if defined(DEBUG_NORMAL)
9447
b.color = vec4(norm, 1.);
9448
#else
9449
b.color = vec4(1.);
9450
#endif
9451
9452
return b;
9453
}
9454
#endif
9455
9456
in vec3 a_v_pos;
9457
in vec2 a_v_texCoords;
9458
in vec3 a_v_normal;
9459
in vec3 a_i_pos;
9460
in vec2 a_i_light;
9461
in float a_i_offset;
9462
in vec3 a_i_axis;
9463
in vec4 a_i_rotation;
9464
in vec3 a_i_rotationCenter;
9465
in float a_i_speed;
9466
out vec2 v2f_texCoords;
9467
out vec4 v2f_color;
9468
out float v2f_diffuse;
9469
out vec2 v2f_light;
9470
void main() {
9471
Vertex v;
9472
v.pos = a_v_pos;
9473
v.texCoords = a_v_texCoords;
9474
v.normal = a_v_normal;
9475
Actor i;
9476
i.pos = a_i_pos;
9477
i.light = a_i_light;
9478
i.offset = a_i_offset;
9479
i.axis = a_i_axis;
9480
i.rotation = a_i_rotation;
9481
i.rotationCenter = a_i_rotationCenter;
9482
i.speed = a_i_speed;
9483
BlockFrag o = vertex(v, i);
9484
v2f_texCoords = o.texCoords;
9485
v2f_color = o.color;
9486
v2f_diffuse = o.diffuse;
9487
v2f_light = o.light;
9488
}
9489
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
9490
9491
[17:17:49] [Render thread/ERROR]: #version 150
9492
#extension GL_ARB_conservative_depth : enable
9493
#define FRAGMENT_SHADER
9494
#if defined(VERTEX_SHADER)
9495
out float FragDistance;
9496
#elif defined(FRAGMENT_SHADER)
9497
in float FragDistance;
9498
#endif
9499
uniform vec4 uFogColor;
9500
uniform vec2 uFogRange;
9501
9502
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
9503
float distXZ = length(worldPos.xz - cameraPos.xz);
9504
float distY = abs(worldPos.y - cameraPos.y);
9505
return max(distXZ, distY);
9506
}
9507
9508
float cylindrical_distance(vec3 worldPos) {
9509
float distXZ = length(worldPos.xz);
9510
float distY = abs(worldPos.y);
9511
return max(distXZ, distY);
9512
}
9513
9514
float FLWFogFactor() {
9515
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
9516
}
9517
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
9518
vec2 shiftLight(vec2 lm) {
9519
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
9520
}
9521
9522
9523
uniform float uTime;
9524
uniform mat4 uViewProjection;
9525
uniform vec3 uCameraPos;
9526
9527
uniform vec2 uTextureScale;
9528
uniform sampler2D uBlockAtlas;
9529
uniform sampler2D uLightMap;
9530
9531
uniform vec2 uWindowSize;
9532
9533
void FLWFinalizeNormal(inout vec3 normal) {
9534
// noop
9535
}
9536
9537
#if defined(VERTEX_SHADER)
9538
void FLWFinalizeWorldPos(inout vec4 worldPos) {
9539
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
9540
9541
gl_Position = uViewProjection * worldPos;
9542
}
9543
9544
#elif defined(FRAGMENT_SHADER)
9545
9546
9547
#define ALPHA_DISCARD 0.1
9548
// optimize discard usage
9549
#if defined(ALPHA_DISCARD)
9550
#if defined(GL_ARB_conservative_depth)
9551
layout (depth_greater) out float gl_FragDepth;
9552
#endif
9553
#endif
9554
out vec4 fragColor;
9555
9556
vec4 FLWBlockTexture(vec2 texCoords) {
9557
return texture(uBlockAtlas, texCoords);
9558
}
9559
9560
void FLWFinalizeColor(vec4 color) {
9561
float a = color.a;
9562
float fog = clamp(FLWFogFactor(), 0., 1.);
9563
9564
color = mix(uFogColor, color, fog);
9565
color.a = a;
9566
9567
#if defined(ALPHA_DISCARD)
9568
if (color.a < ALPHA_DISCARD) {
9569
discard;
9570
}
9571
#endif
9572
9573
fragColor = color;
9574
}
9575
9576
vec4 FLWLight(vec2 lightCoords) {
9577
return texture(uLightMap, shiftLight(lightCoords));
9578
}
9579
#endif
9580
9581
9582
mat4 rotate(vec3 axis, float angle) {
9583
float s = sin(angle);
9584
float c = cos(angle);
9585
float oc = 1. - c;
9586
9587
vec3 sa = axis * s;
9588
9589
mat4 mr = mat4(1.);
9590
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
9591
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
9592
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
9593
9594
return mr;
9595
}
9596
9597
mat4 rotation(vec3 rot) {
9598
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
9599
}
9600
9601
mat3 modelToNormal(mat4 mat) {
9602
// Discard the edges. This won't be accurate for scaled or skewed matrices,
9603
// but we don't have to work with those often.
9604
mat3 m;
9605
m[0] = mat[0].xyz;
9606
m[1] = mat[1].xyz;
9607
m[2] = mat[2].xyz;
9608
return m;
9609
}
9610
9611
#define PIOVER2 1.5707963268
9612
9613
vec4 quat(vec3 axis, float angle) {
9614
float halfAngle = angle * PIOVER2 / 180.0;
9615
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
9616
return vec4(axis.xyz * cs.y, cs.x);
9617
}
9618
9619
vec4 quatMult(vec4 q1, vec4 q2) {
9620
// disgustingly vectorized quaternion multiplication
9621
vec4 a = q1.w * q2.xyzw;
9622
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
9623
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
9624
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
9625
9626
return a + b + c + d;
9627
}
9628
9629
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
9630
vec3 i = q.xyz;
9631
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
9632
}
9633
9634
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
9635
return rotateVertexByQuat(v, quat(axis, angle));
9636
}
9637
9638
float diffuse(vec3 normal) {
9639
vec3 n2 = normal * normal * vec3(.6, .25, .8);
9640
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
9641
}
9642
struct Vertex {
9643
vec3 pos;
9644
vec2 texCoords;
9645
vec3 normal;
9646
};
9647
9648
struct BlockFrag {
9649
vec2 texCoords;
9650
vec4 color;
9651
float diffuse;
9652
vec2 light;
9653
};
9654
9655
#if defined(FRAGMENT_SHADER)
9656
void fragment(BlockFrag r) {
9657
vec4 tex = FLWBlockTexture(r.texCoords);
9658
9659
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
9660
9661
FLWFinalizeColor(color);
9662
}
9663
#endif
9664
#define PI 3.1415926538
9665
9666
9667
9668
9669
9670
struct Actor {
9671
vec3 pos;
9672
vec2 light;
9673
float offset;
9674
vec3 axis;
9675
vec4 rotation;
9676
vec3 rotationCenter;
9677
float speed;
9678
};
9679
9680
9681
9682
9683
#if defined(VERTEX_SHADER)
9684
BlockFrag vertex(Vertex v, Actor instance) {
9685
float degrees = instance.offset + uTime * instance.speed / 20.;
9686
//float angle = fract(degrees / 360.) * PI * 2.;
9687
9688
vec4 kineticRot = quat(instance.axis, degrees);
9689
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
9690
9691
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
9692
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
9693
9694
FLWFinalizeWorldPos(worldPos);
9695
FLWFinalizeNormal(norm);
9696
9697
BlockFrag b;
9698
b.diffuse = diffuse(norm);
9699
b.texCoords = v.texCoords;
9700
b.light = instance.light;
9701
9702
#if defined(DEBUG_NORMAL)
9703
b.color = vec4(norm, 1.);
9704
#else
9705
b.color = vec4(1.);
9706
#endif
9707
9708
return b;
9709
}
9710
#endif
9711
9712
in vec2 v2f_texCoords;
9713
in vec4 v2f_color;
9714
in float v2f_diffuse;
9715
in vec2 v2f_light;
9716
void main() {
9717
BlockFrag o;
9718
o.texCoords = v2f_texCoords;
9719
o.color = v2f_color;
9720
o.diffuse = v2f_diffuse;
9721
o.light = v2f_light;
9722
fragment(o);
9723
}
9724
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
9725
9726
[17:17:49] [Render thread/ERROR]: #version 150
9727
#extension GL_ARB_conservative_depth : enable
9728
#define VERTEX_SHADER
9729
#define DEBUG_NORMAL
9730
#if defined(VERTEX_SHADER)
9731
out float FragDistance;
9732
#elif defined(FRAGMENT_SHADER)
9733
in float FragDistance;
9734
#endif
9735
uniform vec4 uFogColor;
9736
uniform vec2 uFogRange;
9737
9738
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
9739
float distXZ = length(worldPos.xz - cameraPos.xz);
9740
float distY = abs(worldPos.y - cameraPos.y);
9741
return max(distXZ, distY);
9742
}
9743
9744
float cylindrical_distance(vec3 worldPos) {
9745
float distXZ = length(worldPos.xz);
9746
float distY = abs(worldPos.y);
9747
return max(distXZ, distY);
9748
}
9749
9750
float FLWFogFactor() {
9751
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
9752
}
9753
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
9754
vec2 shiftLight(vec2 lm) {
9755
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
9756
}
9757
9758
9759
uniform float uTime;
9760
uniform mat4 uViewProjection;
9761
uniform vec3 uCameraPos;
9762
9763
uniform vec2 uTextureScale;
9764
uniform sampler2D uBlockAtlas;
9765
uniform sampler2D uLightMap;
9766
9767
uniform vec2 uWindowSize;
9768
9769
void FLWFinalizeNormal(inout vec3 normal) {
9770
// noop
9771
}
9772
9773
#if defined(VERTEX_SHADER)
9774
void FLWFinalizeWorldPos(inout vec4 worldPos) {
9775
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
9776
9777
gl_Position = uViewProjection * worldPos;
9778
}
9779
9780
#elif defined(FRAGMENT_SHADER)
9781
9782
9783
#define ALPHA_DISCARD 0.1
9784
// optimize discard usage
9785
#if defined(ALPHA_DISCARD)
9786
#if defined(GL_ARB_conservative_depth)
9787
layout (depth_greater) out float gl_FragDepth;
9788
#endif
9789
#endif
9790
out vec4 fragColor;
9791
9792
vec4 FLWBlockTexture(vec2 texCoords) {
9793
return texture(uBlockAtlas, texCoords);
9794
}
9795
9796
void FLWFinalizeColor(vec4 color) {
9797
float a = color.a;
9798
float fog = clamp(FLWFogFactor(), 0., 1.);
9799
9800
color = mix(uFogColor, color, fog);
9801
color.a = a;
9802
9803
#if defined(ALPHA_DISCARD)
9804
if (color.a < ALPHA_DISCARD) {
9805
discard;
9806
}
9807
#endif
9808
9809
fragColor = color;
9810
}
9811
9812
vec4 FLWLight(vec2 lightCoords) {
9813
return texture(uLightMap, shiftLight(lightCoords));
9814
}
9815
#endif
9816
9817
9818
mat4 rotate(vec3 axis, float angle) {
9819
float s = sin(angle);
9820
float c = cos(angle);
9821
float oc = 1. - c;
9822
9823
vec3 sa = axis * s;
9824
9825
mat4 mr = mat4(1.);
9826
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
9827
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
9828
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
9829
9830
return mr;
9831
}
9832
9833
mat4 rotation(vec3 rot) {
9834
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
9835
}
9836
9837
mat3 modelToNormal(mat4 mat) {
9838
// Discard the edges. This won't be accurate for scaled or skewed matrices,
9839
// but we don't have to work with those often.
9840
mat3 m;
9841
m[0] = mat[0].xyz;
9842
m[1] = mat[1].xyz;
9843
m[2] = mat[2].xyz;
9844
return m;
9845
}
9846
9847
#define PIOVER2 1.5707963268
9848
9849
vec4 quat(vec3 axis, float angle) {
9850
float halfAngle = angle * PIOVER2 / 180.0;
9851
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
9852
return vec4(axis.xyz * cs.y, cs.x);
9853
}
9854
9855
vec4 quatMult(vec4 q1, vec4 q2) {
9856
// disgustingly vectorized quaternion multiplication
9857
vec4 a = q1.w * q2.xyzw;
9858
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
9859
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
9860
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
9861
9862
return a + b + c + d;
9863
}
9864
9865
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
9866
vec3 i = q.xyz;
9867
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
9868
}
9869
9870
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
9871
return rotateVertexByQuat(v, quat(axis, angle));
9872
}
9873
9874
float diffuse(vec3 normal) {
9875
vec3 n2 = normal * normal * vec3(.6, .25, .8);
9876
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
9877
}
9878
struct Vertex {
9879
vec3 pos;
9880
vec2 texCoords;
9881
vec3 normal;
9882
};
9883
9884
struct BlockFrag {
9885
vec2 texCoords;
9886
vec4 color;
9887
float diffuse;
9888
vec2 light;
9889
};
9890
9891
#if defined(FRAGMENT_SHADER)
9892
void fragment(BlockFrag r) {
9893
vec4 tex = FLWBlockTexture(r.texCoords);
9894
9895
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
9896
9897
FLWFinalizeColor(color);
9898
}
9899
#endif
9900
#define PI 3.1415926538
9901
9902
9903
9904
9905
9906
struct Actor {
9907
vec3 pos;
9908
vec2 light;
9909
float offset;
9910
vec3 axis;
9911
vec4 rotation;
9912
vec3 rotationCenter;
9913
float speed;
9914
};
9915
9916
9917
9918
9919
#if defined(VERTEX_SHADER)
9920
BlockFrag vertex(Vertex v, Actor instance) {
9921
float degrees = instance.offset + uTime * instance.speed / 20.;
9922
//float angle = fract(degrees / 360.) * PI * 2.;
9923
9924
vec4 kineticRot = quat(instance.axis, degrees);
9925
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
9926
9927
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
9928
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
9929
9930
FLWFinalizeWorldPos(worldPos);
9931
FLWFinalizeNormal(norm);
9932
9933
BlockFrag b;
9934
b.diffuse = diffuse(norm);
9935
b.texCoords = v.texCoords;
9936
b.light = instance.light;
9937
9938
#if defined(DEBUG_NORMAL)
9939
b.color = vec4(norm, 1.);
9940
#else
9941
b.color = vec4(1.);
9942
#endif
9943
9944
return b;
9945
}
9946
#endif
9947
9948
in vec3 a_v_pos;
9949
in vec2 a_v_texCoords;
9950
in vec3 a_v_normal;
9951
in vec3 a_i_pos;
9952
in vec2 a_i_light;
9953
in float a_i_offset;
9954
in vec3 a_i_axis;
9955
in vec4 a_i_rotation;
9956
in vec3 a_i_rotationCenter;
9957
in float a_i_speed;
9958
out vec2 v2f_texCoords;
9959
out vec4 v2f_color;
9960
out float v2f_diffuse;
9961
out vec2 v2f_light;
9962
void main() {
9963
Vertex v;
9964
v.pos = a_v_pos;
9965
v.texCoords = a_v_texCoords;
9966
v.normal = a_v_normal;
9967
Actor i;
9968
i.pos = a_i_pos;
9969
i.light = a_i_light;
9970
i.offset = a_i_offset;
9971
i.axis = a_i_axis;
9972
i.rotation = a_i_rotation;
9973
i.rotationCenter = a_i_rotationCenter;
9974
i.speed = a_i_speed;
9975
BlockFrag o = vertex(v, i);
9976
v2f_texCoords = o.texCoords;
9977
v2f_color = o.color;
9978
v2f_diffuse = o.diffuse;
9979
v2f_light = o.light;
9980
}
9981
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
9982
9983
[17:17:49] [Render thread/ERROR]: #version 150
9984
#extension GL_ARB_conservative_depth : enable
9985
#define FRAGMENT_SHADER
9986
#define DEBUG_NORMAL
9987
#if defined(VERTEX_SHADER)
9988
out float FragDistance;
9989
#elif defined(FRAGMENT_SHADER)
9990
in float FragDistance;
9991
#endif
9992
uniform vec4 uFogColor;
9993
uniform vec2 uFogRange;
9994
9995
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
9996
float distXZ = length(worldPos.xz - cameraPos.xz);
9997
float distY = abs(worldPos.y - cameraPos.y);
9998
return max(distXZ, distY);
9999
}
10000
10001
float cylindrical_distance(vec3 worldPos) {
10002
float distXZ = length(worldPos.xz);
10003
float distY = abs(worldPos.y);
10004
return max(distXZ, distY);
10005
}
10006
10007
float FLWFogFactor() {
10008
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
10009
}
10010
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
10011
vec2 shiftLight(vec2 lm) {
10012
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
10013
}
10014
10015
10016
uniform float uTime;
10017
uniform mat4 uViewProjection;
10018
uniform vec3 uCameraPos;
10019
10020
uniform vec2 uTextureScale;
10021
uniform sampler2D uBlockAtlas;
10022
uniform sampler2D uLightMap;
10023
10024
uniform vec2 uWindowSize;
10025
10026
void FLWFinalizeNormal(inout vec3 normal) {
10027
// noop
10028
}
10029
10030
#if defined(VERTEX_SHADER)
10031
void FLWFinalizeWorldPos(inout vec4 worldPos) {
10032
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
10033
10034
gl_Position = uViewProjection * worldPos;
10035
}
10036
10037
#elif defined(FRAGMENT_SHADER)
10038
10039
10040
#define ALPHA_DISCARD 0.1
10041
// optimize discard usage
10042
#if defined(ALPHA_DISCARD)
10043
#if defined(GL_ARB_conservative_depth)
10044
layout (depth_greater) out float gl_FragDepth;
10045
#endif
10046
#endif
10047
out vec4 fragColor;
10048
10049
vec4 FLWBlockTexture(vec2 texCoords) {
10050
return texture(uBlockAtlas, texCoords);
10051
}
10052
10053
void FLWFinalizeColor(vec4 color) {
10054
float a = color.a;
10055
float fog = clamp(FLWFogFactor(), 0., 1.);
10056
10057
color = mix(uFogColor, color, fog);
10058
color.a = a;
10059
10060
#if defined(ALPHA_DISCARD)
10061
if (color.a < ALPHA_DISCARD) {
10062
discard;
10063
}
10064
#endif
10065
10066
fragColor = color;
10067
}
10068
10069
vec4 FLWLight(vec2 lightCoords) {
10070
return texture(uLightMap, shiftLight(lightCoords));
10071
}
10072
#endif
10073
10074
10075
mat4 rotate(vec3 axis, float angle) {
10076
float s = sin(angle);
10077
float c = cos(angle);
10078
float oc = 1. - c;
10079
10080
vec3 sa = axis * s;
10081
10082
mat4 mr = mat4(1.);
10083
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
10084
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
10085
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
10086
10087
return mr;
10088
}
10089
10090
mat4 rotation(vec3 rot) {
10091
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
10092
}
10093
10094
mat3 modelToNormal(mat4 mat) {
10095
// Discard the edges. This won't be accurate for scaled or skewed matrices,
10096
// but we don't have to work with those often.
10097
mat3 m;
10098
m[0] = mat[0].xyz;
10099
m[1] = mat[1].xyz;
10100
m[2] = mat[2].xyz;
10101
return m;
10102
}
10103
10104
#define PIOVER2 1.5707963268
10105
10106
vec4 quat(vec3 axis, float angle) {
10107
float halfAngle = angle * PIOVER2 / 180.0;
10108
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
10109
return vec4(axis.xyz * cs.y, cs.x);
10110
}
10111
10112
vec4 quatMult(vec4 q1, vec4 q2) {
10113
// disgustingly vectorized quaternion multiplication
10114
vec4 a = q1.w * q2.xyzw;
10115
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
10116
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
10117
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
10118
10119
return a + b + c + d;
10120
}
10121
10122
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
10123
vec3 i = q.xyz;
10124
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
10125
}
10126
10127
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
10128
return rotateVertexByQuat(v, quat(axis, angle));
10129
}
10130
10131
float diffuse(vec3 normal) {
10132
vec3 n2 = normal * normal * vec3(.6, .25, .8);
10133
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
10134
}
10135
struct Vertex {
10136
vec3 pos;
10137
vec2 texCoords;
10138
vec3 normal;
10139
};
10140
10141
struct BlockFrag {
10142
vec2 texCoords;
10143
vec4 color;
10144
float diffuse;
10145
vec2 light;
10146
};
10147
10148
#if defined(FRAGMENT_SHADER)
10149
void fragment(BlockFrag r) {
10150
vec4 tex = FLWBlockTexture(r.texCoords);
10151
10152
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
10153
10154
FLWFinalizeColor(color);
10155
}
10156
#endif
10157
#define PI 3.1415926538
10158
10159
10160
10161
10162
10163
struct Actor {
10164
vec3 pos;
10165
vec2 light;
10166
float offset;
10167
vec3 axis;
10168
vec4 rotation;
10169
vec3 rotationCenter;
10170
float speed;
10171
};
10172
10173
10174
10175
10176
#if defined(VERTEX_SHADER)
10177
BlockFrag vertex(Vertex v, Actor instance) {
10178
float degrees = instance.offset + uTime * instance.speed / 20.;
10179
//float angle = fract(degrees / 360.) * PI * 2.;
10180
10181
vec4 kineticRot = quat(instance.axis, degrees);
10182
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
10183
10184
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
10185
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
10186
10187
FLWFinalizeWorldPos(worldPos);
10188
FLWFinalizeNormal(norm);
10189
10190
BlockFrag b;
10191
b.diffuse = diffuse(norm);
10192
b.texCoords = v.texCoords;
10193
b.light = instance.light;
10194
10195
#if defined(DEBUG_NORMAL)
10196
b.color = vec4(norm, 1.);
10197
#else
10198
b.color = vec4(1.);
10199
#endif
10200
10201
return b;
10202
}
10203
#endif
10204
10205
in vec2 v2f_texCoords;
10206
in vec4 v2f_color;
10207
in float v2f_diffuse;
10208
in vec2 v2f_light;
10209
void main() {
10210
BlockFrag o;
10211
o.texCoords = v2f_texCoords;
10212
o.color = v2f_color;
10213
o.diffuse = v2f_diffuse;
10214
o.light = v2f_light;
10215
fragment(o);
10216
}
10217
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
10218
10219
[17:17:49] [Render thread/ERROR]: #version 150
10220
#extension GL_ARB_conservative_depth : enable
10221
#define VERTEX_SHADER
10222
#if defined(VERTEX_SHADER)
10223
out float FragDistance;
10224
#elif defined(FRAGMENT_SHADER)
10225
in float FragDistance;
10226
#endif
10227
uniform vec4 uFogColor;
10228
uniform vec2 uFogRange;
10229
10230
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
10231
float distXZ = length(worldPos.xz - cameraPos.xz);
10232
float distY = abs(worldPos.y - cameraPos.y);
10233
return max(distXZ, distY);
10234
}
10235
10236
float cylindrical_distance(vec3 worldPos) {
10237
float distXZ = length(worldPos.xz);
10238
float distY = abs(worldPos.y);
10239
return max(distXZ, distY);
10240
}
10241
10242
float FLWFogFactor() {
10243
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
10244
}
10245
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
10246
vec2 shiftLight(vec2 lm) {
10247
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
10248
}
10249
10250
10251
uniform float uTime;
10252
uniform mat4 uViewProjection;
10253
uniform vec3 uCameraPos;
10254
10255
uniform vec2 uTextureScale;
10256
uniform sampler2D uBlockAtlas;
10257
uniform sampler2D uLightMap;
10258
10259
uniform vec2 uWindowSize;
10260
10261
void FLWFinalizeNormal(inout vec3 normal) {
10262
// noop
10263
}
10264
10265
#if defined(VERTEX_SHADER)
10266
void FLWFinalizeWorldPos(inout vec4 worldPos) {
10267
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
10268
10269
gl_Position = uViewProjection * worldPos;
10270
}
10271
10272
#elif defined(FRAGMENT_SHADER)
10273
10274
10275
#define ALPHA_DISCARD 0.1
10276
// optimize discard usage
10277
#if defined(ALPHA_DISCARD)
10278
#if defined(GL_ARB_conservative_depth)
10279
layout (depth_greater) out float gl_FragDepth;
10280
#endif
10281
#endif
10282
out vec4 fragColor;
10283
10284
vec4 FLWBlockTexture(vec2 texCoords) {
10285
return texture(uBlockAtlas, texCoords);
10286
}
10287
10288
void FLWFinalizeColor(vec4 color) {
10289
float a = color.a;
10290
float fog = clamp(FLWFogFactor(), 0., 1.);
10291
10292
color = mix(uFogColor, color, fog);
10293
color.a = a;
10294
10295
#if defined(ALPHA_DISCARD)
10296
if (color.a < ALPHA_DISCARD) {
10297
discard;
10298
}
10299
#endif
10300
10301
fragColor = color;
10302
}
10303
10304
vec4 FLWLight(vec2 lightCoords) {
10305
return texture(uLightMap, shiftLight(lightCoords));
10306
}
10307
#endif
10308
10309
10310
mat4 rotate(vec3 axis, float angle) {
10311
float s = sin(angle);
10312
float c = cos(angle);
10313
float oc = 1. - c;
10314
10315
vec3 sa = axis * s;
10316
10317
mat4 mr = mat4(1.);
10318
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
10319
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
10320
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
10321
10322
return mr;
10323
}
10324
10325
mat4 rotation(vec3 rot) {
10326
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
10327
}
10328
10329
mat3 modelToNormal(mat4 mat) {
10330
// Discard the edges. This won't be accurate for scaled or skewed matrices,
10331
// but we don't have to work with those often.
10332
mat3 m;
10333
m[0] = mat[0].xyz;
10334
m[1] = mat[1].xyz;
10335
m[2] = mat[2].xyz;
10336
return m;
10337
}
10338
10339
#define PIOVER2 1.5707963268
10340
10341
vec4 quat(vec3 axis, float angle) {
10342
float halfAngle = angle * PIOVER2 / 180.0;
10343
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
10344
return vec4(axis.xyz * cs.y, cs.x);
10345
}
10346
10347
vec4 quatMult(vec4 q1, vec4 q2) {
10348
// disgustingly vectorized quaternion multiplication
10349
vec4 a = q1.w * q2.xyzw;
10350
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
10351
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
10352
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
10353
10354
return a + b + c + d;
10355
}
10356
10357
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
10358
vec3 i = q.xyz;
10359
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
10360
}
10361
10362
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
10363
return rotateVertexByQuat(v, quat(axis, angle));
10364
}
10365
10366
float diffuse(vec3 normal) {
10367
vec3 n2 = normal * normal * vec3(.6, .25, .8);
10368
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
10369
}
10370
struct Vertex {
10371
vec3 pos;
10372
vec2 texCoords;
10373
vec3 normal;
10374
};
10375
10376
struct BlockFrag {
10377
vec2 texCoords;
10378
vec4 color;
10379
float diffuse;
10380
vec2 light;
10381
};
10382
10383
#if defined(FRAGMENT_SHADER)
10384
void fragment(BlockFrag r) {
10385
vec4 tex = FLWBlockTexture(r.texCoords);
10386
10387
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
10388
10389
FLWFinalizeColor(color);
10390
}
10391
#endif
10392
#define PI 3.1415926538
10393
10394
10395
10396
10397
10398
struct Flap {
10399
vec3 instancePos;
10400
vec2 light;
10401
vec3 segmentOffset;
10402
vec3 pivot;
10403
float horizontalAngle;
10404
float intensity;
10405
float flapScale;
10406
float flapness;
10407
};
10408
10409
10410
10411
10412
#if defined(VERTEX_SHADER)
10413
10414
float toRad(float degrees) {
10415
return fract(degrees / 360.) * PI * 2.;
10416
}
10417
10418
float getFlapAngle(float flapness, float intensity, float scale) {
10419
float absFlap = abs(flapness);
10420
10421
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
10422
10423
float halfAngle = angle * 0.5;
10424
10425
float which = step(0., flapness); // 0 if negative, 1 if positive
10426
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
10427
10428
return degrees;
10429
}
10430
10431
BlockFrag vertex(Vertex v, Flap flap) {
10432
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
10433
10434
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
10435
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
10436
10437
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
10438
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
10439
10440
vec4 worldPos = vec4(rotated, 1.);
10441
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
10442
10443
FLWFinalizeWorldPos(worldPos);
10444
FLWFinalizeNormal(norm);
10445
10446
BlockFrag b;
10447
b.diffuse = diffuse(norm);
10448
b.texCoords = v.texCoords;
10449
b.light = flap.light;
10450
#if defined(DEBUG_NORMAL)
10451
b.color = vec4(norm, 1.);
10452
#else
10453
b.color = vec4(1.);
10454
#endif
10455
return b;
10456
}
10457
#endif
10458
10459
in vec3 a_v_pos;
10460
in vec2 a_v_texCoords;
10461
in vec3 a_v_normal;
10462
in vec3 a_i_instancePos;
10463
in vec2 a_i_light;
10464
in vec3 a_i_segmentOffset;
10465
in vec3 a_i_pivot;
10466
in float a_i_horizontalAngle;
10467
in float a_i_intensity;
10468
in float a_i_flapScale;
10469
in float a_i_flapness;
10470
out vec2 v2f_texCoords;
10471
out vec4 v2f_color;
10472
out float v2f_diffuse;
10473
out vec2 v2f_light;
10474
void main() {
10475
Vertex v;
10476
v.pos = a_v_pos;
10477
v.texCoords = a_v_texCoords;
10478
v.normal = a_v_normal;
10479
Flap i;
10480
i.instancePos = a_i_instancePos;
10481
i.light = a_i_light;
10482
i.segmentOffset = a_i_segmentOffset;
10483
i.pivot = a_i_pivot;
10484
i.horizontalAngle = a_i_horizontalAngle;
10485
i.intensity = a_i_intensity;
10486
i.flapScale = a_i_flapScale;
10487
i.flapness = a_i_flapness;
10488
BlockFrag o = vertex(v, i);
10489
v2f_texCoords = o.texCoords;
10490
v2f_color = o.color;
10491
v2f_diffuse = o.diffuse;
10492
v2f_light = o.light;
10493
}
10494
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
10495
10496
[17:17:49] [Render thread/ERROR]: #version 150
10497
#extension GL_ARB_conservative_depth : enable
10498
#define FRAGMENT_SHADER
10499
#if defined(VERTEX_SHADER)
10500
out float FragDistance;
10501
#elif defined(FRAGMENT_SHADER)
10502
in float FragDistance;
10503
#endif
10504
uniform vec4 uFogColor;
10505
uniform vec2 uFogRange;
10506
10507
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
10508
float distXZ = length(worldPos.xz - cameraPos.xz);
10509
float distY = abs(worldPos.y - cameraPos.y);
10510
return max(distXZ, distY);
10511
}
10512
10513
float cylindrical_distance(vec3 worldPos) {
10514
float distXZ = length(worldPos.xz);
10515
float distY = abs(worldPos.y);
10516
return max(distXZ, distY);
10517
}
10518
10519
float FLWFogFactor() {
10520
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
10521
}
10522
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
10523
vec2 shiftLight(vec2 lm) {
10524
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
10525
}
10526
10527
10528
uniform float uTime;
10529
uniform mat4 uViewProjection;
10530
uniform vec3 uCameraPos;
10531
10532
uniform vec2 uTextureScale;
10533
uniform sampler2D uBlockAtlas;
10534
uniform sampler2D uLightMap;
10535
10536
uniform vec2 uWindowSize;
10537
10538
void FLWFinalizeNormal(inout vec3 normal) {
10539
// noop
10540
}
10541
10542
#if defined(VERTEX_SHADER)
10543
void FLWFinalizeWorldPos(inout vec4 worldPos) {
10544
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
10545
10546
gl_Position = uViewProjection * worldPos;
10547
}
10548
10549
#elif defined(FRAGMENT_SHADER)
10550
10551
10552
#define ALPHA_DISCARD 0.1
10553
// optimize discard usage
10554
#if defined(ALPHA_DISCARD)
10555
#if defined(GL_ARB_conservative_depth)
10556
layout (depth_greater) out float gl_FragDepth;
10557
#endif
10558
#endif
10559
out vec4 fragColor;
10560
10561
vec4 FLWBlockTexture(vec2 texCoords) {
10562
return texture(uBlockAtlas, texCoords);
10563
}
10564
10565
void FLWFinalizeColor(vec4 color) {
10566
float a = color.a;
10567
float fog = clamp(FLWFogFactor(), 0., 1.);
10568
10569
color = mix(uFogColor, color, fog);
10570
color.a = a;
10571
10572
#if defined(ALPHA_DISCARD)
10573
if (color.a < ALPHA_DISCARD) {
10574
discard;
10575
}
10576
#endif
10577
10578
fragColor = color;
10579
}
10580
10581
vec4 FLWLight(vec2 lightCoords) {
10582
return texture(uLightMap, shiftLight(lightCoords));
10583
}
10584
#endif
10585
10586
10587
mat4 rotate(vec3 axis, float angle) {
10588
float s = sin(angle);
10589
float c = cos(angle);
10590
float oc = 1. - c;
10591
10592
vec3 sa = axis * s;
10593
10594
mat4 mr = mat4(1.);
10595
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
10596
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
10597
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
10598
10599
return mr;
10600
}
10601
10602
mat4 rotation(vec3 rot) {
10603
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
10604
}
10605
10606
mat3 modelToNormal(mat4 mat) {
10607
// Discard the edges. This won't be accurate for scaled or skewed matrices,
10608
// but we don't have to work with those often.
10609
mat3 m;
10610
m[0] = mat[0].xyz;
10611
m[1] = mat[1].xyz;
10612
m[2] = mat[2].xyz;
10613
return m;
10614
}
10615
10616
#define PIOVER2 1.5707963268
10617
10618
vec4 quat(vec3 axis, float angle) {
10619
float halfAngle = angle * PIOVER2 / 180.0;
10620
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
10621
return vec4(axis.xyz * cs.y, cs.x);
10622
}
10623
10624
vec4 quatMult(vec4 q1, vec4 q2) {
10625
// disgustingly vectorized quaternion multiplication
10626
vec4 a = q1.w * q2.xyzw;
10627
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
10628
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
10629
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
10630
10631
return a + b + c + d;
10632
}
10633
10634
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
10635
vec3 i = q.xyz;
10636
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
10637
}
10638
10639
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
10640
return rotateVertexByQuat(v, quat(axis, angle));
10641
}
10642
10643
float diffuse(vec3 normal) {
10644
vec3 n2 = normal * normal * vec3(.6, .25, .8);
10645
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
10646
}
10647
struct Vertex {
10648
vec3 pos;
10649
vec2 texCoords;
10650
vec3 normal;
10651
};
10652
10653
struct BlockFrag {
10654
vec2 texCoords;
10655
vec4 color;
10656
float diffuse;
10657
vec2 light;
10658
};
10659
10660
#if defined(FRAGMENT_SHADER)
10661
void fragment(BlockFrag r) {
10662
vec4 tex = FLWBlockTexture(r.texCoords);
10663
10664
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
10665
10666
FLWFinalizeColor(color);
10667
}
10668
#endif
10669
#define PI 3.1415926538
10670
10671
10672
10673
10674
10675
struct Flap {
10676
vec3 instancePos;
10677
vec2 light;
10678
vec3 segmentOffset;
10679
vec3 pivot;
10680
float horizontalAngle;
10681
float intensity;
10682
float flapScale;
10683
float flapness;
10684
};
10685
10686
10687
10688
10689
#if defined(VERTEX_SHADER)
10690
10691
float toRad(float degrees) {
10692
return fract(degrees / 360.) * PI * 2.;
10693
}
10694
10695
float getFlapAngle(float flapness, float intensity, float scale) {
10696
float absFlap = abs(flapness);
10697
10698
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
10699
10700
float halfAngle = angle * 0.5;
10701
10702
float which = step(0., flapness); // 0 if negative, 1 if positive
10703
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
10704
10705
return degrees;
10706
}
10707
10708
BlockFrag vertex(Vertex v, Flap flap) {
10709
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
10710
10711
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
10712
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
10713
10714
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
10715
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
10716
10717
vec4 worldPos = vec4(rotated, 1.);
10718
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
10719
10720
FLWFinalizeWorldPos(worldPos);
10721
FLWFinalizeNormal(norm);
10722
10723
BlockFrag b;
10724
b.diffuse = diffuse(norm);
10725
b.texCoords = v.texCoords;
10726
b.light = flap.light;
10727
#if defined(DEBUG_NORMAL)
10728
b.color = vec4(norm, 1.);
10729
#else
10730
b.color = vec4(1.);
10731
#endif
10732
return b;
10733
}
10734
#endif
10735
10736
in vec2 v2f_texCoords;
10737
in vec4 v2f_color;
10738
in float v2f_diffuse;
10739
in vec2 v2f_light;
10740
void main() {
10741
BlockFrag o;
10742
o.texCoords = v2f_texCoords;
10743
o.color = v2f_color;
10744
o.diffuse = v2f_diffuse;
10745
o.light = v2f_light;
10746
fragment(o);
10747
}
10748
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
10749
10750
[17:17:49] [Render thread/ERROR]: #version 150
10751
#extension GL_ARB_conservative_depth : enable
10752
#define VERTEX_SHADER
10753
#define DEBUG_NORMAL
10754
#if defined(VERTEX_SHADER)
10755
out float FragDistance;
10756
#elif defined(FRAGMENT_SHADER)
10757
in float FragDistance;
10758
#endif
10759
uniform vec4 uFogColor;
10760
uniform vec2 uFogRange;
10761
10762
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
10763
float distXZ = length(worldPos.xz - cameraPos.xz);
10764
float distY = abs(worldPos.y - cameraPos.y);
10765
return max(distXZ, distY);
10766
}
10767
10768
float cylindrical_distance(vec3 worldPos) {
10769
float distXZ = length(worldPos.xz);
10770
float distY = abs(worldPos.y);
10771
return max(distXZ, distY);
10772
}
10773
10774
float FLWFogFactor() {
10775
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
10776
}
10777
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
10778
vec2 shiftLight(vec2 lm) {
10779
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
10780
}
10781
10782
10783
uniform float uTime;
10784
uniform mat4 uViewProjection;
10785
uniform vec3 uCameraPos;
10786
10787
uniform vec2 uTextureScale;
10788
uniform sampler2D uBlockAtlas;
10789
uniform sampler2D uLightMap;
10790
10791
uniform vec2 uWindowSize;
10792
10793
void FLWFinalizeNormal(inout vec3 normal) {
10794
// noop
10795
}
10796
10797
#if defined(VERTEX_SHADER)
10798
void FLWFinalizeWorldPos(inout vec4 worldPos) {
10799
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
10800
10801
gl_Position = uViewProjection * worldPos;
10802
}
10803
10804
#elif defined(FRAGMENT_SHADER)
10805
10806
10807
#define ALPHA_DISCARD 0.1
10808
// optimize discard usage
10809
#if defined(ALPHA_DISCARD)
10810
#if defined(GL_ARB_conservative_depth)
10811
layout (depth_greater) out float gl_FragDepth;
10812
#endif
10813
#endif
10814
out vec4 fragColor;
10815
10816
vec4 FLWBlockTexture(vec2 texCoords) {
10817
return texture(uBlockAtlas, texCoords);
10818
}
10819
10820
void FLWFinalizeColor(vec4 color) {
10821
float a = color.a;
10822
float fog = clamp(FLWFogFactor(), 0., 1.);
10823
10824
color = mix(uFogColor, color, fog);
10825
color.a = a;
10826
10827
#if defined(ALPHA_DISCARD)
10828
if (color.a < ALPHA_DISCARD) {
10829
discard;
10830
}
10831
#endif
10832
10833
fragColor = color;
10834
}
10835
10836
vec4 FLWLight(vec2 lightCoords) {
10837
return texture(uLightMap, shiftLight(lightCoords));
10838
}
10839
#endif
10840
10841
10842
mat4 rotate(vec3 axis, float angle) {
10843
float s = sin(angle);
10844
float c = cos(angle);
10845
float oc = 1. - c;
10846
10847
vec3 sa = axis * s;
10848
10849
mat4 mr = mat4(1.);
10850
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
10851
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
10852
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
10853
10854
return mr;
10855
}
10856
10857
mat4 rotation(vec3 rot) {
10858
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
10859
}
10860
10861
mat3 modelToNormal(mat4 mat) {
10862
// Discard the edges. This won't be accurate for scaled or skewed matrices,
10863
// but we don't have to work with those often.
10864
mat3 m;
10865
m[0] = mat[0].xyz;
10866
m[1] = mat[1].xyz;
10867
m[2] = mat[2].xyz;
10868
return m;
10869
}
10870
10871
#define PIOVER2 1.5707963268
10872
10873
vec4 quat(vec3 axis, float angle) {
10874
float halfAngle = angle * PIOVER2 / 180.0;
10875
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
10876
return vec4(axis.xyz * cs.y, cs.x);
10877
}
10878
10879
vec4 quatMult(vec4 q1, vec4 q2) {
10880
// disgustingly vectorized quaternion multiplication
10881
vec4 a = q1.w * q2.xyzw;
10882
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
10883
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
10884
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
10885
10886
return a + b + c + d;
10887
}
10888
10889
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
10890
vec3 i = q.xyz;
10891
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
10892
}
10893
10894
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
10895
return rotateVertexByQuat(v, quat(axis, angle));
10896
}
10897
10898
float diffuse(vec3 normal) {
10899
vec3 n2 = normal * normal * vec3(.6, .25, .8);
10900
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
10901
}
10902
struct Vertex {
10903
vec3 pos;
10904
vec2 texCoords;
10905
vec3 normal;
10906
};
10907
10908
struct BlockFrag {
10909
vec2 texCoords;
10910
vec4 color;
10911
float diffuse;
10912
vec2 light;
10913
};
10914
10915
#if defined(FRAGMENT_SHADER)
10916
void fragment(BlockFrag r) {
10917
vec4 tex = FLWBlockTexture(r.texCoords);
10918
10919
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
10920
10921
FLWFinalizeColor(color);
10922
}
10923
#endif
10924
#define PI 3.1415926538
10925
10926
10927
10928
10929
10930
struct Flap {
10931
vec3 instancePos;
10932
vec2 light;
10933
vec3 segmentOffset;
10934
vec3 pivot;
10935
float horizontalAngle;
10936
float intensity;
10937
float flapScale;
10938
float flapness;
10939
};
10940
10941
10942
10943
10944
#if defined(VERTEX_SHADER)
10945
10946
float toRad(float degrees) {
10947
return fract(degrees / 360.) * PI * 2.;
10948
}
10949
10950
float getFlapAngle(float flapness, float intensity, float scale) {
10951
float absFlap = abs(flapness);
10952
10953
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
10954
10955
float halfAngle = angle * 0.5;
10956
10957
float which = step(0., flapness); // 0 if negative, 1 if positive
10958
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
10959
10960
return degrees;
10961
}
10962
10963
BlockFrag vertex(Vertex v, Flap flap) {
10964
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
10965
10966
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
10967
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
10968
10969
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
10970
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
10971
10972
vec4 worldPos = vec4(rotated, 1.);
10973
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
10974
10975
FLWFinalizeWorldPos(worldPos);
10976
FLWFinalizeNormal(norm);
10977
10978
BlockFrag b;
10979
b.diffuse = diffuse(norm);
10980
b.texCoords = v.texCoords;
10981
b.light = flap.light;
10982
#if defined(DEBUG_NORMAL)
10983
b.color = vec4(norm, 1.);
10984
#else
10985
b.color = vec4(1.);
10986
#endif
10987
return b;
10988
}
10989
#endif
10990
10991
in vec3 a_v_pos;
10992
in vec2 a_v_texCoords;
10993
in vec3 a_v_normal;
10994
in vec3 a_i_instancePos;
10995
in vec2 a_i_light;
10996
in vec3 a_i_segmentOffset;
10997
in vec3 a_i_pivot;
10998
in float a_i_horizontalAngle;
10999
in float a_i_intensity;
11000
in float a_i_flapScale;
11001
in float a_i_flapness;
11002
out vec2 v2f_texCoords;
11003
out vec4 v2f_color;
11004
out float v2f_diffuse;
11005
out vec2 v2f_light;
11006
void main() {
11007
Vertex v;
11008
v.pos = a_v_pos;
11009
v.texCoords = a_v_texCoords;
11010
v.normal = a_v_normal;
11011
Flap i;
11012
i.instancePos = a_i_instancePos;
11013
i.light = a_i_light;
11014
i.segmentOffset = a_i_segmentOffset;
11015
i.pivot = a_i_pivot;
11016
i.horizontalAngle = a_i_horizontalAngle;
11017
i.intensity = a_i_intensity;
11018
i.flapScale = a_i_flapScale;
11019
i.flapness = a_i_flapness;
11020
BlockFrag o = vertex(v, i);
11021
v2f_texCoords = o.texCoords;
11022
v2f_color = o.color;
11023
v2f_diffuse = o.diffuse;
11024
v2f_light = o.light;
11025
}
11026
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
11027
11028
[17:17:49] [Render thread/ERROR]: #version 150
11029
#extension GL_ARB_conservative_depth : enable
11030
#define FRAGMENT_SHADER
11031
#define DEBUG_NORMAL
11032
#if defined(VERTEX_SHADER)
11033
out float FragDistance;
11034
#elif defined(FRAGMENT_SHADER)
11035
in float FragDistance;
11036
#endif
11037
uniform vec4 uFogColor;
11038
uniform vec2 uFogRange;
11039
11040
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
11041
float distXZ = length(worldPos.xz - cameraPos.xz);
11042
float distY = abs(worldPos.y - cameraPos.y);
11043
return max(distXZ, distY);
11044
}
11045
11046
float cylindrical_distance(vec3 worldPos) {
11047
float distXZ = length(worldPos.xz);
11048
float distY = abs(worldPos.y);
11049
return max(distXZ, distY);
11050
}
11051
11052
float FLWFogFactor() {
11053
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
11054
}
11055
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
11056
vec2 shiftLight(vec2 lm) {
11057
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
11058
}
11059
11060
11061
uniform float uTime;
11062
uniform mat4 uViewProjection;
11063
uniform vec3 uCameraPos;
11064
11065
uniform vec2 uTextureScale;
11066
uniform sampler2D uBlockAtlas;
11067
uniform sampler2D uLightMap;
11068
11069
uniform vec2 uWindowSize;
11070
11071
void FLWFinalizeNormal(inout vec3 normal) {
11072
// noop
11073
}
11074
11075
#if defined(VERTEX_SHADER)
11076
void FLWFinalizeWorldPos(inout vec4 worldPos) {
11077
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
11078
11079
gl_Position = uViewProjection * worldPos;
11080
}
11081
11082
#elif defined(FRAGMENT_SHADER)
11083
11084
11085
#define ALPHA_DISCARD 0.1
11086
// optimize discard usage
11087
#if defined(ALPHA_DISCARD)
11088
#if defined(GL_ARB_conservative_depth)
11089
layout (depth_greater) out float gl_FragDepth;
11090
#endif
11091
#endif
11092
out vec4 fragColor;
11093
11094
vec4 FLWBlockTexture(vec2 texCoords) {
11095
return texture(uBlockAtlas, texCoords);
11096
}
11097
11098
void FLWFinalizeColor(vec4 color) {
11099
float a = color.a;
11100
float fog = clamp(FLWFogFactor(), 0., 1.);
11101
11102
color = mix(uFogColor, color, fog);
11103
color.a = a;
11104
11105
#if defined(ALPHA_DISCARD)
11106
if (color.a < ALPHA_DISCARD) {
11107
discard;
11108
}
11109
#endif
11110
11111
fragColor = color;
11112
}
11113
11114
vec4 FLWLight(vec2 lightCoords) {
11115
return texture(uLightMap, shiftLight(lightCoords));
11116
}
11117
#endif
11118
11119
11120
mat4 rotate(vec3 axis, float angle) {
11121
float s = sin(angle);
11122
float c = cos(angle);
11123
float oc = 1. - c;
11124
11125
vec3 sa = axis * s;
11126
11127
mat4 mr = mat4(1.);
11128
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
11129
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
11130
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
11131
11132
return mr;
11133
}
11134
11135
mat4 rotation(vec3 rot) {
11136
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
11137
}
11138
11139
mat3 modelToNormal(mat4 mat) {
11140
// Discard the edges. This won't be accurate for scaled or skewed matrices,
11141
// but we don't have to work with those often.
11142
mat3 m;
11143
m[0] = mat[0].xyz;
11144
m[1] = mat[1].xyz;
11145
m[2] = mat[2].xyz;
11146
return m;
11147
}
11148
11149
#define PIOVER2 1.5707963268
11150
11151
vec4 quat(vec3 axis, float angle) {
11152
float halfAngle = angle * PIOVER2 / 180.0;
11153
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
11154
return vec4(axis.xyz * cs.y, cs.x);
11155
}
11156
11157
vec4 quatMult(vec4 q1, vec4 q2) {
11158
// disgustingly vectorized quaternion multiplication
11159
vec4 a = q1.w * q2.xyzw;
11160
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
11161
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
11162
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
11163
11164
return a + b + c + d;
11165
}
11166
11167
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
11168
vec3 i = q.xyz;
11169
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
11170
}
11171
11172
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
11173
return rotateVertexByQuat(v, quat(axis, angle));
11174
}
11175
11176
float diffuse(vec3 normal) {
11177
vec3 n2 = normal * normal * vec3(.6, .25, .8);
11178
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
11179
}
11180
struct Vertex {
11181
vec3 pos;
11182
vec2 texCoords;
11183
vec3 normal;
11184
};
11185
11186
struct BlockFrag {
11187
vec2 texCoords;
11188
vec4 color;
11189
float diffuse;
11190
vec2 light;
11191
};
11192
11193
#if defined(FRAGMENT_SHADER)
11194
void fragment(BlockFrag r) {
11195
vec4 tex = FLWBlockTexture(r.texCoords);
11196
11197
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
11198
11199
FLWFinalizeColor(color);
11200
}
11201
#endif
11202
#define PI 3.1415926538
11203
11204
11205
11206
11207
11208
struct Flap {
11209
vec3 instancePos;
11210
vec2 light;
11211
vec3 segmentOffset;
11212
vec3 pivot;
11213
float horizontalAngle;
11214
float intensity;
11215
float flapScale;
11216
float flapness;
11217
};
11218
11219
11220
11221
11222
#if defined(VERTEX_SHADER)
11223
11224
float toRad(float degrees) {
11225
return fract(degrees / 360.) * PI * 2.;
11226
}
11227
11228
float getFlapAngle(float flapness, float intensity, float scale) {
11229
float absFlap = abs(flapness);
11230
11231
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
11232
11233
float halfAngle = angle * 0.5;
11234
11235
float which = step(0., flapness); // 0 if negative, 1 if positive
11236
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
11237
11238
return degrees;
11239
}
11240
11241
BlockFrag vertex(Vertex v, Flap flap) {
11242
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
11243
11244
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
11245
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
11246
11247
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
11248
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
11249
11250
vec4 worldPos = vec4(rotated, 1.);
11251
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
11252
11253
FLWFinalizeWorldPos(worldPos);
11254
FLWFinalizeNormal(norm);
11255
11256
BlockFrag b;
11257
b.diffuse = diffuse(norm);
11258
b.texCoords = v.texCoords;
11259
b.light = flap.light;
11260
#if defined(DEBUG_NORMAL)
11261
b.color = vec4(norm, 1.);
11262
#else
11263
b.color = vec4(1.);
11264
#endif
11265
return b;
11266
}
11267
#endif
11268
11269
in vec2 v2f_texCoords;
11270
in vec4 v2f_color;
11271
in float v2f_diffuse;
11272
in vec2 v2f_light;
11273
void main() {
11274
BlockFrag o;
11275
o.texCoords = v2f_texCoords;
11276
o.color = v2f_color;
11277
o.diffuse = v2f_diffuse;
11278
o.light = v2f_light;
11279
fragment(o);
11280
}
11281
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
11282
11283
[17:17:49] [Render thread/ERROR]: #version 150
11284
#extension GL_ARB_conservative_depth : enable
11285
#define VERTEX_SHADER
11286
#if defined(VERTEX_SHADER)
11287
out float FragDistance;
11288
#elif defined(FRAGMENT_SHADER)
11289
in float FragDistance;
11290
#endif
11291
uniform vec4 uFogColor;
11292
uniform vec2 uFogRange;
11293
11294
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
11295
float distXZ = length(worldPos.xz - cameraPos.xz);
11296
float distY = abs(worldPos.y - cameraPos.y);
11297
return max(distXZ, distY);
11298
}
11299
11300
float cylindrical_distance(vec3 worldPos) {
11301
float distXZ = length(worldPos.xz);
11302
float distY = abs(worldPos.y);
11303
return max(distXZ, distY);
11304
}
11305
11306
float FLWFogFactor() {
11307
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
11308
}
11309
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
11310
vec2 shiftLight(vec2 lm) {
11311
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
11312
}
11313
11314
11315
uniform float uTime;
11316
uniform mat4 uViewProjection;
11317
uniform vec3 uCameraPos;
11318
11319
uniform vec2 uTextureScale;
11320
uniform sampler2D uBlockAtlas;
11321
uniform sampler2D uLightMap;
11322
11323
uniform vec2 uWindowSize;
11324
11325
void FLWFinalizeNormal(inout vec3 normal) {
11326
// noop
11327
}
11328
11329
#if defined(VERTEX_SHADER)
11330
void FLWFinalizeWorldPos(inout vec4 worldPos) {
11331
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
11332
11333
gl_Position = uViewProjection * worldPos;
11334
}
11335
11336
#elif defined(FRAGMENT_SHADER)
11337
11338
11339
#define ALPHA_DISCARD 0.1
11340
// optimize discard usage
11341
#if defined(ALPHA_DISCARD)
11342
#if defined(GL_ARB_conservative_depth)
11343
layout (depth_greater) out float gl_FragDepth;
11344
#endif
11345
#endif
11346
out vec4 fragColor;
11347
11348
vec4 FLWBlockTexture(vec2 texCoords) {
11349
return texture(uBlockAtlas, texCoords);
11350
}
11351
11352
void FLWFinalizeColor(vec4 color) {
11353
float a = color.a;
11354
float fog = clamp(FLWFogFactor(), 0., 1.);
11355
11356
color = mix(uFogColor, color, fog);
11357
color.a = a;
11358
11359
#if defined(ALPHA_DISCARD)
11360
if (color.a < ALPHA_DISCARD) {
11361
discard;
11362
}
11363
#endif
11364
11365
fragColor = color;
11366
}
11367
11368
vec4 FLWLight(vec2 lightCoords) {
11369
return texture(uLightMap, shiftLight(lightCoords));
11370
}
11371
#endif
11372
11373
11374
#define PIOVER2 1.5707963268
11375
11376
vec4 quat(vec3 axis, float angle) {
11377
float halfAngle = angle * PIOVER2 / 180.0;
11378
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
11379
return vec4(axis.xyz * cs.y, cs.x);
11380
}
11381
11382
vec4 quatMult(vec4 q1, vec4 q2) {
11383
// disgustingly vectorized quaternion multiplication
11384
vec4 a = q1.w * q2.xyzw;
11385
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
11386
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
11387
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
11388
11389
return a + b + c + d;
11390
}
11391
11392
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
11393
vec3 i = q.xyz;
11394
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
11395
}
11396
11397
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
11398
return rotateVertexByQuat(v, quat(axis, angle));
11399
}
11400
11401
mat4 rotate(vec3 axis, float angle) {
11402
float s = sin(angle);
11403
float c = cos(angle);
11404
float oc = 1. - c;
11405
11406
vec3 sa = axis * s;
11407
11408
mat4 mr = mat4(1.);
11409
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
11410
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
11411
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
11412
11413
return mr;
11414
}
11415
11416
mat4 rotation(vec3 rot) {
11417
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
11418
}
11419
11420
mat3 modelToNormal(mat4 mat) {
11421
// Discard the edges. This won't be accurate for scaled or skewed matrices,
11422
// but we don't have to work with those often.
11423
mat3 m;
11424
m[0] = mat[0].xyz;
11425
m[1] = mat[1].xyz;
11426
m[2] = mat[2].xyz;
11427
return m;
11428
}
11429
11430
float diffuse(vec3 normal) {
11431
vec3 n2 = normal * normal * vec3(.6, .25, .8);
11432
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
11433
}
11434
struct Vertex {
11435
vec3 pos;
11436
vec2 texCoords;
11437
vec3 normal;
11438
};
11439
11440
struct BlockFrag {
11441
vec2 texCoords;
11442
vec4 color;
11443
float diffuse;
11444
vec2 light;
11445
};
11446
11447
#if defined(FRAGMENT_SHADER)
11448
void fragment(BlockFrag r) {
11449
vec4 tex = FLWBlockTexture(r.texCoords);
11450
11451
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
11452
11453
FLWFinalizeColor(color);
11454
}
11455
#endif
11456
#define PI 3.1415926538
11457
11458
11459
11460
11461
11462
struct Belt {
11463
vec2 light;
11464
vec4 color;
11465
vec3 pos;
11466
float speed;
11467
float offset;
11468
vec4 rotation;
11469
vec2 sourceTexture;
11470
vec4 scrollTexture;
11471
float scrollMult;
11472
};
11473
11474
11475
11476
11477
#if defined(VERTEX_SHADER)
11478
BlockFrag vertex(Vertex v, Belt instance) {
11479
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
11480
11481
vec4 worldPos = vec4(rotated, 1.);
11482
11483
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
11484
11485
FLWFinalizeWorldPos(worldPos);
11486
FLWFinalizeNormal(norm);
11487
11488
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
11489
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
11490
11491
BlockFrag b;
11492
b.diffuse = diffuse(norm);
11493
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
11494
b.light = instance.light;
11495
11496
#if defined(DEBUG_RAINBOW)
11497
b.color = instance.color;
11498
#elif defined(DEBUG_NORMAL)
11499
b.color = vec4(norm, 1.);
11500
#else
11501
b.color = vec4(1.);
11502
#endif
11503
11504
return b;
11505
}
11506
#endif
11507
11508
in vec3 a_v_pos;
11509
in vec2 a_v_texCoords;
11510
in vec3 a_v_normal;
11511
in vec2 a_i_light;
11512
in vec4 a_i_color;
11513
in vec3 a_i_pos;
11514
in float a_i_speed;
11515
in float a_i_offset;
11516
in vec4 a_i_rotation;
11517
in vec2 a_i_sourceTexture;
11518
in vec4 a_i_scrollTexture;
11519
in float a_i_scrollMult;
11520
out vec2 v2f_texCoords;
11521
out vec4 v2f_color;
11522
out float v2f_diffuse;
11523
out vec2 v2f_light;
11524
void main() {
11525
Vertex v;
11526
v.pos = a_v_pos;
11527
v.texCoords = a_v_texCoords;
11528
v.normal = a_v_normal;
11529
Belt i;
11530
i.light = a_i_light;
11531
i.color = a_i_color;
11532
i.pos = a_i_pos;
11533
i.speed = a_i_speed;
11534
i.offset = a_i_offset;
11535
i.rotation = a_i_rotation;
11536
i.sourceTexture = a_i_sourceTexture;
11537
i.scrollTexture = a_i_scrollTexture;
11538
i.scrollMult = a_i_scrollMult;
11539
BlockFrag o = vertex(v, i);
11540
v2f_texCoords = o.texCoords;
11541
v2f_color = o.color;
11542
v2f_diffuse = o.diffuse;
11543
v2f_light = o.light;
11544
}
11545
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
11546
11547
[17:17:49] [Render thread/ERROR]: #version 150
11548
#extension GL_ARB_conservative_depth : enable
11549
#define FRAGMENT_SHADER
11550
#if defined(VERTEX_SHADER)
11551
out float FragDistance;
11552
#elif defined(FRAGMENT_SHADER)
11553
in float FragDistance;
11554
#endif
11555
uniform vec4 uFogColor;
11556
uniform vec2 uFogRange;
11557
11558
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
11559
float distXZ = length(worldPos.xz - cameraPos.xz);
11560
float distY = abs(worldPos.y - cameraPos.y);
11561
return max(distXZ, distY);
11562
}
11563
11564
float cylindrical_distance(vec3 worldPos) {
11565
float distXZ = length(worldPos.xz);
11566
float distY = abs(worldPos.y);
11567
return max(distXZ, distY);
11568
}
11569
11570
float FLWFogFactor() {
11571
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
11572
}
11573
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
11574
vec2 shiftLight(vec2 lm) {
11575
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
11576
}
11577
11578
11579
uniform float uTime;
11580
uniform mat4 uViewProjection;
11581
uniform vec3 uCameraPos;
11582
11583
uniform vec2 uTextureScale;
11584
uniform sampler2D uBlockAtlas;
11585
uniform sampler2D uLightMap;
11586
11587
uniform vec2 uWindowSize;
11588
11589
void FLWFinalizeNormal(inout vec3 normal) {
11590
// noop
11591
}
11592
11593
#if defined(VERTEX_SHADER)
11594
void FLWFinalizeWorldPos(inout vec4 worldPos) {
11595
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
11596
11597
gl_Position = uViewProjection * worldPos;
11598
}
11599
11600
#elif defined(FRAGMENT_SHADER)
11601
11602
11603
#define ALPHA_DISCARD 0.1
11604
// optimize discard usage
11605
#if defined(ALPHA_DISCARD)
11606
#if defined(GL_ARB_conservative_depth)
11607
layout (depth_greater) out float gl_FragDepth;
11608
#endif
11609
#endif
11610
out vec4 fragColor;
11611
11612
vec4 FLWBlockTexture(vec2 texCoords) {
11613
return texture(uBlockAtlas, texCoords);
11614
}
11615
11616
void FLWFinalizeColor(vec4 color) {
11617
float a = color.a;
11618
float fog = clamp(FLWFogFactor(), 0., 1.);
11619
11620
color = mix(uFogColor, color, fog);
11621
color.a = a;
11622
11623
#if defined(ALPHA_DISCARD)
11624
if (color.a < ALPHA_DISCARD) {
11625
discard;
11626
}
11627
#endif
11628
11629
fragColor = color;
11630
}
11631
11632
vec4 FLWLight(vec2 lightCoords) {
11633
return texture(uLightMap, shiftLight(lightCoords));
11634
}
11635
#endif
11636
11637
11638
#define PIOVER2 1.5707963268
11639
11640
vec4 quat(vec3 axis, float angle) {
11641
float halfAngle = angle * PIOVER2 / 180.0;
11642
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
11643
return vec4(axis.xyz * cs.y, cs.x);
11644
}
11645
11646
vec4 quatMult(vec4 q1, vec4 q2) {
11647
// disgustingly vectorized quaternion multiplication
11648
vec4 a = q1.w * q2.xyzw;
11649
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
11650
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
11651
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
11652
11653
return a + b + c + d;
11654
}
11655
11656
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
11657
vec3 i = q.xyz;
11658
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
11659
}
11660
11661
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
11662
return rotateVertexByQuat(v, quat(axis, angle));
11663
}
11664
11665
mat4 rotate(vec3 axis, float angle) {
11666
float s = sin(angle);
11667
float c = cos(angle);
11668
float oc = 1. - c;
11669
11670
vec3 sa = axis * s;
11671
11672
mat4 mr = mat4(1.);
11673
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
11674
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
11675
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
11676
11677
return mr;
11678
}
11679
11680
mat4 rotation(vec3 rot) {
11681
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
11682
}
11683
11684
mat3 modelToNormal(mat4 mat) {
11685
// Discard the edges. This won't be accurate for scaled or skewed matrices,
11686
// but we don't have to work with those often.
11687
mat3 m;
11688
m[0] = mat[0].xyz;
11689
m[1] = mat[1].xyz;
11690
m[2] = mat[2].xyz;
11691
return m;
11692
}
11693
11694
float diffuse(vec3 normal) {
11695
vec3 n2 = normal * normal * vec3(.6, .25, .8);
11696
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
11697
}
11698
struct Vertex {
11699
vec3 pos;
11700
vec2 texCoords;
11701
vec3 normal;
11702
};
11703
11704
struct BlockFrag {
11705
vec2 texCoords;
11706
vec4 color;
11707
float diffuse;
11708
vec2 light;
11709
};
11710
11711
#if defined(FRAGMENT_SHADER)
11712
void fragment(BlockFrag r) {
11713
vec4 tex = FLWBlockTexture(r.texCoords);
11714
11715
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
11716
11717
FLWFinalizeColor(color);
11718
}
11719
#endif
11720
#define PI 3.1415926538
11721
11722
11723
11724
11725
11726
struct Belt {
11727
vec2 light;
11728
vec4 color;
11729
vec3 pos;
11730
float speed;
11731
float offset;
11732
vec4 rotation;
11733
vec2 sourceTexture;
11734
vec4 scrollTexture;
11735
float scrollMult;
11736
};
11737
11738
11739
11740
11741
#if defined(VERTEX_SHADER)
11742
BlockFrag vertex(Vertex v, Belt instance) {
11743
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
11744
11745
vec4 worldPos = vec4(rotated, 1.);
11746
11747
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
11748
11749
FLWFinalizeWorldPos(worldPos);
11750
FLWFinalizeNormal(norm);
11751
11752
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
11753
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
11754
11755
BlockFrag b;
11756
b.diffuse = diffuse(norm);
11757
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
11758
b.light = instance.light;
11759
11760
#if defined(DEBUG_RAINBOW)
11761
b.color = instance.color;
11762
#elif defined(DEBUG_NORMAL)
11763
b.color = vec4(norm, 1.);
11764
#else
11765
b.color = vec4(1.);
11766
#endif
11767
11768
return b;
11769
}
11770
#endif
11771
11772
in vec2 v2f_texCoords;
11773
in vec4 v2f_color;
11774
in float v2f_diffuse;
11775
in vec2 v2f_light;
11776
void main() {
11777
BlockFrag o;
11778
o.texCoords = v2f_texCoords;
11779
o.color = v2f_color;
11780
o.diffuse = v2f_diffuse;
11781
o.light = v2f_light;
11782
fragment(o);
11783
}
11784
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
11785
11786
[17:17:49] [Render thread/ERROR]: #version 150
11787
#extension GL_ARB_conservative_depth : enable
11788
#define VERTEX_SHADER
11789
#define DEBUG_RAINBOW
11790
#if defined(VERTEX_SHADER)
11791
out float FragDistance;
11792
#elif defined(FRAGMENT_SHADER)
11793
in float FragDistance;
11794
#endif
11795
uniform vec4 uFogColor;
11796
uniform vec2 uFogRange;
11797
11798
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
11799
float distXZ = length(worldPos.xz - cameraPos.xz);
11800
float distY = abs(worldPos.y - cameraPos.y);
11801
return max(distXZ, distY);
11802
}
11803
11804
float cylindrical_distance(vec3 worldPos) {
11805
float distXZ = length(worldPos.xz);
11806
float distY = abs(worldPos.y);
11807
return max(distXZ, distY);
11808
}
11809
11810
float FLWFogFactor() {
11811
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
11812
}
11813
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
11814
vec2 shiftLight(vec2 lm) {
11815
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
11816
}
11817
11818
11819
uniform float uTime;
11820
uniform mat4 uViewProjection;
11821
uniform vec3 uCameraPos;
11822
11823
uniform vec2 uTextureScale;
11824
uniform sampler2D uBlockAtlas;
11825
uniform sampler2D uLightMap;
11826
11827
uniform vec2 uWindowSize;
11828
11829
void FLWFinalizeNormal(inout vec3 normal) {
11830
// noop
11831
}
11832
11833
#if defined(VERTEX_SHADER)
11834
void FLWFinalizeWorldPos(inout vec4 worldPos) {
11835
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
11836
11837
gl_Position = uViewProjection * worldPos;
11838
}
11839
11840
#elif defined(FRAGMENT_SHADER)
11841
11842
11843
#define ALPHA_DISCARD 0.1
11844
// optimize discard usage
11845
#if defined(ALPHA_DISCARD)
11846
#if defined(GL_ARB_conservative_depth)
11847
layout (depth_greater) out float gl_FragDepth;
11848
#endif
11849
#endif
11850
out vec4 fragColor;
11851
11852
vec4 FLWBlockTexture(vec2 texCoords) {
11853
return texture(uBlockAtlas, texCoords);
11854
}
11855
11856
void FLWFinalizeColor(vec4 color) {
11857
float a = color.a;
11858
float fog = clamp(FLWFogFactor(), 0., 1.);
11859
11860
color = mix(uFogColor, color, fog);
11861
color.a = a;
11862
11863
#if defined(ALPHA_DISCARD)
11864
if (color.a < ALPHA_DISCARD) {
11865
discard;
11866
}
11867
#endif
11868
11869
fragColor = color;
11870
}
11871
11872
vec4 FLWLight(vec2 lightCoords) {
11873
return texture(uLightMap, shiftLight(lightCoords));
11874
}
11875
#endif
11876
11877
11878
#define PIOVER2 1.5707963268
11879
11880
vec4 quat(vec3 axis, float angle) {
11881
float halfAngle = angle * PIOVER2 / 180.0;
11882
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
11883
return vec4(axis.xyz * cs.y, cs.x);
11884
}
11885
11886
vec4 quatMult(vec4 q1, vec4 q2) {
11887
// disgustingly vectorized quaternion multiplication
11888
vec4 a = q1.w * q2.xyzw;
11889
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
11890
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
11891
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
11892
11893
return a + b + c + d;
11894
}
11895
11896
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
11897
vec3 i = q.xyz;
11898
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
11899
}
11900
11901
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
11902
return rotateVertexByQuat(v, quat(axis, angle));
11903
}
11904
11905
mat4 rotate(vec3 axis, float angle) {
11906
float s = sin(angle);
11907
float c = cos(angle);
11908
float oc = 1. - c;
11909
11910
vec3 sa = axis * s;
11911
11912
mat4 mr = mat4(1.);
11913
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
11914
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
11915
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
11916
11917
return mr;
11918
}
11919
11920
mat4 rotation(vec3 rot) {
11921
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
11922
}
11923
11924
mat3 modelToNormal(mat4 mat) {
11925
// Discard the edges. This won't be accurate for scaled or skewed matrices,
11926
// but we don't have to work with those often.
11927
mat3 m;
11928
m[0] = mat[0].xyz;
11929
m[1] = mat[1].xyz;
11930
m[2] = mat[2].xyz;
11931
return m;
11932
}
11933
11934
float diffuse(vec3 normal) {
11935
vec3 n2 = normal * normal * vec3(.6, .25, .8);
11936
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
11937
}
11938
struct Vertex {
11939
vec3 pos;
11940
vec2 texCoords;
11941
vec3 normal;
11942
};
11943
11944
struct BlockFrag {
11945
vec2 texCoords;
11946
vec4 color;
11947
float diffuse;
11948
vec2 light;
11949
};
11950
11951
#if defined(FRAGMENT_SHADER)
11952
void fragment(BlockFrag r) {
11953
vec4 tex = FLWBlockTexture(r.texCoords);
11954
11955
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
11956
11957
FLWFinalizeColor(color);
11958
}
11959
#endif
11960
#define PI 3.1415926538
11961
11962
11963
11964
11965
11966
struct Belt {
11967
vec2 light;
11968
vec4 color;
11969
vec3 pos;
11970
float speed;
11971
float offset;
11972
vec4 rotation;
11973
vec2 sourceTexture;
11974
vec4 scrollTexture;
11975
float scrollMult;
11976
};
11977
11978
11979
11980
11981
#if defined(VERTEX_SHADER)
11982
BlockFrag vertex(Vertex v, Belt instance) {
11983
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
11984
11985
vec4 worldPos = vec4(rotated, 1.);
11986
11987
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
11988
11989
FLWFinalizeWorldPos(worldPos);
11990
FLWFinalizeNormal(norm);
11991
11992
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
11993
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
11994
11995
BlockFrag b;
11996
b.diffuse = diffuse(norm);
11997
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
11998
b.light = instance.light;
11999
12000
#if defined(DEBUG_RAINBOW)
12001
b.color = instance.color;
12002
#elif defined(DEBUG_NORMAL)
12003
b.color = vec4(norm, 1.);
12004
#else
12005
b.color = vec4(1.);
12006
#endif
12007
12008
return b;
12009
}
12010
#endif
12011
12012
in vec3 a_v_pos;
12013
in vec2 a_v_texCoords;
12014
in vec3 a_v_normal;
12015
in vec2 a_i_light;
12016
in vec4 a_i_color;
12017
in vec3 a_i_pos;
12018
in float a_i_speed;
12019
in float a_i_offset;
12020
in vec4 a_i_rotation;
12021
in vec2 a_i_sourceTexture;
12022
in vec4 a_i_scrollTexture;
12023
in float a_i_scrollMult;
12024
out vec2 v2f_texCoords;
12025
out vec4 v2f_color;
12026
out float v2f_diffuse;
12027
out vec2 v2f_light;
12028
void main() {
12029
Vertex v;
12030
v.pos = a_v_pos;
12031
v.texCoords = a_v_texCoords;
12032
v.normal = a_v_normal;
12033
Belt i;
12034
i.light = a_i_light;
12035
i.color = a_i_color;
12036
i.pos = a_i_pos;
12037
i.speed = a_i_speed;
12038
i.offset = a_i_offset;
12039
i.rotation = a_i_rotation;
12040
i.sourceTexture = a_i_sourceTexture;
12041
i.scrollTexture = a_i_scrollTexture;
12042
i.scrollMult = a_i_scrollMult;
12043
BlockFrag o = vertex(v, i);
12044
v2f_texCoords = o.texCoords;
12045
v2f_color = o.color;
12046
v2f_diffuse = o.diffuse;
12047
v2f_light = o.light;
12048
}
12049
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
12050
12051
[17:17:49] [Render thread/ERROR]: #version 150
12052
#extension GL_ARB_conservative_depth : enable
12053
#define FRAGMENT_SHADER
12054
#define DEBUG_RAINBOW
12055
#if defined(VERTEX_SHADER)
12056
out float FragDistance;
12057
#elif defined(FRAGMENT_SHADER)
12058
in float FragDistance;
12059
#endif
12060
uniform vec4 uFogColor;
12061
uniform vec2 uFogRange;
12062
12063
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
12064
float distXZ = length(worldPos.xz - cameraPos.xz);
12065
float distY = abs(worldPos.y - cameraPos.y);
12066
return max(distXZ, distY);
12067
}
12068
12069
float cylindrical_distance(vec3 worldPos) {
12070
float distXZ = length(worldPos.xz);
12071
float distY = abs(worldPos.y);
12072
return max(distXZ, distY);
12073
}
12074
12075
float FLWFogFactor() {
12076
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
12077
}
12078
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
12079
vec2 shiftLight(vec2 lm) {
12080
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
12081
}
12082
12083
12084
uniform float uTime;
12085
uniform mat4 uViewProjection;
12086
uniform vec3 uCameraPos;
12087
12088
uniform vec2 uTextureScale;
12089
uniform sampler2D uBlockAtlas;
12090
uniform sampler2D uLightMap;
12091
12092
uniform vec2 uWindowSize;
12093
12094
void FLWFinalizeNormal(inout vec3 normal) {
12095
// noop
12096
}
12097
12098
#if defined(VERTEX_SHADER)
12099
void FLWFinalizeWorldPos(inout vec4 worldPos) {
12100
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
12101
12102
gl_Position = uViewProjection * worldPos;
12103
}
12104
12105
#elif defined(FRAGMENT_SHADER)
12106
12107
12108
#define ALPHA_DISCARD 0.1
12109
// optimize discard usage
12110
#if defined(ALPHA_DISCARD)
12111
#if defined(GL_ARB_conservative_depth)
12112
layout (depth_greater) out float gl_FragDepth;
12113
#endif
12114
#endif
12115
out vec4 fragColor;
12116
12117
vec4 FLWBlockTexture(vec2 texCoords) {
12118
return texture(uBlockAtlas, texCoords);
12119
}
12120
12121
void FLWFinalizeColor(vec4 color) {
12122
float a = color.a;
12123
float fog = clamp(FLWFogFactor(), 0., 1.);
12124
12125
color = mix(uFogColor, color, fog);
12126
color.a = a;
12127
12128
#if defined(ALPHA_DISCARD)
12129
if (color.a < ALPHA_DISCARD) {
12130
discard;
12131
}
12132
#endif
12133
12134
fragColor = color;
12135
}
12136
12137
vec4 FLWLight(vec2 lightCoords) {
12138
return texture(uLightMap, shiftLight(lightCoords));
12139
}
12140
#endif
12141
12142
12143
#define PIOVER2 1.5707963268
12144
12145
vec4 quat(vec3 axis, float angle) {
12146
float halfAngle = angle * PIOVER2 / 180.0;
12147
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
12148
return vec4(axis.xyz * cs.y, cs.x);
12149
}
12150
12151
vec4 quatMult(vec4 q1, vec4 q2) {
12152
// disgustingly vectorized quaternion multiplication
12153
vec4 a = q1.w * q2.xyzw;
12154
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
12155
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
12156
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
12157
12158
return a + b + c + d;
12159
}
12160
12161
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
12162
vec3 i = q.xyz;
12163
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
12164
}
12165
12166
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
12167
return rotateVertexByQuat(v, quat(axis, angle));
12168
}
12169
12170
mat4 rotate(vec3 axis, float angle) {
12171
float s = sin(angle);
12172
float c = cos(angle);
12173
float oc = 1. - c;
12174
12175
vec3 sa = axis * s;
12176
12177
mat4 mr = mat4(1.);
12178
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
12179
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
12180
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
12181
12182
return mr;
12183
}
12184
12185
mat4 rotation(vec3 rot) {
12186
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
12187
}
12188
12189
mat3 modelToNormal(mat4 mat) {
12190
// Discard the edges. This won't be accurate for scaled or skewed matrices,
12191
// but we don't have to work with those often.
12192
mat3 m;
12193
m[0] = mat[0].xyz;
12194
m[1] = mat[1].xyz;
12195
m[2] = mat[2].xyz;
12196
return m;
12197
}
12198
12199
float diffuse(vec3 normal) {
12200
vec3 n2 = normal * normal * vec3(.6, .25, .8);
12201
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
12202
}
12203
struct Vertex {
12204
vec3 pos;
12205
vec2 texCoords;
12206
vec3 normal;
12207
};
12208
12209
struct BlockFrag {
12210
vec2 texCoords;
12211
vec4 color;
12212
float diffuse;
12213
vec2 light;
12214
};
12215
12216
#if defined(FRAGMENT_SHADER)
12217
void fragment(BlockFrag r) {
12218
vec4 tex = FLWBlockTexture(r.texCoords);
12219
12220
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
12221
12222
FLWFinalizeColor(color);
12223
}
12224
#endif
12225
#define PI 3.1415926538
12226
12227
12228
12229
12230
12231
struct Belt {
12232
vec2 light;
12233
vec4 color;
12234
vec3 pos;
12235
float speed;
12236
float offset;
12237
vec4 rotation;
12238
vec2 sourceTexture;
12239
vec4 scrollTexture;
12240
float scrollMult;
12241
};
12242
12243
12244
12245
12246
#if defined(VERTEX_SHADER)
12247
BlockFrag vertex(Vertex v, Belt instance) {
12248
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
12249
12250
vec4 worldPos = vec4(rotated, 1.);
12251
12252
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
12253
12254
FLWFinalizeWorldPos(worldPos);
12255
FLWFinalizeNormal(norm);
12256
12257
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
12258
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
12259
12260
BlockFrag b;
12261
b.diffuse = diffuse(norm);
12262
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
12263
b.light = instance.light;
12264
12265
#if defined(DEBUG_RAINBOW)
12266
b.color = instance.color;
12267
#elif defined(DEBUG_NORMAL)
12268
b.color = vec4(norm, 1.);
12269
#else
12270
b.color = vec4(1.);
12271
#endif
12272
12273
return b;
12274
}
12275
#endif
12276
12277
in vec2 v2f_texCoords;
12278
in vec4 v2f_color;
12279
in float v2f_diffuse;
12280
in vec2 v2f_light;
12281
void main() {
12282
BlockFrag o;
12283
o.texCoords = v2f_texCoords;
12284
o.color = v2f_color;
12285
o.diffuse = v2f_diffuse;
12286
o.light = v2f_light;
12287
fragment(o);
12288
}
12289
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
12290
12291
[17:17:49] [Render thread/ERROR]: #version 150
12292
#extension GL_ARB_conservative_depth : enable
12293
#define VERTEX_SHADER
12294
#define DEBUG_NORMAL
12295
#if defined(VERTEX_SHADER)
12296
out float FragDistance;
12297
#elif defined(FRAGMENT_SHADER)
12298
in float FragDistance;
12299
#endif
12300
uniform vec4 uFogColor;
12301
uniform vec2 uFogRange;
12302
12303
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
12304
float distXZ = length(worldPos.xz - cameraPos.xz);
12305
float distY = abs(worldPos.y - cameraPos.y);
12306
return max(distXZ, distY);
12307
}
12308
12309
float cylindrical_distance(vec3 worldPos) {
12310
float distXZ = length(worldPos.xz);
12311
float distY = abs(worldPos.y);
12312
return max(distXZ, distY);
12313
}
12314
12315
float FLWFogFactor() {
12316
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
12317
}
12318
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
12319
vec2 shiftLight(vec2 lm) {
12320
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
12321
}
12322
12323
12324
uniform float uTime;
12325
uniform mat4 uViewProjection;
12326
uniform vec3 uCameraPos;
12327
12328
uniform vec2 uTextureScale;
12329
uniform sampler2D uBlockAtlas;
12330
uniform sampler2D uLightMap;
12331
12332
uniform vec2 uWindowSize;
12333
12334
void FLWFinalizeNormal(inout vec3 normal) {
12335
// noop
12336
}
12337
12338
#if defined(VERTEX_SHADER)
12339
void FLWFinalizeWorldPos(inout vec4 worldPos) {
12340
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
12341
12342
gl_Position = uViewProjection * worldPos;
12343
}
12344
12345
#elif defined(FRAGMENT_SHADER)
12346
12347
12348
#define ALPHA_DISCARD 0.1
12349
// optimize discard usage
12350
#if defined(ALPHA_DISCARD)
12351
#if defined(GL_ARB_conservative_depth)
12352
layout (depth_greater) out float gl_FragDepth;
12353
#endif
12354
#endif
12355
out vec4 fragColor;
12356
12357
vec4 FLWBlockTexture(vec2 texCoords) {
12358
return texture(uBlockAtlas, texCoords);
12359
}
12360
12361
void FLWFinalizeColor(vec4 color) {
12362
float a = color.a;
12363
float fog = clamp(FLWFogFactor(), 0., 1.);
12364
12365
color = mix(uFogColor, color, fog);
12366
color.a = a;
12367
12368
#if defined(ALPHA_DISCARD)
12369
if (color.a < ALPHA_DISCARD) {
12370
discard;
12371
}
12372
#endif
12373
12374
fragColor = color;
12375
}
12376
12377
vec4 FLWLight(vec2 lightCoords) {
12378
return texture(uLightMap, shiftLight(lightCoords));
12379
}
12380
#endif
12381
12382
12383
#define PIOVER2 1.5707963268
12384
12385
vec4 quat(vec3 axis, float angle) {
12386
float halfAngle = angle * PIOVER2 / 180.0;
12387
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
12388
return vec4(axis.xyz * cs.y, cs.x);
12389
}
12390
12391
vec4 quatMult(vec4 q1, vec4 q2) {
12392
// disgustingly vectorized quaternion multiplication
12393
vec4 a = q1.w * q2.xyzw;
12394
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
12395
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
12396
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
12397
12398
return a + b + c + d;
12399
}
12400
12401
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
12402
vec3 i = q.xyz;
12403
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
12404
}
12405
12406
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
12407
return rotateVertexByQuat(v, quat(axis, angle));
12408
}
12409
12410
mat4 rotate(vec3 axis, float angle) {
12411
float s = sin(angle);
12412
float c = cos(angle);
12413
float oc = 1. - c;
12414
12415
vec3 sa = axis * s;
12416
12417
mat4 mr = mat4(1.);
12418
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
12419
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
12420
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
12421
12422
return mr;
12423
}
12424
12425
mat4 rotation(vec3 rot) {
12426
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
12427
}
12428
12429
mat3 modelToNormal(mat4 mat) {
12430
// Discard the edges. This won't be accurate for scaled or skewed matrices,
12431
// but we don't have to work with those often.
12432
mat3 m;
12433
m[0] = mat[0].xyz;
12434
m[1] = mat[1].xyz;
12435
m[2] = mat[2].xyz;
12436
return m;
12437
}
12438
12439
float diffuse(vec3 normal) {
12440
vec3 n2 = normal * normal * vec3(.6, .25, .8);
12441
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
12442
}
12443
struct Vertex {
12444
vec3 pos;
12445
vec2 texCoords;
12446
vec3 normal;
12447
};
12448
12449
struct BlockFrag {
12450
vec2 texCoords;
12451
vec4 color;
12452
float diffuse;
12453
vec2 light;
12454
};
12455
12456
#if defined(FRAGMENT_SHADER)
12457
void fragment(BlockFrag r) {
12458
vec4 tex = FLWBlockTexture(r.texCoords);
12459
12460
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
12461
12462
FLWFinalizeColor(color);
12463
}
12464
#endif
12465
#define PI 3.1415926538
12466
12467
12468
12469
12470
12471
struct Belt {
12472
vec2 light;
12473
vec4 color;
12474
vec3 pos;
12475
float speed;
12476
float offset;
12477
vec4 rotation;
12478
vec2 sourceTexture;
12479
vec4 scrollTexture;
12480
float scrollMult;
12481
};
12482
12483
12484
12485
12486
#if defined(VERTEX_SHADER)
12487
BlockFrag vertex(Vertex v, Belt instance) {
12488
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
12489
12490
vec4 worldPos = vec4(rotated, 1.);
12491
12492
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
12493
12494
FLWFinalizeWorldPos(worldPos);
12495
FLWFinalizeNormal(norm);
12496
12497
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
12498
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
12499
12500
BlockFrag b;
12501
b.diffuse = diffuse(norm);
12502
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
12503
b.light = instance.light;
12504
12505
#if defined(DEBUG_RAINBOW)
12506
b.color = instance.color;
12507
#elif defined(DEBUG_NORMAL)
12508
b.color = vec4(norm, 1.);
12509
#else
12510
b.color = vec4(1.);
12511
#endif
12512
12513
return b;
12514
}
12515
#endif
12516
12517
in vec3 a_v_pos;
12518
in vec2 a_v_texCoords;
12519
in vec3 a_v_normal;
12520
in vec2 a_i_light;
12521
in vec4 a_i_color;
12522
in vec3 a_i_pos;
12523
in float a_i_speed;
12524
in float a_i_offset;
12525
in vec4 a_i_rotation;
12526
in vec2 a_i_sourceTexture;
12527
in vec4 a_i_scrollTexture;
12528
in float a_i_scrollMult;
12529
out vec2 v2f_texCoords;
12530
out vec4 v2f_color;
12531
out float v2f_diffuse;
12532
out vec2 v2f_light;
12533
void main() {
12534
Vertex v;
12535
v.pos = a_v_pos;
12536
v.texCoords = a_v_texCoords;
12537
v.normal = a_v_normal;
12538
Belt i;
12539
i.light = a_i_light;
12540
i.color = a_i_color;
12541
i.pos = a_i_pos;
12542
i.speed = a_i_speed;
12543
i.offset = a_i_offset;
12544
i.rotation = a_i_rotation;
12545
i.sourceTexture = a_i_sourceTexture;
12546
i.scrollTexture = a_i_scrollTexture;
12547
i.scrollMult = a_i_scrollMult;
12548
BlockFrag o = vertex(v, i);
12549
v2f_texCoords = o.texCoords;
12550
v2f_color = o.color;
12551
v2f_diffuse = o.diffuse;
12552
v2f_light = o.light;
12553
}
12554
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
12555
12556
[17:17:49] [Render thread/ERROR]: #version 150
12557
#extension GL_ARB_conservative_depth : enable
12558
#define FRAGMENT_SHADER
12559
#define DEBUG_NORMAL
12560
#if defined(VERTEX_SHADER)
12561
out float FragDistance;
12562
#elif defined(FRAGMENT_SHADER)
12563
in float FragDistance;
12564
#endif
12565
uniform vec4 uFogColor;
12566
uniform vec2 uFogRange;
12567
12568
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
12569
float distXZ = length(worldPos.xz - cameraPos.xz);
12570
float distY = abs(worldPos.y - cameraPos.y);
12571
return max(distXZ, distY);
12572
}
12573
12574
float cylindrical_distance(vec3 worldPos) {
12575
float distXZ = length(worldPos.xz);
12576
float distY = abs(worldPos.y);
12577
return max(distXZ, distY);
12578
}
12579
12580
float FLWFogFactor() {
12581
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
12582
}
12583
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
12584
vec2 shiftLight(vec2 lm) {
12585
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
12586
}
12587
12588
12589
uniform float uTime;
12590
uniform mat4 uViewProjection;
12591
uniform vec3 uCameraPos;
12592
12593
uniform vec2 uTextureScale;
12594
uniform sampler2D uBlockAtlas;
12595
uniform sampler2D uLightMap;
12596
12597
uniform vec2 uWindowSize;
12598
12599
void FLWFinalizeNormal(inout vec3 normal) {
12600
// noop
12601
}
12602
12603
#if defined(VERTEX_SHADER)
12604
void FLWFinalizeWorldPos(inout vec4 worldPos) {
12605
FragDistance = cylindrical_distance(worldPos.xyz, uCameraPos);
12606
12607
gl_Position = uViewProjection * worldPos;
12608
}
12609
12610
#elif defined(FRAGMENT_SHADER)
12611
12612
12613
#define ALPHA_DISCARD 0.1
12614
// optimize discard usage
12615
#if defined(ALPHA_DISCARD)
12616
#if defined(GL_ARB_conservative_depth)
12617
layout (depth_greater) out float gl_FragDepth;
12618
#endif
12619
#endif
12620
out vec4 fragColor;
12621
12622
vec4 FLWBlockTexture(vec2 texCoords) {
12623
return texture(uBlockAtlas, texCoords);
12624
}
12625
12626
void FLWFinalizeColor(vec4 color) {
12627
float a = color.a;
12628
float fog = clamp(FLWFogFactor(), 0., 1.);
12629
12630
color = mix(uFogColor, color, fog);
12631
color.a = a;
12632
12633
#if defined(ALPHA_DISCARD)
12634
if (color.a < ALPHA_DISCARD) {
12635
discard;
12636
}
12637
#endif
12638
12639
fragColor = color;
12640
}
12641
12642
vec4 FLWLight(vec2 lightCoords) {
12643
return texture(uLightMap, shiftLight(lightCoords));
12644
}
12645
#endif
12646
12647
12648
#define PIOVER2 1.5707963268
12649
12650
vec4 quat(vec3 axis, float angle) {
12651
float halfAngle = angle * PIOVER2 / 180.0;
12652
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
12653
return vec4(axis.xyz * cs.y, cs.x);
12654
}
12655
12656
vec4 quatMult(vec4 q1, vec4 q2) {
12657
// disgustingly vectorized quaternion multiplication
12658
vec4 a = q1.w * q2.xyzw;
12659
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
12660
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
12661
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
12662
12663
return a + b + c + d;
12664
}
12665
12666
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
12667
vec3 i = q.xyz;
12668
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
12669
}
12670
12671
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
12672
return rotateVertexByQuat(v, quat(axis, angle));
12673
}
12674
12675
mat4 rotate(vec3 axis, float angle) {
12676
float s = sin(angle);
12677
float c = cos(angle);
12678
float oc = 1. - c;
12679
12680
vec3 sa = axis * s;
12681
12682
mat4 mr = mat4(1.);
12683
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
12684
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
12685
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
12686
12687
return mr;
12688
}
12689
12690
mat4 rotation(vec3 rot) {
12691
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
12692
}
12693
12694
mat3 modelToNormal(mat4 mat) {
12695
// Discard the edges. This won't be accurate for scaled or skewed matrices,
12696
// but we don't have to work with those often.
12697
mat3 m;
12698
m[0] = mat[0].xyz;
12699
m[1] = mat[1].xyz;
12700
m[2] = mat[2].xyz;
12701
return m;
12702
}
12703
12704
float diffuse(vec3 normal) {
12705
vec3 n2 = normal * normal * vec3(.6, .25, .8);
12706
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
12707
}
12708
struct Vertex {
12709
vec3 pos;
12710
vec2 texCoords;
12711
vec3 normal;
12712
};
12713
12714
struct BlockFrag {
12715
vec2 texCoords;
12716
vec4 color;
12717
float diffuse;
12718
vec2 light;
12719
};
12720
12721
#if defined(FRAGMENT_SHADER)
12722
void fragment(BlockFrag r) {
12723
vec4 tex = FLWBlockTexture(r.texCoords);
12724
12725
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
12726
12727
FLWFinalizeColor(color);
12728
}
12729
#endif
12730
#define PI 3.1415926538
12731
12732
12733
12734
12735
12736
struct Belt {
12737
vec2 light;
12738
vec4 color;
12739
vec3 pos;
12740
float speed;
12741
float offset;
12742
vec4 rotation;
12743
vec2 sourceTexture;
12744
vec4 scrollTexture;
12745
float scrollMult;
12746
};
12747
12748
12749
12750
12751
#if defined(VERTEX_SHADER)
12752
BlockFrag vertex(Vertex v, Belt instance) {
12753
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
12754
12755
vec4 worldPos = vec4(rotated, 1.);
12756
12757
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
12758
12759
FLWFinalizeWorldPos(worldPos);
12760
FLWFinalizeNormal(norm);
12761
12762
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
12763
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
12764
12765
BlockFrag b;
12766
b.diffuse = diffuse(norm);
12767
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
12768
b.light = instance.light;
12769
12770
#if defined(DEBUG_RAINBOW)
12771
b.color = instance.color;
12772
#elif defined(DEBUG_NORMAL)
12773
b.color = vec4(norm, 1.);
12774
#else
12775
b.color = vec4(1.);
12776
#endif
12777
12778
return b;
12779
}
12780
#endif
12781
12782
in vec2 v2f_texCoords;
12783
in vec4 v2f_color;
12784
in float v2f_diffuse;
12785
in vec2 v2f_light;
12786
void main() {
12787
BlockFrag o;
12788
o.texCoords = v2f_texCoords;
12789
o.color = v2f_color;
12790
o.diffuse = v2f_diffuse;
12791
o.light = v2f_light;
12792
fragment(o);
12793
}
12794
[17:17:49] [Render thread/INFO]: Loading context 'create:context/contraption'
12795
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
12796
12797
[17:17:49] [Render thread/ERROR]: #version 150
12798
#extension GL_ARB_conservative_depth : enable
12799
#define VERTEX_SHADER
12800
#if defined(VERTEX_SHADER)
12801
out float FragDistance;
12802
#elif defined(FRAGMENT_SHADER)
12803
in float FragDistance;
12804
#endif
12805
uniform vec4 uFogColor;
12806
uniform vec2 uFogRange;
12807
12808
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
12809
float distXZ = length(worldPos.xz - cameraPos.xz);
12810
float distY = abs(worldPos.y - cameraPos.y);
12811
return max(distXZ, distY);
12812
}
12813
12814
float cylindrical_distance(vec3 worldPos) {
12815
float distXZ = length(worldPos.xz);
12816
float distY = abs(worldPos.y);
12817
return max(distXZ, distY);
12818
}
12819
12820
float FLWFogFactor() {
12821
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
12822
}
12823
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
12824
vec2 shiftLight(vec2 lm) {
12825
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
12826
}
12827
12828
12829
uniform sampler3D uLightVolume;
12830
12831
uniform sampler2D uBlockAtlas;
12832
uniform sampler2D uLightMap;
12833
12834
uniform vec3 uLightBoxSize;
12835
uniform vec3 uLightBoxMin;
12836
uniform mat4 uModel;
12837
12838
uniform float uTime;
12839
uniform mat4 uViewProjection;
12840
uniform vec3 uCameraPos;
12841
12842
void FLWFinalizeNormal(inout vec3 normal) {
12843
mat3 m;
12844
m[0] = uModel[0].xyz;
12845
m[1] = uModel[1].xyz;
12846
m[2] = uModel[2].xyz;
12847
normal = m * normal;
12848
}
12849
12850
#if defined(VERTEX_SHADER)
12851
12852
out vec3 BoxCoord;
12853
12854
void FLWFinalizeWorldPos(inout vec4 worldPos) {
12855
worldPos = uModel * worldPos;
12856
12857
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
12858
12859
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
12860
12861
gl_Position = uViewProjection * worldPos;
12862
}
12863
12864
#elif defined(FRAGMENT_SHADER)
12865
12866
12867
#define ALPHA_DISCARD 0.1
12868
// optimize discard usage
12869
#if defined(ALPHA_DISCARD)
12870
#if defined(GL_ARB_conservative_depth)
12871
layout (depth_greater) out float gl_FragDepth;
12872
#endif
12873
#endif
12874
12875
in vec3 BoxCoord;
12876
12877
out vec4 FragColor;
12878
12879
vec4 FLWBlockTexture(vec2 texCoords) {
12880
return texture(uBlockAtlas, texCoords);
12881
}
12882
12883
void FLWFinalizeColor(vec4 color) {
12884
float a = color.a;
12885
float fog = clamp(FLWFogFactor(), 0., 1.);
12886
12887
color = mix(uFogColor, color, fog);
12888
color.a = a;
12889
12890
#if defined(ALPHA_DISCARD)
12891
if (color.a < ALPHA_DISCARD) {
12892
discard;
12893
}
12894
#endif
12895
12896
FragColor = color;
12897
}
12898
12899
vec4 FLWLight(vec2 lightCoords) {
12900
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
12901
12902
return texture(uLightMap, shiftLight(lightCoords));
12903
}
12904
12905
#endif
12906
12907
12908
float diffuse(vec3 normal) {
12909
vec3 n2 = normal * normal * vec3(.6, .25, .8);
12910
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
12911
}
12912
struct Vertex {
12913
vec3 pos;
12914
vec2 texCoords;
12915
vec3 normal;
12916
};
12917
12918
struct BlockFrag {
12919
vec2 texCoords;
12920
vec4 color;
12921
float diffuse;
12922
vec2 light;
12923
};
12924
12925
#if defined(FRAGMENT_SHADER)
12926
void fragment(BlockFrag r) {
12927
vec4 tex = FLWBlockTexture(r.texCoords);
12928
12929
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
12930
12931
FLWFinalizeColor(color);
12932
}
12933
#endif
12934
12935
12936
12937
12938
struct Instance {
12939
vec2 light;
12940
vec4 color;
12941
mat4 transform;
12942
mat3 normalMat;
12943
};
12944
12945
#if defined(VERTEX_SHADER)
12946
BlockFrag vertex(Vertex v, Instance i) {
12947
vec4 worldPos = i.transform * vec4(v.pos, 1.);
12948
12949
vec3 norm = i.normalMat * v.normal;
12950
12951
FLWFinalizeWorldPos(worldPos);
12952
FLWFinalizeNormal(norm);
12953
12954
norm = normalize(norm);
12955
12956
BlockFrag b;
12957
b.diffuse = diffuse(norm);
12958
b.texCoords = v.texCoords;
12959
b.light = i.light;
12960
#if defined(DEBUG_NORMAL)
12961
b.color = vec4(norm, 1.);
12962
#else
12963
b.color = i.color;
12964
#endif
12965
return b;
12966
}
12967
#endif
12968
12969
in vec3 a_v_pos;
12970
in vec2 a_v_texCoords;
12971
in vec3 a_v_normal;
12972
in vec2 a_i_light;
12973
in vec4 a_i_color;
12974
in mat4 a_i_transform;
12975
in mat3 a_i_normalMat;
12976
out vec2 v2f_texCoords;
12977
out vec4 v2f_color;
12978
out float v2f_diffuse;
12979
out vec2 v2f_light;
12980
void main() {
12981
Vertex v;
12982
v.pos = a_v_pos;
12983
v.texCoords = a_v_texCoords;
12984
v.normal = a_v_normal;
12985
Instance i;
12986
i.light = a_i_light;
12987
i.color = a_i_color;
12988
i.transform = a_i_transform;
12989
i.normalMat = a_i_normalMat;
12990
BlockFrag o = vertex(v, i);
12991
v2f_texCoords = o.texCoords;
12992
v2f_color = o.color;
12993
v2f_diffuse = o.diffuse;
12994
v2f_light = o.light;
12995
}
12996
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
12997
12998
[17:17:49] [Render thread/ERROR]: #version 150
12999
#extension GL_ARB_conservative_depth : enable
13000
#define FRAGMENT_SHADER
13001
#if defined(VERTEX_SHADER)
13002
out float FragDistance;
13003
#elif defined(FRAGMENT_SHADER)
13004
in float FragDistance;
13005
#endif
13006
uniform vec4 uFogColor;
13007
uniform vec2 uFogRange;
13008
13009
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
13010
float distXZ = length(worldPos.xz - cameraPos.xz);
13011
float distY = abs(worldPos.y - cameraPos.y);
13012
return max(distXZ, distY);
13013
}
13014
13015
float cylindrical_distance(vec3 worldPos) {
13016
float distXZ = length(worldPos.xz);
13017
float distY = abs(worldPos.y);
13018
return max(distXZ, distY);
13019
}
13020
13021
float FLWFogFactor() {
13022
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13023
}
13024
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
13025
vec2 shiftLight(vec2 lm) {
13026
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
13027
}
13028
13029
13030
uniform sampler3D uLightVolume;
13031
13032
uniform sampler2D uBlockAtlas;
13033
uniform sampler2D uLightMap;
13034
13035
uniform vec3 uLightBoxSize;
13036
uniform vec3 uLightBoxMin;
13037
uniform mat4 uModel;
13038
13039
uniform float uTime;
13040
uniform mat4 uViewProjection;
13041
uniform vec3 uCameraPos;
13042
13043
void FLWFinalizeNormal(inout vec3 normal) {
13044
mat3 m;
13045
m[0] = uModel[0].xyz;
13046
m[1] = uModel[1].xyz;
13047
m[2] = uModel[2].xyz;
13048
normal = m * normal;
13049
}
13050
13051
#if defined(VERTEX_SHADER)
13052
13053
out vec3 BoxCoord;
13054
13055
void FLWFinalizeWorldPos(inout vec4 worldPos) {
13056
worldPos = uModel * worldPos;
13057
13058
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
13059
13060
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
13061
13062
gl_Position = uViewProjection * worldPos;
13063
}
13064
13065
#elif defined(FRAGMENT_SHADER)
13066
13067
13068
#define ALPHA_DISCARD 0.1
13069
// optimize discard usage
13070
#if defined(ALPHA_DISCARD)
13071
#if defined(GL_ARB_conservative_depth)
13072
layout (depth_greater) out float gl_FragDepth;
13073
#endif
13074
#endif
13075
13076
in vec3 BoxCoord;
13077
13078
out vec4 FragColor;
13079
13080
vec4 FLWBlockTexture(vec2 texCoords) {
13081
return texture(uBlockAtlas, texCoords);
13082
}
13083
13084
void FLWFinalizeColor(vec4 color) {
13085
float a = color.a;
13086
float fog = clamp(FLWFogFactor(), 0., 1.);
13087
13088
color = mix(uFogColor, color, fog);
13089
color.a = a;
13090
13091
#if defined(ALPHA_DISCARD)
13092
if (color.a < ALPHA_DISCARD) {
13093
discard;
13094
}
13095
#endif
13096
13097
FragColor = color;
13098
}
13099
13100
vec4 FLWLight(vec2 lightCoords) {
13101
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
13102
13103
return texture(uLightMap, shiftLight(lightCoords));
13104
}
13105
13106
#endif
13107
13108
13109
float diffuse(vec3 normal) {
13110
vec3 n2 = normal * normal * vec3(.6, .25, .8);
13111
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
13112
}
13113
struct Vertex {
13114
vec3 pos;
13115
vec2 texCoords;
13116
vec3 normal;
13117
};
13118
13119
struct BlockFrag {
13120
vec2 texCoords;
13121
vec4 color;
13122
float diffuse;
13123
vec2 light;
13124
};
13125
13126
#if defined(FRAGMENT_SHADER)
13127
void fragment(BlockFrag r) {
13128
vec4 tex = FLWBlockTexture(r.texCoords);
13129
13130
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
13131
13132
FLWFinalizeColor(color);
13133
}
13134
#endif
13135
13136
13137
13138
13139
struct Instance {
13140
vec2 light;
13141
vec4 color;
13142
mat4 transform;
13143
mat3 normalMat;
13144
};
13145
13146
#if defined(VERTEX_SHADER)
13147
BlockFrag vertex(Vertex v, Instance i) {
13148
vec4 worldPos = i.transform * vec4(v.pos, 1.);
13149
13150
vec3 norm = i.normalMat * v.normal;
13151
13152
FLWFinalizeWorldPos(worldPos);
13153
FLWFinalizeNormal(norm);
13154
13155
norm = normalize(norm);
13156
13157
BlockFrag b;
13158
b.diffuse = diffuse(norm);
13159
b.texCoords = v.texCoords;
13160
b.light = i.light;
13161
#if defined(DEBUG_NORMAL)
13162
b.color = vec4(norm, 1.);
13163
#else
13164
b.color = i.color;
13165
#endif
13166
return b;
13167
}
13168
#endif
13169
13170
in vec2 v2f_texCoords;
13171
in vec4 v2f_color;
13172
in float v2f_diffuse;
13173
in vec2 v2f_light;
13174
void main() {
13175
BlockFrag o;
13176
o.texCoords = v2f_texCoords;
13177
o.color = v2f_color;
13178
o.diffuse = v2f_diffuse;
13179
o.light = v2f_light;
13180
fragment(o);
13181
}
13182
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
13183
13184
[17:17:49] [Render thread/ERROR]: #version 150
13185
#extension GL_ARB_conservative_depth : enable
13186
#define VERTEX_SHADER
13187
#define DEBUG_NORMAL
13188
#if defined(VERTEX_SHADER)
13189
out float FragDistance;
13190
#elif defined(FRAGMENT_SHADER)
13191
in float FragDistance;
13192
#endif
13193
uniform vec4 uFogColor;
13194
uniform vec2 uFogRange;
13195
13196
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
13197
float distXZ = length(worldPos.xz - cameraPos.xz);
13198
float distY = abs(worldPos.y - cameraPos.y);
13199
return max(distXZ, distY);
13200
}
13201
13202
float cylindrical_distance(vec3 worldPos) {
13203
float distXZ = length(worldPos.xz);
13204
float distY = abs(worldPos.y);
13205
return max(distXZ, distY);
13206
}
13207
13208
float FLWFogFactor() {
13209
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13210
}
13211
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
13212
vec2 shiftLight(vec2 lm) {
13213
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
13214
}
13215
13216
13217
uniform sampler3D uLightVolume;
13218
13219
uniform sampler2D uBlockAtlas;
13220
uniform sampler2D uLightMap;
13221
13222
uniform vec3 uLightBoxSize;
13223
uniform vec3 uLightBoxMin;
13224
uniform mat4 uModel;
13225
13226
uniform float uTime;
13227
uniform mat4 uViewProjection;
13228
uniform vec3 uCameraPos;
13229
13230
void FLWFinalizeNormal(inout vec3 normal) {
13231
mat3 m;
13232
m[0] = uModel[0].xyz;
13233
m[1] = uModel[1].xyz;
13234
m[2] = uModel[2].xyz;
13235
normal = m * normal;
13236
}
13237
13238
#if defined(VERTEX_SHADER)
13239
13240
out vec3 BoxCoord;
13241
13242
void FLWFinalizeWorldPos(inout vec4 worldPos) {
13243
worldPos = uModel * worldPos;
13244
13245
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
13246
13247
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
13248
13249
gl_Position = uViewProjection * worldPos;
13250
}
13251
13252
#elif defined(FRAGMENT_SHADER)
13253
13254
13255
#define ALPHA_DISCARD 0.1
13256
// optimize discard usage
13257
#if defined(ALPHA_DISCARD)
13258
#if defined(GL_ARB_conservative_depth)
13259
layout (depth_greater) out float gl_FragDepth;
13260
#endif
13261
#endif
13262
13263
in vec3 BoxCoord;
13264
13265
out vec4 FragColor;
13266
13267
vec4 FLWBlockTexture(vec2 texCoords) {
13268
return texture(uBlockAtlas, texCoords);
13269
}
13270
13271
void FLWFinalizeColor(vec4 color) {
13272
float a = color.a;
13273
float fog = clamp(FLWFogFactor(), 0., 1.);
13274
13275
color = mix(uFogColor, color, fog);
13276
color.a = a;
13277
13278
#if defined(ALPHA_DISCARD)
13279
if (color.a < ALPHA_DISCARD) {
13280
discard;
13281
}
13282
#endif
13283
13284
FragColor = color;
13285
}
13286
13287
vec4 FLWLight(vec2 lightCoords) {
13288
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
13289
13290
return texture(uLightMap, shiftLight(lightCoords));
13291
}
13292
13293
#endif
13294
13295
13296
float diffuse(vec3 normal) {
13297
vec3 n2 = normal * normal * vec3(.6, .25, .8);
13298
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
13299
}
13300
struct Vertex {
13301
vec3 pos;
13302
vec2 texCoords;
13303
vec3 normal;
13304
};
13305
13306
struct BlockFrag {
13307
vec2 texCoords;
13308
vec4 color;
13309
float diffuse;
13310
vec2 light;
13311
};
13312
13313
#if defined(FRAGMENT_SHADER)
13314
void fragment(BlockFrag r) {
13315
vec4 tex = FLWBlockTexture(r.texCoords);
13316
13317
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
13318
13319
FLWFinalizeColor(color);
13320
}
13321
#endif
13322
13323
13324
13325
13326
struct Instance {
13327
vec2 light;
13328
vec4 color;
13329
mat4 transform;
13330
mat3 normalMat;
13331
};
13332
13333
#if defined(VERTEX_SHADER)
13334
BlockFrag vertex(Vertex v, Instance i) {
13335
vec4 worldPos = i.transform * vec4(v.pos, 1.);
13336
13337
vec3 norm = i.normalMat * v.normal;
13338
13339
FLWFinalizeWorldPos(worldPos);
13340
FLWFinalizeNormal(norm);
13341
13342
norm = normalize(norm);
13343
13344
BlockFrag b;
13345
b.diffuse = diffuse(norm);
13346
b.texCoords = v.texCoords;
13347
b.light = i.light;
13348
#if defined(DEBUG_NORMAL)
13349
b.color = vec4(norm, 1.);
13350
#else
13351
b.color = i.color;
13352
#endif
13353
return b;
13354
}
13355
#endif
13356
13357
in vec3 a_v_pos;
13358
in vec2 a_v_texCoords;
13359
in vec3 a_v_normal;
13360
in vec2 a_i_light;
13361
in vec4 a_i_color;
13362
in mat4 a_i_transform;
13363
in mat3 a_i_normalMat;
13364
out vec2 v2f_texCoords;
13365
out vec4 v2f_color;
13366
out float v2f_diffuse;
13367
out vec2 v2f_light;
13368
void main() {
13369
Vertex v;
13370
v.pos = a_v_pos;
13371
v.texCoords = a_v_texCoords;
13372
v.normal = a_v_normal;
13373
Instance i;
13374
i.light = a_i_light;
13375
i.color = a_i_color;
13376
i.transform = a_i_transform;
13377
i.normalMat = a_i_normalMat;
13378
BlockFrag o = vertex(v, i);
13379
v2f_texCoords = o.texCoords;
13380
v2f_color = o.color;
13381
v2f_diffuse = o.diffuse;
13382
v2f_light = o.light;
13383
}
13384
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:model: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
13385
13386
[17:17:49] [Render thread/ERROR]: #version 150
13387
#extension GL_ARB_conservative_depth : enable
13388
#define FRAGMENT_SHADER
13389
#define DEBUG_NORMAL
13390
#if defined(VERTEX_SHADER)
13391
out float FragDistance;
13392
#elif defined(FRAGMENT_SHADER)
13393
in float FragDistance;
13394
#endif
13395
uniform vec4 uFogColor;
13396
uniform vec2 uFogRange;
13397
13398
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
13399
float distXZ = length(worldPos.xz - cameraPos.xz);
13400
float distY = abs(worldPos.y - cameraPos.y);
13401
return max(distXZ, distY);
13402
}
13403
13404
float cylindrical_distance(vec3 worldPos) {
13405
float distXZ = length(worldPos.xz);
13406
float distY = abs(worldPos.y);
13407
return max(distXZ, distY);
13408
}
13409
13410
float FLWFogFactor() {
13411
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13412
}
13413
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
13414
vec2 shiftLight(vec2 lm) {
13415
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
13416
}
13417
13418
13419
uniform sampler3D uLightVolume;
13420
13421
uniform sampler2D uBlockAtlas;
13422
uniform sampler2D uLightMap;
13423
13424
uniform vec3 uLightBoxSize;
13425
uniform vec3 uLightBoxMin;
13426
uniform mat4 uModel;
13427
13428
uniform float uTime;
13429
uniform mat4 uViewProjection;
13430
uniform vec3 uCameraPos;
13431
13432
void FLWFinalizeNormal(inout vec3 normal) {
13433
mat3 m;
13434
m[0] = uModel[0].xyz;
13435
m[1] = uModel[1].xyz;
13436
m[2] = uModel[2].xyz;
13437
normal = m * normal;
13438
}
13439
13440
#if defined(VERTEX_SHADER)
13441
13442
out vec3 BoxCoord;
13443
13444
void FLWFinalizeWorldPos(inout vec4 worldPos) {
13445
worldPos = uModel * worldPos;
13446
13447
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
13448
13449
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
13450
13451
gl_Position = uViewProjection * worldPos;
13452
}
13453
13454
#elif defined(FRAGMENT_SHADER)
13455
13456
13457
#define ALPHA_DISCARD 0.1
13458
// optimize discard usage
13459
#if defined(ALPHA_DISCARD)
13460
#if defined(GL_ARB_conservative_depth)
13461
layout (depth_greater) out float gl_FragDepth;
13462
#endif
13463
#endif
13464
13465
in vec3 BoxCoord;
13466
13467
out vec4 FragColor;
13468
13469
vec4 FLWBlockTexture(vec2 texCoords) {
13470
return texture(uBlockAtlas, texCoords);
13471
}
13472
13473
void FLWFinalizeColor(vec4 color) {
13474
float a = color.a;
13475
float fog = clamp(FLWFogFactor(), 0., 1.);
13476
13477
color = mix(uFogColor, color, fog);
13478
color.a = a;
13479
13480
#if defined(ALPHA_DISCARD)
13481
if (color.a < ALPHA_DISCARD) {
13482
discard;
13483
}
13484
#endif
13485
13486
FragColor = color;
13487
}
13488
13489
vec4 FLWLight(vec2 lightCoords) {
13490
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
13491
13492
return texture(uLightMap, shiftLight(lightCoords));
13493
}
13494
13495
#endif
13496
13497
13498
float diffuse(vec3 normal) {
13499
vec3 n2 = normal * normal * vec3(.6, .25, .8);
13500
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
13501
}
13502
struct Vertex {
13503
vec3 pos;
13504
vec2 texCoords;
13505
vec3 normal;
13506
};
13507
13508
struct BlockFrag {
13509
vec2 texCoords;
13510
vec4 color;
13511
float diffuse;
13512
vec2 light;
13513
};
13514
13515
#if defined(FRAGMENT_SHADER)
13516
void fragment(BlockFrag r) {
13517
vec4 tex = FLWBlockTexture(r.texCoords);
13518
13519
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
13520
13521
FLWFinalizeColor(color);
13522
}
13523
#endif
13524
13525
13526
13527
13528
struct Instance {
13529
vec2 light;
13530
vec4 color;
13531
mat4 transform;
13532
mat3 normalMat;
13533
};
13534
13535
#if defined(VERTEX_SHADER)
13536
BlockFrag vertex(Vertex v, Instance i) {
13537
vec4 worldPos = i.transform * vec4(v.pos, 1.);
13538
13539
vec3 norm = i.normalMat * v.normal;
13540
13541
FLWFinalizeWorldPos(worldPos);
13542
FLWFinalizeNormal(norm);
13543
13544
norm = normalize(norm);
13545
13546
BlockFrag b;
13547
b.diffuse = diffuse(norm);
13548
b.texCoords = v.texCoords;
13549
b.light = i.light;
13550
#if defined(DEBUG_NORMAL)
13551
b.color = vec4(norm, 1.);
13552
#else
13553
b.color = i.color;
13554
#endif
13555
return b;
13556
}
13557
#endif
13558
13559
in vec2 v2f_texCoords;
13560
in vec4 v2f_color;
13561
in float v2f_diffuse;
13562
in vec2 v2f_light;
13563
void main() {
13564
BlockFrag o;
13565
o.texCoords = v2f_texCoords;
13566
o.color = v2f_color;
13567
o.diffuse = v2f_diffuse;
13568
o.light = v2f_light;
13569
fragment(o);
13570
}
13571
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
13572
13573
[17:17:49] [Render thread/ERROR]: #version 150
13574
#extension GL_ARB_conservative_depth : enable
13575
#define VERTEX_SHADER
13576
#if defined(VERTEX_SHADER)
13577
out float FragDistance;
13578
#elif defined(FRAGMENT_SHADER)
13579
in float FragDistance;
13580
#endif
13581
uniform vec4 uFogColor;
13582
uniform vec2 uFogRange;
13583
13584
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
13585
float distXZ = length(worldPos.xz - cameraPos.xz);
13586
float distY = abs(worldPos.y - cameraPos.y);
13587
return max(distXZ, distY);
13588
}
13589
13590
float cylindrical_distance(vec3 worldPos) {
13591
float distXZ = length(worldPos.xz);
13592
float distY = abs(worldPos.y);
13593
return max(distXZ, distY);
13594
}
13595
13596
float FLWFogFactor() {
13597
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13598
}
13599
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
13600
vec2 shiftLight(vec2 lm) {
13601
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
13602
}
13603
13604
13605
uniform sampler3D uLightVolume;
13606
13607
uniform sampler2D uBlockAtlas;
13608
uniform sampler2D uLightMap;
13609
13610
uniform vec3 uLightBoxSize;
13611
uniform vec3 uLightBoxMin;
13612
uniform mat4 uModel;
13613
13614
uniform float uTime;
13615
uniform mat4 uViewProjection;
13616
uniform vec3 uCameraPos;
13617
13618
void FLWFinalizeNormal(inout vec3 normal) {
13619
mat3 m;
13620
m[0] = uModel[0].xyz;
13621
m[1] = uModel[1].xyz;
13622
m[2] = uModel[2].xyz;
13623
normal = m * normal;
13624
}
13625
13626
#if defined(VERTEX_SHADER)
13627
13628
out vec3 BoxCoord;
13629
13630
void FLWFinalizeWorldPos(inout vec4 worldPos) {
13631
worldPos = uModel * worldPos;
13632
13633
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
13634
13635
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
13636
13637
gl_Position = uViewProjection * worldPos;
13638
}
13639
13640
#elif defined(FRAGMENT_SHADER)
13641
13642
13643
#define ALPHA_DISCARD 0.1
13644
// optimize discard usage
13645
#if defined(ALPHA_DISCARD)
13646
#if defined(GL_ARB_conservative_depth)
13647
layout (depth_greater) out float gl_FragDepth;
13648
#endif
13649
#endif
13650
13651
in vec3 BoxCoord;
13652
13653
out vec4 FragColor;
13654
13655
vec4 FLWBlockTexture(vec2 texCoords) {
13656
return texture(uBlockAtlas, texCoords);
13657
}
13658
13659
void FLWFinalizeColor(vec4 color) {
13660
float a = color.a;
13661
float fog = clamp(FLWFogFactor(), 0., 1.);
13662
13663
color = mix(uFogColor, color, fog);
13664
color.a = a;
13665
13666
#if defined(ALPHA_DISCARD)
13667
if (color.a < ALPHA_DISCARD) {
13668
discard;
13669
}
13670
#endif
13671
13672
FragColor = color;
13673
}
13674
13675
vec4 FLWLight(vec2 lightCoords) {
13676
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
13677
13678
return texture(uLightMap, shiftLight(lightCoords));
13679
}
13680
13681
#endif
13682
13683
13684
#define PIOVER2 1.5707963268
13685
13686
vec4 quat(vec3 axis, float angle) {
13687
float halfAngle = angle * PIOVER2 / 180.0;
13688
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
13689
return vec4(axis.xyz * cs.y, cs.x);
13690
}
13691
13692
vec4 quatMult(vec4 q1, vec4 q2) {
13693
// disgustingly vectorized quaternion multiplication
13694
vec4 a = q1.w * q2.xyzw;
13695
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
13696
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
13697
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
13698
13699
return a + b + c + d;
13700
}
13701
13702
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
13703
vec3 i = q.xyz;
13704
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
13705
}
13706
13707
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
13708
return rotateVertexByQuat(v, quat(axis, angle));
13709
}
13710
13711
float diffuse(vec3 normal) {
13712
vec3 n2 = normal * normal * vec3(.6, .25, .8);
13713
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
13714
}
13715
struct Vertex {
13716
vec3 pos;
13717
vec2 texCoords;
13718
vec3 normal;
13719
};
13720
13721
struct BlockFrag {
13722
vec2 texCoords;
13723
vec4 color;
13724
float diffuse;
13725
vec2 light;
13726
};
13727
13728
#if defined(FRAGMENT_SHADER)
13729
void fragment(BlockFrag r) {
13730
vec4 tex = FLWBlockTexture(r.texCoords);
13731
13732
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
13733
13734
FLWFinalizeColor(color);
13735
}
13736
#endif
13737
13738
13739
13740
13741
13742
13743
struct Oriented {
13744
vec2 light;
13745
vec4 color;
13746
vec3 pos;
13747
vec3 pivot;
13748
vec4 rotation;
13749
};
13750
13751
#if defined(VERTEX_SHADER)
13752
BlockFrag vertex(Vertex v, Oriented o) {
13753
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
13754
13755
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
13756
13757
FLWFinalizeWorldPos(worldPos);
13758
FLWFinalizeNormal(norm);
13759
13760
BlockFrag b;
13761
b.diffuse = diffuse(norm);
13762
b.texCoords = v.texCoords;
13763
b.light = o.light;
13764
#if defined(DEBUG_NORMAL)
13765
b.color = vec4(norm, 1.);
13766
#else
13767
b.color = o.color;
13768
#endif
13769
return b;
13770
}
13771
#endif
13772
13773
in vec3 a_v_pos;
13774
in vec2 a_v_texCoords;
13775
in vec3 a_v_normal;
13776
in vec2 a_i_light;
13777
in vec4 a_i_color;
13778
in vec3 a_i_pos;
13779
in vec3 a_i_pivot;
13780
in vec4 a_i_rotation;
13781
out vec2 v2f_texCoords;
13782
out vec4 v2f_color;
13783
out float v2f_diffuse;
13784
out vec2 v2f_light;
13785
void main() {
13786
Vertex v;
13787
v.pos = a_v_pos;
13788
v.texCoords = a_v_texCoords;
13789
v.normal = a_v_normal;
13790
Oriented i;
13791
i.light = a_i_light;
13792
i.color = a_i_color;
13793
i.pos = a_i_pos;
13794
i.pivot = a_i_pivot;
13795
i.rotation = a_i_rotation;
13796
BlockFrag o = vertex(v, i);
13797
v2f_texCoords = o.texCoords;
13798
v2f_color = o.color;
13799
v2f_diffuse = o.diffuse;
13800
v2f_light = o.light;
13801
}
13802
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
13803
13804
[17:17:49] [Render thread/ERROR]: #version 150
13805
#extension GL_ARB_conservative_depth : enable
13806
#define FRAGMENT_SHADER
13807
#if defined(VERTEX_SHADER)
13808
out float FragDistance;
13809
#elif defined(FRAGMENT_SHADER)
13810
in float FragDistance;
13811
#endif
13812
uniform vec4 uFogColor;
13813
uniform vec2 uFogRange;
13814
13815
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
13816
float distXZ = length(worldPos.xz - cameraPos.xz);
13817
float distY = abs(worldPos.y - cameraPos.y);
13818
return max(distXZ, distY);
13819
}
13820
13821
float cylindrical_distance(vec3 worldPos) {
13822
float distXZ = length(worldPos.xz);
13823
float distY = abs(worldPos.y);
13824
return max(distXZ, distY);
13825
}
13826
13827
float FLWFogFactor() {
13828
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13829
}
13830
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
13831
vec2 shiftLight(vec2 lm) {
13832
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
13833
}
13834
13835
13836
uniform sampler3D uLightVolume;
13837
13838
uniform sampler2D uBlockAtlas;
13839
uniform sampler2D uLightMap;
13840
13841
uniform vec3 uLightBoxSize;
13842
uniform vec3 uLightBoxMin;
13843
uniform mat4 uModel;
13844
13845
uniform float uTime;
13846
uniform mat4 uViewProjection;
13847
uniform vec3 uCameraPos;
13848
13849
void FLWFinalizeNormal(inout vec3 normal) {
13850
mat3 m;
13851
m[0] = uModel[0].xyz;
13852
m[1] = uModel[1].xyz;
13853
m[2] = uModel[2].xyz;
13854
normal = m * normal;
13855
}
13856
13857
#if defined(VERTEX_SHADER)
13858
13859
out vec3 BoxCoord;
13860
13861
void FLWFinalizeWorldPos(inout vec4 worldPos) {
13862
worldPos = uModel * worldPos;
13863
13864
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
13865
13866
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
13867
13868
gl_Position = uViewProjection * worldPos;
13869
}
13870
13871
#elif defined(FRAGMENT_SHADER)
13872
13873
13874
#define ALPHA_DISCARD 0.1
13875
// optimize discard usage
13876
#if defined(ALPHA_DISCARD)
13877
#if defined(GL_ARB_conservative_depth)
13878
layout (depth_greater) out float gl_FragDepth;
13879
#endif
13880
#endif
13881
13882
in vec3 BoxCoord;
13883
13884
out vec4 FragColor;
13885
13886
vec4 FLWBlockTexture(vec2 texCoords) {
13887
return texture(uBlockAtlas, texCoords);
13888
}
13889
13890
void FLWFinalizeColor(vec4 color) {
13891
float a = color.a;
13892
float fog = clamp(FLWFogFactor(), 0., 1.);
13893
13894
color = mix(uFogColor, color, fog);
13895
color.a = a;
13896
13897
#if defined(ALPHA_DISCARD)
13898
if (color.a < ALPHA_DISCARD) {
13899
discard;
13900
}
13901
#endif
13902
13903
FragColor = color;
13904
}
13905
13906
vec4 FLWLight(vec2 lightCoords) {
13907
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
13908
13909
return texture(uLightMap, shiftLight(lightCoords));
13910
}
13911
13912
#endif
13913
13914
13915
#define PIOVER2 1.5707963268
13916
13917
vec4 quat(vec3 axis, float angle) {
13918
float halfAngle = angle * PIOVER2 / 180.0;
13919
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
13920
return vec4(axis.xyz * cs.y, cs.x);
13921
}
13922
13923
vec4 quatMult(vec4 q1, vec4 q2) {
13924
// disgustingly vectorized quaternion multiplication
13925
vec4 a = q1.w * q2.xyzw;
13926
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
13927
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
13928
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
13929
13930
return a + b + c + d;
13931
}
13932
13933
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
13934
vec3 i = q.xyz;
13935
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
13936
}
13937
13938
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
13939
return rotateVertexByQuat(v, quat(axis, angle));
13940
}
13941
13942
float diffuse(vec3 normal) {
13943
vec3 n2 = normal * normal * vec3(.6, .25, .8);
13944
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
13945
}
13946
struct Vertex {
13947
vec3 pos;
13948
vec2 texCoords;
13949
vec3 normal;
13950
};
13951
13952
struct BlockFrag {
13953
vec2 texCoords;
13954
vec4 color;
13955
float diffuse;
13956
vec2 light;
13957
};
13958
13959
#if defined(FRAGMENT_SHADER)
13960
void fragment(BlockFrag r) {
13961
vec4 tex = FLWBlockTexture(r.texCoords);
13962
13963
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
13964
13965
FLWFinalizeColor(color);
13966
}
13967
#endif
13968
13969
13970
13971
13972
13973
13974
struct Oriented {
13975
vec2 light;
13976
vec4 color;
13977
vec3 pos;
13978
vec3 pivot;
13979
vec4 rotation;
13980
};
13981
13982
#if defined(VERTEX_SHADER)
13983
BlockFrag vertex(Vertex v, Oriented o) {
13984
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
13985
13986
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
13987
13988
FLWFinalizeWorldPos(worldPos);
13989
FLWFinalizeNormal(norm);
13990
13991
BlockFrag b;
13992
b.diffuse = diffuse(norm);
13993
b.texCoords = v.texCoords;
13994
b.light = o.light;
13995
#if defined(DEBUG_NORMAL)
13996
b.color = vec4(norm, 1.);
13997
#else
13998
b.color = o.color;
13999
#endif
14000
return b;
14001
}
14002
#endif
14003
14004
in vec2 v2f_texCoords;
14005
in vec4 v2f_color;
14006
in float v2f_diffuse;
14007
in vec2 v2f_light;
14008
void main() {
14009
BlockFrag o;
14010
o.texCoords = v2f_texCoords;
14011
o.color = v2f_color;
14012
o.diffuse = v2f_diffuse;
14013
o.light = v2f_light;
14014
fragment(o);
14015
}
14016
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
14017
14018
[17:17:49] [Render thread/ERROR]: #version 150
14019
#extension GL_ARB_conservative_depth : enable
14020
#define VERTEX_SHADER
14021
#define DEBUG_NORMAL
14022
#if defined(VERTEX_SHADER)
14023
out float FragDistance;
14024
#elif defined(FRAGMENT_SHADER)
14025
in float FragDistance;
14026
#endif
14027
uniform vec4 uFogColor;
14028
uniform vec2 uFogRange;
14029
14030
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
14031
float distXZ = length(worldPos.xz - cameraPos.xz);
14032
float distY = abs(worldPos.y - cameraPos.y);
14033
return max(distXZ, distY);
14034
}
14035
14036
float cylindrical_distance(vec3 worldPos) {
14037
float distXZ = length(worldPos.xz);
14038
float distY = abs(worldPos.y);
14039
return max(distXZ, distY);
14040
}
14041
14042
float FLWFogFactor() {
14043
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14044
}
14045
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
14046
vec2 shiftLight(vec2 lm) {
14047
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
14048
}
14049
14050
14051
uniform sampler3D uLightVolume;
14052
14053
uniform sampler2D uBlockAtlas;
14054
uniform sampler2D uLightMap;
14055
14056
uniform vec3 uLightBoxSize;
14057
uniform vec3 uLightBoxMin;
14058
uniform mat4 uModel;
14059
14060
uniform float uTime;
14061
uniform mat4 uViewProjection;
14062
uniform vec3 uCameraPos;
14063
14064
void FLWFinalizeNormal(inout vec3 normal) {
14065
mat3 m;
14066
m[0] = uModel[0].xyz;
14067
m[1] = uModel[1].xyz;
14068
m[2] = uModel[2].xyz;
14069
normal = m * normal;
14070
}
14071
14072
#if defined(VERTEX_SHADER)
14073
14074
out vec3 BoxCoord;
14075
14076
void FLWFinalizeWorldPos(inout vec4 worldPos) {
14077
worldPos = uModel * worldPos;
14078
14079
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
14080
14081
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
14082
14083
gl_Position = uViewProjection * worldPos;
14084
}
14085
14086
#elif defined(FRAGMENT_SHADER)
14087
14088
14089
#define ALPHA_DISCARD 0.1
14090
// optimize discard usage
14091
#if defined(ALPHA_DISCARD)
14092
#if defined(GL_ARB_conservative_depth)
14093
layout (depth_greater) out float gl_FragDepth;
14094
#endif
14095
#endif
14096
14097
in vec3 BoxCoord;
14098
14099
out vec4 FragColor;
14100
14101
vec4 FLWBlockTexture(vec2 texCoords) {
14102
return texture(uBlockAtlas, texCoords);
14103
}
14104
14105
void FLWFinalizeColor(vec4 color) {
14106
float a = color.a;
14107
float fog = clamp(FLWFogFactor(), 0., 1.);
14108
14109
color = mix(uFogColor, color, fog);
14110
color.a = a;
14111
14112
#if defined(ALPHA_DISCARD)
14113
if (color.a < ALPHA_DISCARD) {
14114
discard;
14115
}
14116
#endif
14117
14118
FragColor = color;
14119
}
14120
14121
vec4 FLWLight(vec2 lightCoords) {
14122
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
14123
14124
return texture(uLightMap, shiftLight(lightCoords));
14125
}
14126
14127
#endif
14128
14129
14130
#define PIOVER2 1.5707963268
14131
14132
vec4 quat(vec3 axis, float angle) {
14133
float halfAngle = angle * PIOVER2 / 180.0;
14134
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
14135
return vec4(axis.xyz * cs.y, cs.x);
14136
}
14137
14138
vec4 quatMult(vec4 q1, vec4 q2) {
14139
// disgustingly vectorized quaternion multiplication
14140
vec4 a = q1.w * q2.xyzw;
14141
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
14142
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
14143
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
14144
14145
return a + b + c + d;
14146
}
14147
14148
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
14149
vec3 i = q.xyz;
14150
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
14151
}
14152
14153
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
14154
return rotateVertexByQuat(v, quat(axis, angle));
14155
}
14156
14157
float diffuse(vec3 normal) {
14158
vec3 n2 = normal * normal * vec3(.6, .25, .8);
14159
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
14160
}
14161
struct Vertex {
14162
vec3 pos;
14163
vec2 texCoords;
14164
vec3 normal;
14165
};
14166
14167
struct BlockFrag {
14168
vec2 texCoords;
14169
vec4 color;
14170
float diffuse;
14171
vec2 light;
14172
};
14173
14174
#if defined(FRAGMENT_SHADER)
14175
void fragment(BlockFrag r) {
14176
vec4 tex = FLWBlockTexture(r.texCoords);
14177
14178
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
14179
14180
FLWFinalizeColor(color);
14181
}
14182
#endif
14183
14184
14185
14186
14187
14188
14189
struct Oriented {
14190
vec2 light;
14191
vec4 color;
14192
vec3 pos;
14193
vec3 pivot;
14194
vec4 rotation;
14195
};
14196
14197
#if defined(VERTEX_SHADER)
14198
BlockFrag vertex(Vertex v, Oriented o) {
14199
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
14200
14201
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
14202
14203
FLWFinalizeWorldPos(worldPos);
14204
FLWFinalizeNormal(norm);
14205
14206
BlockFrag b;
14207
b.diffuse = diffuse(norm);
14208
b.texCoords = v.texCoords;
14209
b.light = o.light;
14210
#if defined(DEBUG_NORMAL)
14211
b.color = vec4(norm, 1.);
14212
#else
14213
b.color = o.color;
14214
#endif
14215
return b;
14216
}
14217
#endif
14218
14219
in vec3 a_v_pos;
14220
in vec2 a_v_texCoords;
14221
in vec3 a_v_normal;
14222
in vec2 a_i_light;
14223
in vec4 a_i_color;
14224
in vec3 a_i_pos;
14225
in vec3 a_i_pivot;
14226
in vec4 a_i_rotation;
14227
out vec2 v2f_texCoords;
14228
out vec4 v2f_color;
14229
out float v2f_diffuse;
14230
out vec2 v2f_light;
14231
void main() {
14232
Vertex v;
14233
v.pos = a_v_pos;
14234
v.texCoords = a_v_texCoords;
14235
v.normal = a_v_normal;
14236
Oriented i;
14237
i.light = a_i_light;
14238
i.color = a_i_color;
14239
i.pos = a_i_pos;
14240
i.pivot = a_i_pivot;
14241
i.rotation = a_i_rotation;
14242
BlockFrag o = vertex(v, i);
14243
v2f_texCoords = o.texCoords;
14244
v2f_color = o.color;
14245
v2f_diffuse = o.diffuse;
14246
v2f_light = o.light;
14247
}
14248
[17:17:49] [Render thread/ERROR]: Shader compilation log for flywheel:oriented: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
14249
14250
[17:17:49] [Render thread/ERROR]: #version 150
14251
#extension GL_ARB_conservative_depth : enable
14252
#define FRAGMENT_SHADER
14253
#define DEBUG_NORMAL
14254
#if defined(VERTEX_SHADER)
14255
out float FragDistance;
14256
#elif defined(FRAGMENT_SHADER)
14257
in float FragDistance;
14258
#endif
14259
uniform vec4 uFogColor;
14260
uniform vec2 uFogRange;
14261
14262
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
14263
float distXZ = length(worldPos.xz - cameraPos.xz);
14264
float distY = abs(worldPos.y - cameraPos.y);
14265
return max(distXZ, distY);
14266
}
14267
14268
float cylindrical_distance(vec3 worldPos) {
14269
float distXZ = length(worldPos.xz);
14270
float distY = abs(worldPos.y);
14271
return max(distXZ, distY);
14272
}
14273
14274
float FLWFogFactor() {
14275
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14276
}
14277
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
14278
vec2 shiftLight(vec2 lm) {
14279
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
14280
}
14281
14282
14283
uniform sampler3D uLightVolume;
14284
14285
uniform sampler2D uBlockAtlas;
14286
uniform sampler2D uLightMap;
14287
14288
uniform vec3 uLightBoxSize;
14289
uniform vec3 uLightBoxMin;
14290
uniform mat4 uModel;
14291
14292
uniform float uTime;
14293
uniform mat4 uViewProjection;
14294
uniform vec3 uCameraPos;
14295
14296
void FLWFinalizeNormal(inout vec3 normal) {
14297
mat3 m;
14298
m[0] = uModel[0].xyz;
14299
m[1] = uModel[1].xyz;
14300
m[2] = uModel[2].xyz;
14301
normal = m * normal;
14302
}
14303
14304
#if defined(VERTEX_SHADER)
14305
14306
out vec3 BoxCoord;
14307
14308
void FLWFinalizeWorldPos(inout vec4 worldPos) {
14309
worldPos = uModel * worldPos;
14310
14311
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
14312
14313
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
14314
14315
gl_Position = uViewProjection * worldPos;
14316
}
14317
14318
#elif defined(FRAGMENT_SHADER)
14319
14320
14321
#define ALPHA_DISCARD 0.1
14322
// optimize discard usage
14323
#if defined(ALPHA_DISCARD)
14324
#if defined(GL_ARB_conservative_depth)
14325
layout (depth_greater) out float gl_FragDepth;
14326
#endif
14327
#endif
14328
14329
in vec3 BoxCoord;
14330
14331
out vec4 FragColor;
14332
14333
vec4 FLWBlockTexture(vec2 texCoords) {
14334
return texture(uBlockAtlas, texCoords);
14335
}
14336
14337
void FLWFinalizeColor(vec4 color) {
14338
float a = color.a;
14339
float fog = clamp(FLWFogFactor(), 0., 1.);
14340
14341
color = mix(uFogColor, color, fog);
14342
color.a = a;
14343
14344
#if defined(ALPHA_DISCARD)
14345
if (color.a < ALPHA_DISCARD) {
14346
discard;
14347
}
14348
#endif
14349
14350
FragColor = color;
14351
}
14352
14353
vec4 FLWLight(vec2 lightCoords) {
14354
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
14355
14356
return texture(uLightMap, shiftLight(lightCoords));
14357
}
14358
14359
#endif
14360
14361
14362
#define PIOVER2 1.5707963268
14363
14364
vec4 quat(vec3 axis, float angle) {
14365
float halfAngle = angle * PIOVER2 / 180.0;
14366
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
14367
return vec4(axis.xyz * cs.y, cs.x);
14368
}
14369
14370
vec4 quatMult(vec4 q1, vec4 q2) {
14371
// disgustingly vectorized quaternion multiplication
14372
vec4 a = q1.w * q2.xyzw;
14373
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
14374
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
14375
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
14376
14377
return a + b + c + d;
14378
}
14379
14380
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
14381
vec3 i = q.xyz;
14382
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
14383
}
14384
14385
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
14386
return rotateVertexByQuat(v, quat(axis, angle));
14387
}
14388
14389
float diffuse(vec3 normal) {
14390
vec3 n2 = normal * normal * vec3(.6, .25, .8);
14391
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
14392
}
14393
struct Vertex {
14394
vec3 pos;
14395
vec2 texCoords;
14396
vec3 normal;
14397
};
14398
14399
struct BlockFrag {
14400
vec2 texCoords;
14401
vec4 color;
14402
float diffuse;
14403
vec2 light;
14404
};
14405
14406
#if defined(FRAGMENT_SHADER)
14407
void fragment(BlockFrag r) {
14408
vec4 tex = FLWBlockTexture(r.texCoords);
14409
14410
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
14411
14412
FLWFinalizeColor(color);
14413
}
14414
#endif
14415
14416
14417
14418
14419
14420
14421
struct Oriented {
14422
vec2 light;
14423
vec4 color;
14424
vec3 pos;
14425
vec3 pivot;
14426
vec4 rotation;
14427
};
14428
14429
#if defined(VERTEX_SHADER)
14430
BlockFrag vertex(Vertex v, Oriented o) {
14431
vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
14432
14433
vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
14434
14435
FLWFinalizeWorldPos(worldPos);
14436
FLWFinalizeNormal(norm);
14437
14438
BlockFrag b;
14439
b.diffuse = diffuse(norm);
14440
b.texCoords = v.texCoords;
14441
b.light = o.light;
14442
#if defined(DEBUG_NORMAL)
14443
b.color = vec4(norm, 1.);
14444
#else
14445
b.color = o.color;
14446
#endif
14447
return b;
14448
}
14449
#endif
14450
14451
in vec2 v2f_texCoords;
14452
in vec4 v2f_color;
14453
in float v2f_diffuse;
14454
in vec2 v2f_light;
14455
void main() {
14456
BlockFrag o;
14457
o.texCoords = v2f_texCoords;
14458
o.color = v2f_color;
14459
o.diffuse = v2f_diffuse;
14460
o.light = v2f_light;
14461
fragment(o);
14462
}
14463
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
14464
14465
[17:17:49] [Render thread/ERROR]: #version 150
14466
#extension GL_ARB_conservative_depth : enable
14467
#define VERTEX_SHADER
14468
#if defined(VERTEX_SHADER)
14469
out float FragDistance;
14470
#elif defined(FRAGMENT_SHADER)
14471
in float FragDistance;
14472
#endif
14473
uniform vec4 uFogColor;
14474
uniform vec2 uFogRange;
14475
14476
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
14477
float distXZ = length(worldPos.xz - cameraPos.xz);
14478
float distY = abs(worldPos.y - cameraPos.y);
14479
return max(distXZ, distY);
14480
}
14481
14482
float cylindrical_distance(vec3 worldPos) {
14483
float distXZ = length(worldPos.xz);
14484
float distY = abs(worldPos.y);
14485
return max(distXZ, distY);
14486
}
14487
14488
float FLWFogFactor() {
14489
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14490
}
14491
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
14492
vec2 shiftLight(vec2 lm) {
14493
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
14494
}
14495
14496
14497
uniform sampler3D uLightVolume;
14498
14499
uniform sampler2D uBlockAtlas;
14500
uniform sampler2D uLightMap;
14501
14502
uniform vec3 uLightBoxSize;
14503
uniform vec3 uLightBoxMin;
14504
uniform mat4 uModel;
14505
14506
uniform float uTime;
14507
uniform mat4 uViewProjection;
14508
uniform vec3 uCameraPos;
14509
14510
void FLWFinalizeNormal(inout vec3 normal) {
14511
mat3 m;
14512
m[0] = uModel[0].xyz;
14513
m[1] = uModel[1].xyz;
14514
m[2] = uModel[2].xyz;
14515
normal = m * normal;
14516
}
14517
14518
#if defined(VERTEX_SHADER)
14519
14520
out vec3 BoxCoord;
14521
14522
void FLWFinalizeWorldPos(inout vec4 worldPos) {
14523
worldPos = uModel * worldPos;
14524
14525
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
14526
14527
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
14528
14529
gl_Position = uViewProjection * worldPos;
14530
}
14531
14532
#elif defined(FRAGMENT_SHADER)
14533
14534
14535
#define ALPHA_DISCARD 0.1
14536
// optimize discard usage
14537
#if defined(ALPHA_DISCARD)
14538
#if defined(GL_ARB_conservative_depth)
14539
layout (depth_greater) out float gl_FragDepth;
14540
#endif
14541
#endif
14542
14543
in vec3 BoxCoord;
14544
14545
out vec4 FragColor;
14546
14547
vec4 FLWBlockTexture(vec2 texCoords) {
14548
return texture(uBlockAtlas, texCoords);
14549
}
14550
14551
void FLWFinalizeColor(vec4 color) {
14552
float a = color.a;
14553
float fog = clamp(FLWFogFactor(), 0., 1.);
14554
14555
color = mix(uFogColor, color, fog);
14556
color.a = a;
14557
14558
#if defined(ALPHA_DISCARD)
14559
if (color.a < ALPHA_DISCARD) {
14560
discard;
14561
}
14562
#endif
14563
14564
FragColor = color;
14565
}
14566
14567
vec4 FLWLight(vec2 lightCoords) {
14568
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
14569
14570
return texture(uLightMap, shiftLight(lightCoords));
14571
}
14572
14573
#endif
14574
14575
14576
mat4 rotate(vec3 axis, float angle) {
14577
float s = sin(angle);
14578
float c = cos(angle);
14579
float oc = 1. - c;
14580
14581
vec3 sa = axis * s;
14582
14583
mat4 mr = mat4(1.);
14584
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
14585
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
14586
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
14587
14588
return mr;
14589
}
14590
14591
mat4 rotation(vec3 rot) {
14592
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
14593
}
14594
14595
mat3 modelToNormal(mat4 mat) {
14596
// Discard the edges. This won't be accurate for scaled or skewed matrices,
14597
// but we don't have to work with those often.
14598
mat3 m;
14599
m[0] = mat[0].xyz;
14600
m[1] = mat[1].xyz;
14601
m[2] = mat[2].xyz;
14602
return m;
14603
}
14604
14605
float diffuse(vec3 normal) {
14606
vec3 n2 = normal * normal * vec3(.6, .25, .8);
14607
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
14608
}
14609
struct Vertex {
14610
vec3 pos;
14611
vec2 texCoords;
14612
vec3 normal;
14613
};
14614
14615
struct BlockFrag {
14616
vec2 texCoords;
14617
vec4 color;
14618
float diffuse;
14619
vec2 light;
14620
};
14621
14622
#if defined(FRAGMENT_SHADER)
14623
void fragment(BlockFrag r) {
14624
vec4 tex = FLWBlockTexture(r.texCoords);
14625
14626
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
14627
14628
FLWFinalizeColor(color);
14629
}
14630
#endif
14631
#define PI 3.1415926538
14632
14633
14634
14635
14636
struct Rotating {
14637
vec2 light;
14638
vec4 color;
14639
vec3 pos;
14640
float speed;
14641
float offset;
14642
vec3 axis;
14643
};
14644
14645
14646
14647
14648
mat4 kineticRotation(float offset, float speed, vec3 axis) {
14649
float degrees = offset + uTime * speed * 3./10.;
14650
float angle = fract(degrees / 360.) * PI * 2.;
14651
14652
return rotate(axis, angle);
14653
}
14654
14655
#if defined(VERTEX_SHADER)
14656
BlockFrag vertex(Vertex v, Rotating instance) {
14657
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
14658
14659
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
14660
worldPos += vec4(instance.pos + .5, 0.);
14661
14662
vec3 norm = modelToNormal(spin) * v.normal;
14663
14664
FLWFinalizeWorldPos(worldPos);
14665
FLWFinalizeNormal(norm);
14666
14667
BlockFrag b;
14668
b.diffuse = diffuse(norm);
14669
b.texCoords = v.texCoords;
14670
b.light = instance.light;
14671
14672
#if defined(DEBUG_RAINBOW)
14673
b.color = instance.color;
14674
#elif defined(DEBUG_NORMAL)
14675
b.color = vec4(norm, 1.);
14676
#else
14677
b.color = vec4(1.);
14678
#endif
14679
14680
return b;
14681
}
14682
#endif
14683
14684
in vec3 a_v_pos;
14685
in vec2 a_v_texCoords;
14686
in vec3 a_v_normal;
14687
in vec2 a_i_light;
14688
in vec4 a_i_color;
14689
in vec3 a_i_pos;
14690
in float a_i_speed;
14691
in float a_i_offset;
14692
in vec3 a_i_axis;
14693
out vec2 v2f_texCoords;
14694
out vec4 v2f_color;
14695
out float v2f_diffuse;
14696
out vec2 v2f_light;
14697
void main() {
14698
Vertex v;
14699
v.pos = a_v_pos;
14700
v.texCoords = a_v_texCoords;
14701
v.normal = a_v_normal;
14702
Rotating i;
14703
i.light = a_i_light;
14704
i.color = a_i_color;
14705
i.pos = a_i_pos;
14706
i.speed = a_i_speed;
14707
i.offset = a_i_offset;
14708
i.axis = a_i_axis;
14709
BlockFrag o = vertex(v, i);
14710
v2f_texCoords = o.texCoords;
14711
v2f_color = o.color;
14712
v2f_diffuse = o.diffuse;
14713
v2f_light = o.light;
14714
}
14715
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
14716
14717
[17:17:49] [Render thread/ERROR]: #version 150
14718
#extension GL_ARB_conservative_depth : enable
14719
#define FRAGMENT_SHADER
14720
#if defined(VERTEX_SHADER)
14721
out float FragDistance;
14722
#elif defined(FRAGMENT_SHADER)
14723
in float FragDistance;
14724
#endif
14725
uniform vec4 uFogColor;
14726
uniform vec2 uFogRange;
14727
14728
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
14729
float distXZ = length(worldPos.xz - cameraPos.xz);
14730
float distY = abs(worldPos.y - cameraPos.y);
14731
return max(distXZ, distY);
14732
}
14733
14734
float cylindrical_distance(vec3 worldPos) {
14735
float distXZ = length(worldPos.xz);
14736
float distY = abs(worldPos.y);
14737
return max(distXZ, distY);
14738
}
14739
14740
float FLWFogFactor() {
14741
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14742
}
14743
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
14744
vec2 shiftLight(vec2 lm) {
14745
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
14746
}
14747
14748
14749
uniform sampler3D uLightVolume;
14750
14751
uniform sampler2D uBlockAtlas;
14752
uniform sampler2D uLightMap;
14753
14754
uniform vec3 uLightBoxSize;
14755
uniform vec3 uLightBoxMin;
14756
uniform mat4 uModel;
14757
14758
uniform float uTime;
14759
uniform mat4 uViewProjection;
14760
uniform vec3 uCameraPos;
14761
14762
void FLWFinalizeNormal(inout vec3 normal) {
14763
mat3 m;
14764
m[0] = uModel[0].xyz;
14765
m[1] = uModel[1].xyz;
14766
m[2] = uModel[2].xyz;
14767
normal = m * normal;
14768
}
14769
14770
#if defined(VERTEX_SHADER)
14771
14772
out vec3 BoxCoord;
14773
14774
void FLWFinalizeWorldPos(inout vec4 worldPos) {
14775
worldPos = uModel * worldPos;
14776
14777
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
14778
14779
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
14780
14781
gl_Position = uViewProjection * worldPos;
14782
}
14783
14784
#elif defined(FRAGMENT_SHADER)
14785
14786
14787
#define ALPHA_DISCARD 0.1
14788
// optimize discard usage
14789
#if defined(ALPHA_DISCARD)
14790
#if defined(GL_ARB_conservative_depth)
14791
layout (depth_greater) out float gl_FragDepth;
14792
#endif
14793
#endif
14794
14795
in vec3 BoxCoord;
14796
14797
out vec4 FragColor;
14798
14799
vec4 FLWBlockTexture(vec2 texCoords) {
14800
return texture(uBlockAtlas, texCoords);
14801
}
14802
14803
void FLWFinalizeColor(vec4 color) {
14804
float a = color.a;
14805
float fog = clamp(FLWFogFactor(), 0., 1.);
14806
14807
color = mix(uFogColor, color, fog);
14808
color.a = a;
14809
14810
#if defined(ALPHA_DISCARD)
14811
if (color.a < ALPHA_DISCARD) {
14812
discard;
14813
}
14814
#endif
14815
14816
FragColor = color;
14817
}
14818
14819
vec4 FLWLight(vec2 lightCoords) {
14820
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
14821
14822
return texture(uLightMap, shiftLight(lightCoords));
14823
}
14824
14825
#endif
14826
14827
14828
mat4 rotate(vec3 axis, float angle) {
14829
float s = sin(angle);
14830
float c = cos(angle);
14831
float oc = 1. - c;
14832
14833
vec3 sa = axis * s;
14834
14835
mat4 mr = mat4(1.);
14836
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
14837
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
14838
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
14839
14840
return mr;
14841
}
14842
14843
mat4 rotation(vec3 rot) {
14844
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
14845
}
14846
14847
mat3 modelToNormal(mat4 mat) {
14848
// Discard the edges. This won't be accurate for scaled or skewed matrices,
14849
// but we don't have to work with those often.
14850
mat3 m;
14851
m[0] = mat[0].xyz;
14852
m[1] = mat[1].xyz;
14853
m[2] = mat[2].xyz;
14854
return m;
14855
}
14856
14857
float diffuse(vec3 normal) {
14858
vec3 n2 = normal * normal * vec3(.6, .25, .8);
14859
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
14860
}
14861
struct Vertex {
14862
vec3 pos;
14863
vec2 texCoords;
14864
vec3 normal;
14865
};
14866
14867
struct BlockFrag {
14868
vec2 texCoords;
14869
vec4 color;
14870
float diffuse;
14871
vec2 light;
14872
};
14873
14874
#if defined(FRAGMENT_SHADER)
14875
void fragment(BlockFrag r) {
14876
vec4 tex = FLWBlockTexture(r.texCoords);
14877
14878
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
14879
14880
FLWFinalizeColor(color);
14881
}
14882
#endif
14883
#define PI 3.1415926538
14884
14885
14886
14887
14888
struct Rotating {
14889
vec2 light;
14890
vec4 color;
14891
vec3 pos;
14892
float speed;
14893
float offset;
14894
vec3 axis;
14895
};
14896
14897
14898
14899
14900
mat4 kineticRotation(float offset, float speed, vec3 axis) {
14901
float degrees = offset + uTime * speed * 3./10.;
14902
float angle = fract(degrees / 360.) * PI * 2.;
14903
14904
return rotate(axis, angle);
14905
}
14906
14907
#if defined(VERTEX_SHADER)
14908
BlockFrag vertex(Vertex v, Rotating instance) {
14909
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
14910
14911
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
14912
worldPos += vec4(instance.pos + .5, 0.);
14913
14914
vec3 norm = modelToNormal(spin) * v.normal;
14915
14916
FLWFinalizeWorldPos(worldPos);
14917
FLWFinalizeNormal(norm);
14918
14919
BlockFrag b;
14920
b.diffuse = diffuse(norm);
14921
b.texCoords = v.texCoords;
14922
b.light = instance.light;
14923
14924
#if defined(DEBUG_RAINBOW)
14925
b.color = instance.color;
14926
#elif defined(DEBUG_NORMAL)
14927
b.color = vec4(norm, 1.);
14928
#else
14929
b.color = vec4(1.);
14930
#endif
14931
14932
return b;
14933
}
14934
#endif
14935
14936
in vec2 v2f_texCoords;
14937
in vec4 v2f_color;
14938
in float v2f_diffuse;
14939
in vec2 v2f_light;
14940
void main() {
14941
BlockFrag o;
14942
o.texCoords = v2f_texCoords;
14943
o.color = v2f_color;
14944
o.diffuse = v2f_diffuse;
14945
o.light = v2f_light;
14946
fragment(o);
14947
}
14948
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
14949
14950
[17:17:49] [Render thread/ERROR]: #version 150
14951
#extension GL_ARB_conservative_depth : enable
14952
#define VERTEX_SHADER
14953
#define DEBUG_RAINBOW
14954
#if defined(VERTEX_SHADER)
14955
out float FragDistance;
14956
#elif defined(FRAGMENT_SHADER)
14957
in float FragDistance;
14958
#endif
14959
uniform vec4 uFogColor;
14960
uniform vec2 uFogRange;
14961
14962
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
14963
float distXZ = length(worldPos.xz - cameraPos.xz);
14964
float distY = abs(worldPos.y - cameraPos.y);
14965
return max(distXZ, distY);
14966
}
14967
14968
float cylindrical_distance(vec3 worldPos) {
14969
float distXZ = length(worldPos.xz);
14970
float distY = abs(worldPos.y);
14971
return max(distXZ, distY);
14972
}
14973
14974
float FLWFogFactor() {
14975
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14976
}
14977
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
14978
vec2 shiftLight(vec2 lm) {
14979
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
14980
}
14981
14982
14983
uniform sampler3D uLightVolume;
14984
14985
uniform sampler2D uBlockAtlas;
14986
uniform sampler2D uLightMap;
14987
14988
uniform vec3 uLightBoxSize;
14989
uniform vec3 uLightBoxMin;
14990
uniform mat4 uModel;
14991
14992
uniform float uTime;
14993
uniform mat4 uViewProjection;
14994
uniform vec3 uCameraPos;
14995
14996
void FLWFinalizeNormal(inout vec3 normal) {
14997
mat3 m;
14998
m[0] = uModel[0].xyz;
14999
m[1] = uModel[1].xyz;
15000
m[2] = uModel[2].xyz;
15001
normal = m * normal;
15002
}
15003
15004
#if defined(VERTEX_SHADER)
15005
15006
out vec3 BoxCoord;
15007
15008
void FLWFinalizeWorldPos(inout vec4 worldPos) {
15009
worldPos = uModel * worldPos;
15010
15011
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
15012
15013
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
15014
15015
gl_Position = uViewProjection * worldPos;
15016
}
15017
15018
#elif defined(FRAGMENT_SHADER)
15019
15020
15021
#define ALPHA_DISCARD 0.1
15022
// optimize discard usage
15023
#if defined(ALPHA_DISCARD)
15024
#if defined(GL_ARB_conservative_depth)
15025
layout (depth_greater) out float gl_FragDepth;
15026
#endif
15027
#endif
15028
15029
in vec3 BoxCoord;
15030
15031
out vec4 FragColor;
15032
15033
vec4 FLWBlockTexture(vec2 texCoords) {
15034
return texture(uBlockAtlas, texCoords);
15035
}
15036
15037
void FLWFinalizeColor(vec4 color) {
15038
float a = color.a;
15039
float fog = clamp(FLWFogFactor(), 0., 1.);
15040
15041
color = mix(uFogColor, color, fog);
15042
color.a = a;
15043
15044
#if defined(ALPHA_DISCARD)
15045
if (color.a < ALPHA_DISCARD) {
15046
discard;
15047
}
15048
#endif
15049
15050
FragColor = color;
15051
}
15052
15053
vec4 FLWLight(vec2 lightCoords) {
15054
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
15055
15056
return texture(uLightMap, shiftLight(lightCoords));
15057
}
15058
15059
#endif
15060
15061
15062
mat4 rotate(vec3 axis, float angle) {
15063
float s = sin(angle);
15064
float c = cos(angle);
15065
float oc = 1. - c;
15066
15067
vec3 sa = axis * s;
15068
15069
mat4 mr = mat4(1.);
15070
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
15071
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
15072
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
15073
15074
return mr;
15075
}
15076
15077
mat4 rotation(vec3 rot) {
15078
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
15079
}
15080
15081
mat3 modelToNormal(mat4 mat) {
15082
// Discard the edges. This won't be accurate for scaled or skewed matrices,
15083
// but we don't have to work with those often.
15084
mat3 m;
15085
m[0] = mat[0].xyz;
15086
m[1] = mat[1].xyz;
15087
m[2] = mat[2].xyz;
15088
return m;
15089
}
15090
15091
float diffuse(vec3 normal) {
15092
vec3 n2 = normal * normal * vec3(.6, .25, .8);
15093
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
15094
}
15095
struct Vertex {
15096
vec3 pos;
15097
vec2 texCoords;
15098
vec3 normal;
15099
};
15100
15101
struct BlockFrag {
15102
vec2 texCoords;
15103
vec4 color;
15104
float diffuse;
15105
vec2 light;
15106
};
15107
15108
#if defined(FRAGMENT_SHADER)
15109
void fragment(BlockFrag r) {
15110
vec4 tex = FLWBlockTexture(r.texCoords);
15111
15112
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
15113
15114
FLWFinalizeColor(color);
15115
}
15116
#endif
15117
#define PI 3.1415926538
15118
15119
15120
15121
15122
struct Rotating {
15123
vec2 light;
15124
vec4 color;
15125
vec3 pos;
15126
float speed;
15127
float offset;
15128
vec3 axis;
15129
};
15130
15131
15132
15133
15134
mat4 kineticRotation(float offset, float speed, vec3 axis) {
15135
float degrees = offset + uTime * speed * 3./10.;
15136
float angle = fract(degrees / 360.) * PI * 2.;
15137
15138
return rotate(axis, angle);
15139
}
15140
15141
#if defined(VERTEX_SHADER)
15142
BlockFrag vertex(Vertex v, Rotating instance) {
15143
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
15144
15145
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
15146
worldPos += vec4(instance.pos + .5, 0.);
15147
15148
vec3 norm = modelToNormal(spin) * v.normal;
15149
15150
FLWFinalizeWorldPos(worldPos);
15151
FLWFinalizeNormal(norm);
15152
15153
BlockFrag b;
15154
b.diffuse = diffuse(norm);
15155
b.texCoords = v.texCoords;
15156
b.light = instance.light;
15157
15158
#if defined(DEBUG_RAINBOW)
15159
b.color = instance.color;
15160
#elif defined(DEBUG_NORMAL)
15161
b.color = vec4(norm, 1.);
15162
#else
15163
b.color = vec4(1.);
15164
#endif
15165
15166
return b;
15167
}
15168
#endif
15169
15170
in vec3 a_v_pos;
15171
in vec2 a_v_texCoords;
15172
in vec3 a_v_normal;
15173
in vec2 a_i_light;
15174
in vec4 a_i_color;
15175
in vec3 a_i_pos;
15176
in float a_i_speed;
15177
in float a_i_offset;
15178
in vec3 a_i_axis;
15179
out vec2 v2f_texCoords;
15180
out vec4 v2f_color;
15181
out float v2f_diffuse;
15182
out vec2 v2f_light;
15183
void main() {
15184
Vertex v;
15185
v.pos = a_v_pos;
15186
v.texCoords = a_v_texCoords;
15187
v.normal = a_v_normal;
15188
Rotating i;
15189
i.light = a_i_light;
15190
i.color = a_i_color;
15191
i.pos = a_i_pos;
15192
i.speed = a_i_speed;
15193
i.offset = a_i_offset;
15194
i.axis = a_i_axis;
15195
BlockFrag o = vertex(v, i);
15196
v2f_texCoords = o.texCoords;
15197
v2f_color = o.color;
15198
v2f_diffuse = o.diffuse;
15199
v2f_light = o.light;
15200
}
15201
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
15202
15203
[17:17:49] [Render thread/ERROR]: #version 150
15204
#extension GL_ARB_conservative_depth : enable
15205
#define FRAGMENT_SHADER
15206
#define DEBUG_RAINBOW
15207
#if defined(VERTEX_SHADER)
15208
out float FragDistance;
15209
#elif defined(FRAGMENT_SHADER)
15210
in float FragDistance;
15211
#endif
15212
uniform vec4 uFogColor;
15213
uniform vec2 uFogRange;
15214
15215
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
15216
float distXZ = length(worldPos.xz - cameraPos.xz);
15217
float distY = abs(worldPos.y - cameraPos.y);
15218
return max(distXZ, distY);
15219
}
15220
15221
float cylindrical_distance(vec3 worldPos) {
15222
float distXZ = length(worldPos.xz);
15223
float distY = abs(worldPos.y);
15224
return max(distXZ, distY);
15225
}
15226
15227
float FLWFogFactor() {
15228
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15229
}
15230
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
15231
vec2 shiftLight(vec2 lm) {
15232
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
15233
}
15234
15235
15236
uniform sampler3D uLightVolume;
15237
15238
uniform sampler2D uBlockAtlas;
15239
uniform sampler2D uLightMap;
15240
15241
uniform vec3 uLightBoxSize;
15242
uniform vec3 uLightBoxMin;
15243
uniform mat4 uModel;
15244
15245
uniform float uTime;
15246
uniform mat4 uViewProjection;
15247
uniform vec3 uCameraPos;
15248
15249
void FLWFinalizeNormal(inout vec3 normal) {
15250
mat3 m;
15251
m[0] = uModel[0].xyz;
15252
m[1] = uModel[1].xyz;
15253
m[2] = uModel[2].xyz;
15254
normal = m * normal;
15255
}
15256
15257
#if defined(VERTEX_SHADER)
15258
15259
out vec3 BoxCoord;
15260
15261
void FLWFinalizeWorldPos(inout vec4 worldPos) {
15262
worldPos = uModel * worldPos;
15263
15264
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
15265
15266
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
15267
15268
gl_Position = uViewProjection * worldPos;
15269
}
15270
15271
#elif defined(FRAGMENT_SHADER)
15272
15273
15274
#define ALPHA_DISCARD 0.1
15275
// optimize discard usage
15276
#if defined(ALPHA_DISCARD)
15277
#if defined(GL_ARB_conservative_depth)
15278
layout (depth_greater) out float gl_FragDepth;
15279
#endif
15280
#endif
15281
15282
in vec3 BoxCoord;
15283
15284
out vec4 FragColor;
15285
15286
vec4 FLWBlockTexture(vec2 texCoords) {
15287
return texture(uBlockAtlas, texCoords);
15288
}
15289
15290
void FLWFinalizeColor(vec4 color) {
15291
float a = color.a;
15292
float fog = clamp(FLWFogFactor(), 0., 1.);
15293
15294
color = mix(uFogColor, color, fog);
15295
color.a = a;
15296
15297
#if defined(ALPHA_DISCARD)
15298
if (color.a < ALPHA_DISCARD) {
15299
discard;
15300
}
15301
#endif
15302
15303
FragColor = color;
15304
}
15305
15306
vec4 FLWLight(vec2 lightCoords) {
15307
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
15308
15309
return texture(uLightMap, shiftLight(lightCoords));
15310
}
15311
15312
#endif
15313
15314
15315
mat4 rotate(vec3 axis, float angle) {
15316
float s = sin(angle);
15317
float c = cos(angle);
15318
float oc = 1. - c;
15319
15320
vec3 sa = axis * s;
15321
15322
mat4 mr = mat4(1.);
15323
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
15324
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
15325
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
15326
15327
return mr;
15328
}
15329
15330
mat4 rotation(vec3 rot) {
15331
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
15332
}
15333
15334
mat3 modelToNormal(mat4 mat) {
15335
// Discard the edges. This won't be accurate for scaled or skewed matrices,
15336
// but we don't have to work with those often.
15337
mat3 m;
15338
m[0] = mat[0].xyz;
15339
m[1] = mat[1].xyz;
15340
m[2] = mat[2].xyz;
15341
return m;
15342
}
15343
15344
float diffuse(vec3 normal) {
15345
vec3 n2 = normal * normal * vec3(.6, .25, .8);
15346
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
15347
}
15348
struct Vertex {
15349
vec3 pos;
15350
vec2 texCoords;
15351
vec3 normal;
15352
};
15353
15354
struct BlockFrag {
15355
vec2 texCoords;
15356
vec4 color;
15357
float diffuse;
15358
vec2 light;
15359
};
15360
15361
#if defined(FRAGMENT_SHADER)
15362
void fragment(BlockFrag r) {
15363
vec4 tex = FLWBlockTexture(r.texCoords);
15364
15365
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
15366
15367
FLWFinalizeColor(color);
15368
}
15369
#endif
15370
#define PI 3.1415926538
15371
15372
15373
15374
15375
struct Rotating {
15376
vec2 light;
15377
vec4 color;
15378
vec3 pos;
15379
float speed;
15380
float offset;
15381
vec3 axis;
15382
};
15383
15384
15385
15386
15387
mat4 kineticRotation(float offset, float speed, vec3 axis) {
15388
float degrees = offset + uTime * speed * 3./10.;
15389
float angle = fract(degrees / 360.) * PI * 2.;
15390
15391
return rotate(axis, angle);
15392
}
15393
15394
#if defined(VERTEX_SHADER)
15395
BlockFrag vertex(Vertex v, Rotating instance) {
15396
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
15397
15398
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
15399
worldPos += vec4(instance.pos + .5, 0.);
15400
15401
vec3 norm = modelToNormal(spin) * v.normal;
15402
15403
FLWFinalizeWorldPos(worldPos);
15404
FLWFinalizeNormal(norm);
15405
15406
BlockFrag b;
15407
b.diffuse = diffuse(norm);
15408
b.texCoords = v.texCoords;
15409
b.light = instance.light;
15410
15411
#if defined(DEBUG_RAINBOW)
15412
b.color = instance.color;
15413
#elif defined(DEBUG_NORMAL)
15414
b.color = vec4(norm, 1.);
15415
#else
15416
b.color = vec4(1.);
15417
#endif
15418
15419
return b;
15420
}
15421
#endif
15422
15423
in vec2 v2f_texCoords;
15424
in vec4 v2f_color;
15425
in float v2f_diffuse;
15426
in vec2 v2f_light;
15427
void main() {
15428
BlockFrag o;
15429
o.texCoords = v2f_texCoords;
15430
o.color = v2f_color;
15431
o.diffuse = v2f_diffuse;
15432
o.light = v2f_light;
15433
fragment(o);
15434
}
15435
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
15436
15437
[17:17:49] [Render thread/ERROR]: #version 150
15438
#extension GL_ARB_conservative_depth : enable
15439
#define VERTEX_SHADER
15440
#define DEBUG_NORMAL
15441
#if defined(VERTEX_SHADER)
15442
out float FragDistance;
15443
#elif defined(FRAGMENT_SHADER)
15444
in float FragDistance;
15445
#endif
15446
uniform vec4 uFogColor;
15447
uniform vec2 uFogRange;
15448
15449
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
15450
float distXZ = length(worldPos.xz - cameraPos.xz);
15451
float distY = abs(worldPos.y - cameraPos.y);
15452
return max(distXZ, distY);
15453
}
15454
15455
float cylindrical_distance(vec3 worldPos) {
15456
float distXZ = length(worldPos.xz);
15457
float distY = abs(worldPos.y);
15458
return max(distXZ, distY);
15459
}
15460
15461
float FLWFogFactor() {
15462
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15463
}
15464
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
15465
vec2 shiftLight(vec2 lm) {
15466
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
15467
}
15468
15469
15470
uniform sampler3D uLightVolume;
15471
15472
uniform sampler2D uBlockAtlas;
15473
uniform sampler2D uLightMap;
15474
15475
uniform vec3 uLightBoxSize;
15476
uniform vec3 uLightBoxMin;
15477
uniform mat4 uModel;
15478
15479
uniform float uTime;
15480
uniform mat4 uViewProjection;
15481
uniform vec3 uCameraPos;
15482
15483
void FLWFinalizeNormal(inout vec3 normal) {
15484
mat3 m;
15485
m[0] = uModel[0].xyz;
15486
m[1] = uModel[1].xyz;
15487
m[2] = uModel[2].xyz;
15488
normal = m * normal;
15489
}
15490
15491
#if defined(VERTEX_SHADER)
15492
15493
out vec3 BoxCoord;
15494
15495
void FLWFinalizeWorldPos(inout vec4 worldPos) {
15496
worldPos = uModel * worldPos;
15497
15498
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
15499
15500
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
15501
15502
gl_Position = uViewProjection * worldPos;
15503
}
15504
15505
#elif defined(FRAGMENT_SHADER)
15506
15507
15508
#define ALPHA_DISCARD 0.1
15509
// optimize discard usage
15510
#if defined(ALPHA_DISCARD)
15511
#if defined(GL_ARB_conservative_depth)
15512
layout (depth_greater) out float gl_FragDepth;
15513
#endif
15514
#endif
15515
15516
in vec3 BoxCoord;
15517
15518
out vec4 FragColor;
15519
15520
vec4 FLWBlockTexture(vec2 texCoords) {
15521
return texture(uBlockAtlas, texCoords);
15522
}
15523
15524
void FLWFinalizeColor(vec4 color) {
15525
float a = color.a;
15526
float fog = clamp(FLWFogFactor(), 0., 1.);
15527
15528
color = mix(uFogColor, color, fog);
15529
color.a = a;
15530
15531
#if defined(ALPHA_DISCARD)
15532
if (color.a < ALPHA_DISCARD) {
15533
discard;
15534
}
15535
#endif
15536
15537
FragColor = color;
15538
}
15539
15540
vec4 FLWLight(vec2 lightCoords) {
15541
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
15542
15543
return texture(uLightMap, shiftLight(lightCoords));
15544
}
15545
15546
#endif
15547
15548
15549
mat4 rotate(vec3 axis, float angle) {
15550
float s = sin(angle);
15551
float c = cos(angle);
15552
float oc = 1. - c;
15553
15554
vec3 sa = axis * s;
15555
15556
mat4 mr = mat4(1.);
15557
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
15558
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
15559
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
15560
15561
return mr;
15562
}
15563
15564
mat4 rotation(vec3 rot) {
15565
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
15566
}
15567
15568
mat3 modelToNormal(mat4 mat) {
15569
// Discard the edges. This won't be accurate for scaled or skewed matrices,
15570
// but we don't have to work with those often.
15571
mat3 m;
15572
m[0] = mat[0].xyz;
15573
m[1] = mat[1].xyz;
15574
m[2] = mat[2].xyz;
15575
return m;
15576
}
15577
15578
float diffuse(vec3 normal) {
15579
vec3 n2 = normal * normal * vec3(.6, .25, .8);
15580
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
15581
}
15582
struct Vertex {
15583
vec3 pos;
15584
vec2 texCoords;
15585
vec3 normal;
15586
};
15587
15588
struct BlockFrag {
15589
vec2 texCoords;
15590
vec4 color;
15591
float diffuse;
15592
vec2 light;
15593
};
15594
15595
#if defined(FRAGMENT_SHADER)
15596
void fragment(BlockFrag r) {
15597
vec4 tex = FLWBlockTexture(r.texCoords);
15598
15599
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
15600
15601
FLWFinalizeColor(color);
15602
}
15603
#endif
15604
#define PI 3.1415926538
15605
15606
15607
15608
15609
struct Rotating {
15610
vec2 light;
15611
vec4 color;
15612
vec3 pos;
15613
float speed;
15614
float offset;
15615
vec3 axis;
15616
};
15617
15618
15619
15620
15621
mat4 kineticRotation(float offset, float speed, vec3 axis) {
15622
float degrees = offset + uTime * speed * 3./10.;
15623
float angle = fract(degrees / 360.) * PI * 2.;
15624
15625
return rotate(axis, angle);
15626
}
15627
15628
#if defined(VERTEX_SHADER)
15629
BlockFrag vertex(Vertex v, Rotating instance) {
15630
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
15631
15632
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
15633
worldPos += vec4(instance.pos + .5, 0.);
15634
15635
vec3 norm = modelToNormal(spin) * v.normal;
15636
15637
FLWFinalizeWorldPos(worldPos);
15638
FLWFinalizeNormal(norm);
15639
15640
BlockFrag b;
15641
b.diffuse = diffuse(norm);
15642
b.texCoords = v.texCoords;
15643
b.light = instance.light;
15644
15645
#if defined(DEBUG_RAINBOW)
15646
b.color = instance.color;
15647
#elif defined(DEBUG_NORMAL)
15648
b.color = vec4(norm, 1.);
15649
#else
15650
b.color = vec4(1.);
15651
#endif
15652
15653
return b;
15654
}
15655
#endif
15656
15657
in vec3 a_v_pos;
15658
in vec2 a_v_texCoords;
15659
in vec3 a_v_normal;
15660
in vec2 a_i_light;
15661
in vec4 a_i_color;
15662
in vec3 a_i_pos;
15663
in float a_i_speed;
15664
in float a_i_offset;
15665
in vec3 a_i_axis;
15666
out vec2 v2f_texCoords;
15667
out vec4 v2f_color;
15668
out float v2f_diffuse;
15669
out vec2 v2f_light;
15670
void main() {
15671
Vertex v;
15672
v.pos = a_v_pos;
15673
v.texCoords = a_v_texCoords;
15674
v.normal = a_v_normal;
15675
Rotating i;
15676
i.light = a_i_light;
15677
i.color = a_i_color;
15678
i.pos = a_i_pos;
15679
i.speed = a_i_speed;
15680
i.offset = a_i_offset;
15681
i.axis = a_i_axis;
15682
BlockFrag o = vertex(v, i);
15683
v2f_texCoords = o.texCoords;
15684
v2f_color = o.color;
15685
v2f_diffuse = o.diffuse;
15686
v2f_light = o.light;
15687
}
15688
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:rotating: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
15689
15690
[17:17:49] [Render thread/ERROR]: #version 150
15691
#extension GL_ARB_conservative_depth : enable
15692
#define FRAGMENT_SHADER
15693
#define DEBUG_NORMAL
15694
#if defined(VERTEX_SHADER)
15695
out float FragDistance;
15696
#elif defined(FRAGMENT_SHADER)
15697
in float FragDistance;
15698
#endif
15699
uniform vec4 uFogColor;
15700
uniform vec2 uFogRange;
15701
15702
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
15703
float distXZ = length(worldPos.xz - cameraPos.xz);
15704
float distY = abs(worldPos.y - cameraPos.y);
15705
return max(distXZ, distY);
15706
}
15707
15708
float cylindrical_distance(vec3 worldPos) {
15709
float distXZ = length(worldPos.xz);
15710
float distY = abs(worldPos.y);
15711
return max(distXZ, distY);
15712
}
15713
15714
float FLWFogFactor() {
15715
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15716
}
15717
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
15718
vec2 shiftLight(vec2 lm) {
15719
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
15720
}
15721
15722
15723
uniform sampler3D uLightVolume;
15724
15725
uniform sampler2D uBlockAtlas;
15726
uniform sampler2D uLightMap;
15727
15728
uniform vec3 uLightBoxSize;
15729
uniform vec3 uLightBoxMin;
15730
uniform mat4 uModel;
15731
15732
uniform float uTime;
15733
uniform mat4 uViewProjection;
15734
uniform vec3 uCameraPos;
15735
15736
void FLWFinalizeNormal(inout vec3 normal) {
15737
mat3 m;
15738
m[0] = uModel[0].xyz;
15739
m[1] = uModel[1].xyz;
15740
m[2] = uModel[2].xyz;
15741
normal = m * normal;
15742
}
15743
15744
#if defined(VERTEX_SHADER)
15745
15746
out vec3 BoxCoord;
15747
15748
void FLWFinalizeWorldPos(inout vec4 worldPos) {
15749
worldPos = uModel * worldPos;
15750
15751
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
15752
15753
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
15754
15755
gl_Position = uViewProjection * worldPos;
15756
}
15757
15758
#elif defined(FRAGMENT_SHADER)
15759
15760
15761
#define ALPHA_DISCARD 0.1
15762
// optimize discard usage
15763
#if defined(ALPHA_DISCARD)
15764
#if defined(GL_ARB_conservative_depth)
15765
layout (depth_greater) out float gl_FragDepth;
15766
#endif
15767
#endif
15768
15769
in vec3 BoxCoord;
15770
15771
out vec4 FragColor;
15772
15773
vec4 FLWBlockTexture(vec2 texCoords) {
15774
return texture(uBlockAtlas, texCoords);
15775
}
15776
15777
void FLWFinalizeColor(vec4 color) {
15778
float a = color.a;
15779
float fog = clamp(FLWFogFactor(), 0., 1.);
15780
15781
color = mix(uFogColor, color, fog);
15782
color.a = a;
15783
15784
#if defined(ALPHA_DISCARD)
15785
if (color.a < ALPHA_DISCARD) {
15786
discard;
15787
}
15788
#endif
15789
15790
FragColor = color;
15791
}
15792
15793
vec4 FLWLight(vec2 lightCoords) {
15794
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
15795
15796
return texture(uLightMap, shiftLight(lightCoords));
15797
}
15798
15799
#endif
15800
15801
15802
mat4 rotate(vec3 axis, float angle) {
15803
float s = sin(angle);
15804
float c = cos(angle);
15805
float oc = 1. - c;
15806
15807
vec3 sa = axis * s;
15808
15809
mat4 mr = mat4(1.);
15810
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
15811
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
15812
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
15813
15814
return mr;
15815
}
15816
15817
mat4 rotation(vec3 rot) {
15818
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
15819
}
15820
15821
mat3 modelToNormal(mat4 mat) {
15822
// Discard the edges. This won't be accurate for scaled or skewed matrices,
15823
// but we don't have to work with those often.
15824
mat3 m;
15825
m[0] = mat[0].xyz;
15826
m[1] = mat[1].xyz;
15827
m[2] = mat[2].xyz;
15828
return m;
15829
}
15830
15831
float diffuse(vec3 normal) {
15832
vec3 n2 = normal * normal * vec3(.6, .25, .8);
15833
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
15834
}
15835
struct Vertex {
15836
vec3 pos;
15837
vec2 texCoords;
15838
vec3 normal;
15839
};
15840
15841
struct BlockFrag {
15842
vec2 texCoords;
15843
vec4 color;
15844
float diffuse;
15845
vec2 light;
15846
};
15847
15848
#if defined(FRAGMENT_SHADER)
15849
void fragment(BlockFrag r) {
15850
vec4 tex = FLWBlockTexture(r.texCoords);
15851
15852
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
15853
15854
FLWFinalizeColor(color);
15855
}
15856
#endif
15857
#define PI 3.1415926538
15858
15859
15860
15861
15862
struct Rotating {
15863
vec2 light;
15864
vec4 color;
15865
vec3 pos;
15866
float speed;
15867
float offset;
15868
vec3 axis;
15869
};
15870
15871
15872
15873
15874
mat4 kineticRotation(float offset, float speed, vec3 axis) {
15875
float degrees = offset + uTime * speed * 3./10.;
15876
float angle = fract(degrees / 360.) * PI * 2.;
15877
15878
return rotate(axis, angle);
15879
}
15880
15881
#if defined(VERTEX_SHADER)
15882
BlockFrag vertex(Vertex v, Rotating instance) {
15883
mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
15884
15885
vec4 worldPos = spin * vec4(v.pos - .5, 1.);
15886
worldPos += vec4(instance.pos + .5, 0.);
15887
15888
vec3 norm = modelToNormal(spin) * v.normal;
15889
15890
FLWFinalizeWorldPos(worldPos);
15891
FLWFinalizeNormal(norm);
15892
15893
BlockFrag b;
15894
b.diffuse = diffuse(norm);
15895
b.texCoords = v.texCoords;
15896
b.light = instance.light;
15897
15898
#if defined(DEBUG_RAINBOW)
15899
b.color = instance.color;
15900
#elif defined(DEBUG_NORMAL)
15901
b.color = vec4(norm, 1.);
15902
#else
15903
b.color = vec4(1.);
15904
#endif
15905
15906
return b;
15907
}
15908
#endif
15909
15910
in vec2 v2f_texCoords;
15911
in vec4 v2f_color;
15912
in float v2f_diffuse;
15913
in vec2 v2f_light;
15914
void main() {
15915
BlockFrag o;
15916
o.texCoords = v2f_texCoords;
15917
o.color = v2f_color;
15918
o.diffuse = v2f_diffuse;
15919
o.light = v2f_light;
15920
fragment(o);
15921
}
15922
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
15923
15924
[17:17:49] [Render thread/ERROR]: #version 150
15925
#extension GL_ARB_conservative_depth : enable
15926
#define VERTEX_SHADER
15927
#if defined(VERTEX_SHADER)
15928
out float FragDistance;
15929
#elif defined(FRAGMENT_SHADER)
15930
in float FragDistance;
15931
#endif
15932
uniform vec4 uFogColor;
15933
uniform vec2 uFogRange;
15934
15935
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
15936
float distXZ = length(worldPos.xz - cameraPos.xz);
15937
float distY = abs(worldPos.y - cameraPos.y);
15938
return max(distXZ, distY);
15939
}
15940
15941
float cylindrical_distance(vec3 worldPos) {
15942
float distXZ = length(worldPos.xz);
15943
float distY = abs(worldPos.y);
15944
return max(distXZ, distY);
15945
}
15946
15947
float FLWFogFactor() {
15948
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15949
}
15950
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
15951
vec2 shiftLight(vec2 lm) {
15952
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
15953
}
15954
15955
15956
uniform sampler3D uLightVolume;
15957
15958
uniform sampler2D uBlockAtlas;
15959
uniform sampler2D uLightMap;
15960
15961
uniform vec3 uLightBoxSize;
15962
uniform vec3 uLightBoxMin;
15963
uniform mat4 uModel;
15964
15965
uniform float uTime;
15966
uniform mat4 uViewProjection;
15967
uniform vec3 uCameraPos;
15968
15969
void FLWFinalizeNormal(inout vec3 normal) {
15970
mat3 m;
15971
m[0] = uModel[0].xyz;
15972
m[1] = uModel[1].xyz;
15973
m[2] = uModel[2].xyz;
15974
normal = m * normal;
15975
}
15976
15977
#if defined(VERTEX_SHADER)
15978
15979
out vec3 BoxCoord;
15980
15981
void FLWFinalizeWorldPos(inout vec4 worldPos) {
15982
worldPos = uModel * worldPos;
15983
15984
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
15985
15986
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
15987
15988
gl_Position = uViewProjection * worldPos;
15989
}
15990
15991
#elif defined(FRAGMENT_SHADER)
15992
15993
15994
#define ALPHA_DISCARD 0.1
15995
// optimize discard usage
15996
#if defined(ALPHA_DISCARD)
15997
#if defined(GL_ARB_conservative_depth)
15998
layout (depth_greater) out float gl_FragDepth;
15999
#endif
16000
#endif
16001
16002
in vec3 BoxCoord;
16003
16004
out vec4 FragColor;
16005
16006
vec4 FLWBlockTexture(vec2 texCoords) {
16007
return texture(uBlockAtlas, texCoords);
16008
}
16009
16010
void FLWFinalizeColor(vec4 color) {
16011
float a = color.a;
16012
float fog = clamp(FLWFogFactor(), 0., 1.);
16013
16014
color = mix(uFogColor, color, fog);
16015
color.a = a;
16016
16017
#if defined(ALPHA_DISCARD)
16018
if (color.a < ALPHA_DISCARD) {
16019
discard;
16020
}
16021
#endif
16022
16023
FragColor = color;
16024
}
16025
16026
vec4 FLWLight(vec2 lightCoords) {
16027
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
16028
16029
return texture(uLightMap, shiftLight(lightCoords));
16030
}
16031
16032
#endif
16033
16034
16035
mat4 rotate(vec3 axis, float angle) {
16036
float s = sin(angle);
16037
float c = cos(angle);
16038
float oc = 1. - c;
16039
16040
vec3 sa = axis * s;
16041
16042
mat4 mr = mat4(1.);
16043
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
16044
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
16045
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
16046
16047
return mr;
16048
}
16049
16050
mat4 rotation(vec3 rot) {
16051
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
16052
}
16053
16054
mat3 modelToNormal(mat4 mat) {
16055
// Discard the edges. This won't be accurate for scaled or skewed matrices,
16056
// but we don't have to work with those often.
16057
mat3 m;
16058
m[0] = mat[0].xyz;
16059
m[1] = mat[1].xyz;
16060
m[2] = mat[2].xyz;
16061
return m;
16062
}
16063
16064
#define PIOVER2 1.5707963268
16065
16066
vec4 quat(vec3 axis, float angle) {
16067
float halfAngle = angle * PIOVER2 / 180.0;
16068
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
16069
return vec4(axis.xyz * cs.y, cs.x);
16070
}
16071
16072
vec4 quatMult(vec4 q1, vec4 q2) {
16073
// disgustingly vectorized quaternion multiplication
16074
vec4 a = q1.w * q2.xyzw;
16075
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
16076
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
16077
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
16078
16079
return a + b + c + d;
16080
}
16081
16082
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
16083
vec3 i = q.xyz;
16084
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
16085
}
16086
16087
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
16088
return rotateVertexByQuat(v, quat(axis, angle));
16089
}
16090
16091
float diffuse(vec3 normal) {
16092
vec3 n2 = normal * normal * vec3(.6, .25, .8);
16093
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
16094
}
16095
struct Vertex {
16096
vec3 pos;
16097
vec2 texCoords;
16098
vec3 normal;
16099
};
16100
16101
struct BlockFrag {
16102
vec2 texCoords;
16103
vec4 color;
16104
float diffuse;
16105
vec2 light;
16106
};
16107
16108
#if defined(FRAGMENT_SHADER)
16109
void fragment(BlockFrag r) {
16110
vec4 tex = FLWBlockTexture(r.texCoords);
16111
16112
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
16113
16114
FLWFinalizeColor(color);
16115
}
16116
#endif
16117
#define PI 3.1415926538
16118
16119
16120
16121
16122
16123
struct Actor {
16124
vec3 pos;
16125
vec2 light;
16126
float offset;
16127
vec3 axis;
16128
vec4 rotation;
16129
vec3 rotationCenter;
16130
float speed;
16131
};
16132
16133
16134
16135
16136
#if defined(VERTEX_SHADER)
16137
BlockFrag vertex(Vertex v, Actor instance) {
16138
float degrees = instance.offset + uTime * instance.speed / 20.;
16139
//float angle = fract(degrees / 360.) * PI * 2.;
16140
16141
vec4 kineticRot = quat(instance.axis, degrees);
16142
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
16143
16144
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
16145
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
16146
16147
FLWFinalizeWorldPos(worldPos);
16148
FLWFinalizeNormal(norm);
16149
16150
BlockFrag b;
16151
b.diffuse = diffuse(norm);
16152
b.texCoords = v.texCoords;
16153
b.light = instance.light;
16154
16155
#if defined(DEBUG_NORMAL)
16156
b.color = vec4(norm, 1.);
16157
#else
16158
b.color = vec4(1.);
16159
#endif
16160
16161
return b;
16162
}
16163
#endif
16164
16165
in vec3 a_v_pos;
16166
in vec2 a_v_texCoords;
16167
in vec3 a_v_normal;
16168
in vec3 a_i_pos;
16169
in vec2 a_i_light;
16170
in float a_i_offset;
16171
in vec3 a_i_axis;
16172
in vec4 a_i_rotation;
16173
in vec3 a_i_rotationCenter;
16174
in float a_i_speed;
16175
out vec2 v2f_texCoords;
16176
out vec4 v2f_color;
16177
out float v2f_diffuse;
16178
out vec2 v2f_light;
16179
void main() {
16180
Vertex v;
16181
v.pos = a_v_pos;
16182
v.texCoords = a_v_texCoords;
16183
v.normal = a_v_normal;
16184
Actor i;
16185
i.pos = a_i_pos;
16186
i.light = a_i_light;
16187
i.offset = a_i_offset;
16188
i.axis = a_i_axis;
16189
i.rotation = a_i_rotation;
16190
i.rotationCenter = a_i_rotationCenter;
16191
i.speed = a_i_speed;
16192
BlockFrag o = vertex(v, i);
16193
v2f_texCoords = o.texCoords;
16194
v2f_color = o.color;
16195
v2f_diffuse = o.diffuse;
16196
v2f_light = o.light;
16197
}
16198
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
16199
16200
[17:17:49] [Render thread/ERROR]: #version 150
16201
#extension GL_ARB_conservative_depth : enable
16202
#define FRAGMENT_SHADER
16203
#if defined(VERTEX_SHADER)
16204
out float FragDistance;
16205
#elif defined(FRAGMENT_SHADER)
16206
in float FragDistance;
16207
#endif
16208
uniform vec4 uFogColor;
16209
uniform vec2 uFogRange;
16210
16211
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
16212
float distXZ = length(worldPos.xz - cameraPos.xz);
16213
float distY = abs(worldPos.y - cameraPos.y);
16214
return max(distXZ, distY);
16215
}
16216
16217
float cylindrical_distance(vec3 worldPos) {
16218
float distXZ = length(worldPos.xz);
16219
float distY = abs(worldPos.y);
16220
return max(distXZ, distY);
16221
}
16222
16223
float FLWFogFactor() {
16224
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
16225
}
16226
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
16227
vec2 shiftLight(vec2 lm) {
16228
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
16229
}
16230
16231
16232
uniform sampler3D uLightVolume;
16233
16234
uniform sampler2D uBlockAtlas;
16235
uniform sampler2D uLightMap;
16236
16237
uniform vec3 uLightBoxSize;
16238
uniform vec3 uLightBoxMin;
16239
uniform mat4 uModel;
16240
16241
uniform float uTime;
16242
uniform mat4 uViewProjection;
16243
uniform vec3 uCameraPos;
16244
16245
void FLWFinalizeNormal(inout vec3 normal) {
16246
mat3 m;
16247
m[0] = uModel[0].xyz;
16248
m[1] = uModel[1].xyz;
16249
m[2] = uModel[2].xyz;
16250
normal = m * normal;
16251
}
16252
16253
#if defined(VERTEX_SHADER)
16254
16255
out vec3 BoxCoord;
16256
16257
void FLWFinalizeWorldPos(inout vec4 worldPos) {
16258
worldPos = uModel * worldPos;
16259
16260
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
16261
16262
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
16263
16264
gl_Position = uViewProjection * worldPos;
16265
}
16266
16267
#elif defined(FRAGMENT_SHADER)
16268
16269
16270
#define ALPHA_DISCARD 0.1
16271
// optimize discard usage
16272
#if defined(ALPHA_DISCARD)
16273
#if defined(GL_ARB_conservative_depth)
16274
layout (depth_greater) out float gl_FragDepth;
16275
#endif
16276
#endif
16277
16278
in vec3 BoxCoord;
16279
16280
out vec4 FragColor;
16281
16282
vec4 FLWBlockTexture(vec2 texCoords) {
16283
return texture(uBlockAtlas, texCoords);
16284
}
16285
16286
void FLWFinalizeColor(vec4 color) {
16287
float a = color.a;
16288
float fog = clamp(FLWFogFactor(), 0., 1.);
16289
16290
color = mix(uFogColor, color, fog);
16291
color.a = a;
16292
16293
#if defined(ALPHA_DISCARD)
16294
if (color.a < ALPHA_DISCARD) {
16295
discard;
16296
}
16297
#endif
16298
16299
FragColor = color;
16300
}
16301
16302
vec4 FLWLight(vec2 lightCoords) {
16303
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
16304
16305
return texture(uLightMap, shiftLight(lightCoords));
16306
}
16307
16308
#endif
16309
16310
16311
mat4 rotate(vec3 axis, float angle) {
16312
float s = sin(angle);
16313
float c = cos(angle);
16314
float oc = 1. - c;
16315
16316
vec3 sa = axis * s;
16317
16318
mat4 mr = mat4(1.);
16319
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
16320
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
16321
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
16322
16323
return mr;
16324
}
16325
16326
mat4 rotation(vec3 rot) {
16327
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
16328
}
16329
16330
mat3 modelToNormal(mat4 mat) {
16331
// Discard the edges. This won't be accurate for scaled or skewed matrices,
16332
// but we don't have to work with those often.
16333
mat3 m;
16334
m[0] = mat[0].xyz;
16335
m[1] = mat[1].xyz;
16336
m[2] = mat[2].xyz;
16337
return m;
16338
}
16339
16340
#define PIOVER2 1.5707963268
16341
16342
vec4 quat(vec3 axis, float angle) {
16343
float halfAngle = angle * PIOVER2 / 180.0;
16344
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
16345
return vec4(axis.xyz * cs.y, cs.x);
16346
}
16347
16348
vec4 quatMult(vec4 q1, vec4 q2) {
16349
// disgustingly vectorized quaternion multiplication
16350
vec4 a = q1.w * q2.xyzw;
16351
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
16352
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
16353
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
16354
16355
return a + b + c + d;
16356
}
16357
16358
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
16359
vec3 i = q.xyz;
16360
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
16361
}
16362
16363
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
16364
return rotateVertexByQuat(v, quat(axis, angle));
16365
}
16366
16367
float diffuse(vec3 normal) {
16368
vec3 n2 = normal * normal * vec3(.6, .25, .8);
16369
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
16370
}
16371
struct Vertex {
16372
vec3 pos;
16373
vec2 texCoords;
16374
vec3 normal;
16375
};
16376
16377
struct BlockFrag {
16378
vec2 texCoords;
16379
vec4 color;
16380
float diffuse;
16381
vec2 light;
16382
};
16383
16384
#if defined(FRAGMENT_SHADER)
16385
void fragment(BlockFrag r) {
16386
vec4 tex = FLWBlockTexture(r.texCoords);
16387
16388
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
16389
16390
FLWFinalizeColor(color);
16391
}
16392
#endif
16393
#define PI 3.1415926538
16394
16395
16396
16397
16398
16399
struct Actor {
16400
vec3 pos;
16401
vec2 light;
16402
float offset;
16403
vec3 axis;
16404
vec4 rotation;
16405
vec3 rotationCenter;
16406
float speed;
16407
};
16408
16409
16410
16411
16412
#if defined(VERTEX_SHADER)
16413
BlockFrag vertex(Vertex v, Actor instance) {
16414
float degrees = instance.offset + uTime * instance.speed / 20.;
16415
//float angle = fract(degrees / 360.) * PI * 2.;
16416
16417
vec4 kineticRot = quat(instance.axis, degrees);
16418
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
16419
16420
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
16421
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
16422
16423
FLWFinalizeWorldPos(worldPos);
16424
FLWFinalizeNormal(norm);
16425
16426
BlockFrag b;
16427
b.diffuse = diffuse(norm);
16428
b.texCoords = v.texCoords;
16429
b.light = instance.light;
16430
16431
#if defined(DEBUG_NORMAL)
16432
b.color = vec4(norm, 1.);
16433
#else
16434
b.color = vec4(1.);
16435
#endif
16436
16437
return b;
16438
}
16439
#endif
16440
16441
in vec2 v2f_texCoords;
16442
in vec4 v2f_color;
16443
in float v2f_diffuse;
16444
in vec2 v2f_light;
16445
void main() {
16446
BlockFrag o;
16447
o.texCoords = v2f_texCoords;
16448
o.color = v2f_color;
16449
o.diffuse = v2f_diffuse;
16450
o.light = v2f_light;
16451
fragment(o);
16452
}
16453
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
16454
16455
[17:17:49] [Render thread/ERROR]: #version 150
16456
#extension GL_ARB_conservative_depth : enable
16457
#define VERTEX_SHADER
16458
#define DEBUG_NORMAL
16459
#if defined(VERTEX_SHADER)
16460
out float FragDistance;
16461
#elif defined(FRAGMENT_SHADER)
16462
in float FragDistance;
16463
#endif
16464
uniform vec4 uFogColor;
16465
uniform vec2 uFogRange;
16466
16467
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
16468
float distXZ = length(worldPos.xz - cameraPos.xz);
16469
float distY = abs(worldPos.y - cameraPos.y);
16470
return max(distXZ, distY);
16471
}
16472
16473
float cylindrical_distance(vec3 worldPos) {
16474
float distXZ = length(worldPos.xz);
16475
float distY = abs(worldPos.y);
16476
return max(distXZ, distY);
16477
}
16478
16479
float FLWFogFactor() {
16480
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
16481
}
16482
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
16483
vec2 shiftLight(vec2 lm) {
16484
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
16485
}
16486
16487
16488
uniform sampler3D uLightVolume;
16489
16490
uniform sampler2D uBlockAtlas;
16491
uniform sampler2D uLightMap;
16492
16493
uniform vec3 uLightBoxSize;
16494
uniform vec3 uLightBoxMin;
16495
uniform mat4 uModel;
16496
16497
uniform float uTime;
16498
uniform mat4 uViewProjection;
16499
uniform vec3 uCameraPos;
16500
16501
void FLWFinalizeNormal(inout vec3 normal) {
16502
mat3 m;
16503
m[0] = uModel[0].xyz;
16504
m[1] = uModel[1].xyz;
16505
m[2] = uModel[2].xyz;
16506
normal = m * normal;
16507
}
16508
16509
#if defined(VERTEX_SHADER)
16510
16511
out vec3 BoxCoord;
16512
16513
void FLWFinalizeWorldPos(inout vec4 worldPos) {
16514
worldPos = uModel * worldPos;
16515
16516
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
16517
16518
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
16519
16520
gl_Position = uViewProjection * worldPos;
16521
}
16522
16523
#elif defined(FRAGMENT_SHADER)
16524
16525
16526
#define ALPHA_DISCARD 0.1
16527
// optimize discard usage
16528
#if defined(ALPHA_DISCARD)
16529
#if defined(GL_ARB_conservative_depth)
16530
layout (depth_greater) out float gl_FragDepth;
16531
#endif
16532
#endif
16533
16534
in vec3 BoxCoord;
16535
16536
out vec4 FragColor;
16537
16538
vec4 FLWBlockTexture(vec2 texCoords) {
16539
return texture(uBlockAtlas, texCoords);
16540
}
16541
16542
void FLWFinalizeColor(vec4 color) {
16543
float a = color.a;
16544
float fog = clamp(FLWFogFactor(), 0., 1.);
16545
16546
color = mix(uFogColor, color, fog);
16547
color.a = a;
16548
16549
#if defined(ALPHA_DISCARD)
16550
if (color.a < ALPHA_DISCARD) {
16551
discard;
16552
}
16553
#endif
16554
16555
FragColor = color;
16556
}
16557
16558
vec4 FLWLight(vec2 lightCoords) {
16559
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
16560
16561
return texture(uLightMap, shiftLight(lightCoords));
16562
}
16563
16564
#endif
16565
16566
16567
mat4 rotate(vec3 axis, float angle) {
16568
float s = sin(angle);
16569
float c = cos(angle);
16570
float oc = 1. - c;
16571
16572
vec3 sa = axis * s;
16573
16574
mat4 mr = mat4(1.);
16575
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
16576
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
16577
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
16578
16579
return mr;
16580
}
16581
16582
mat4 rotation(vec3 rot) {
16583
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
16584
}
16585
16586
mat3 modelToNormal(mat4 mat) {
16587
// Discard the edges. This won't be accurate for scaled or skewed matrices,
16588
// but we don't have to work with those often.
16589
mat3 m;
16590
m[0] = mat[0].xyz;
16591
m[1] = mat[1].xyz;
16592
m[2] = mat[2].xyz;
16593
return m;
16594
}
16595
16596
#define PIOVER2 1.5707963268
16597
16598
vec4 quat(vec3 axis, float angle) {
16599
float halfAngle = angle * PIOVER2 / 180.0;
16600
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
16601
return vec4(axis.xyz * cs.y, cs.x);
16602
}
16603
16604
vec4 quatMult(vec4 q1, vec4 q2) {
16605
// disgustingly vectorized quaternion multiplication
16606
vec4 a = q1.w * q2.xyzw;
16607
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
16608
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
16609
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
16610
16611
return a + b + c + d;
16612
}
16613
16614
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
16615
vec3 i = q.xyz;
16616
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
16617
}
16618
16619
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
16620
return rotateVertexByQuat(v, quat(axis, angle));
16621
}
16622
16623
float diffuse(vec3 normal) {
16624
vec3 n2 = normal * normal * vec3(.6, .25, .8);
16625
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
16626
}
16627
struct Vertex {
16628
vec3 pos;
16629
vec2 texCoords;
16630
vec3 normal;
16631
};
16632
16633
struct BlockFrag {
16634
vec2 texCoords;
16635
vec4 color;
16636
float diffuse;
16637
vec2 light;
16638
};
16639
16640
#if defined(FRAGMENT_SHADER)
16641
void fragment(BlockFrag r) {
16642
vec4 tex = FLWBlockTexture(r.texCoords);
16643
16644
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
16645
16646
FLWFinalizeColor(color);
16647
}
16648
#endif
16649
#define PI 3.1415926538
16650
16651
16652
16653
16654
16655
struct Actor {
16656
vec3 pos;
16657
vec2 light;
16658
float offset;
16659
vec3 axis;
16660
vec4 rotation;
16661
vec3 rotationCenter;
16662
float speed;
16663
};
16664
16665
16666
16667
16668
#if defined(VERTEX_SHADER)
16669
BlockFrag vertex(Vertex v, Actor instance) {
16670
float degrees = instance.offset + uTime * instance.speed / 20.;
16671
//float angle = fract(degrees / 360.) * PI * 2.;
16672
16673
vec4 kineticRot = quat(instance.axis, degrees);
16674
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
16675
16676
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
16677
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
16678
16679
FLWFinalizeWorldPos(worldPos);
16680
FLWFinalizeNormal(norm);
16681
16682
BlockFrag b;
16683
b.diffuse = diffuse(norm);
16684
b.texCoords = v.texCoords;
16685
b.light = instance.light;
16686
16687
#if defined(DEBUG_NORMAL)
16688
b.color = vec4(norm, 1.);
16689
#else
16690
b.color = vec4(1.);
16691
#endif
16692
16693
return b;
16694
}
16695
#endif
16696
16697
in vec3 a_v_pos;
16698
in vec2 a_v_texCoords;
16699
in vec3 a_v_normal;
16700
in vec3 a_i_pos;
16701
in vec2 a_i_light;
16702
in float a_i_offset;
16703
in vec3 a_i_axis;
16704
in vec4 a_i_rotation;
16705
in vec3 a_i_rotationCenter;
16706
in float a_i_speed;
16707
out vec2 v2f_texCoords;
16708
out vec4 v2f_color;
16709
out float v2f_diffuse;
16710
out vec2 v2f_light;
16711
void main() {
16712
Vertex v;
16713
v.pos = a_v_pos;
16714
v.texCoords = a_v_texCoords;
16715
v.normal = a_v_normal;
16716
Actor i;
16717
i.pos = a_i_pos;
16718
i.light = a_i_light;
16719
i.offset = a_i_offset;
16720
i.axis = a_i_axis;
16721
i.rotation = a_i_rotation;
16722
i.rotationCenter = a_i_rotationCenter;
16723
i.speed = a_i_speed;
16724
BlockFrag o = vertex(v, i);
16725
v2f_texCoords = o.texCoords;
16726
v2f_color = o.color;
16727
v2f_diffuse = o.diffuse;
16728
v2f_light = o.light;
16729
}
16730
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_actor: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
16731
16732
[17:17:49] [Render thread/ERROR]: #version 150
16733
#extension GL_ARB_conservative_depth : enable
16734
#define FRAGMENT_SHADER
16735
#define DEBUG_NORMAL
16736
#if defined(VERTEX_SHADER)
16737
out float FragDistance;
16738
#elif defined(FRAGMENT_SHADER)
16739
in float FragDistance;
16740
#endif
16741
uniform vec4 uFogColor;
16742
uniform vec2 uFogRange;
16743
16744
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
16745
float distXZ = length(worldPos.xz - cameraPos.xz);
16746
float distY = abs(worldPos.y - cameraPos.y);
16747
return max(distXZ, distY);
16748
}
16749
16750
float cylindrical_distance(vec3 worldPos) {
16751
float distXZ = length(worldPos.xz);
16752
float distY = abs(worldPos.y);
16753
return max(distXZ, distY);
16754
}
16755
16756
float FLWFogFactor() {
16757
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
16758
}
16759
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
16760
vec2 shiftLight(vec2 lm) {
16761
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
16762
}
16763
16764
16765
uniform sampler3D uLightVolume;
16766
16767
uniform sampler2D uBlockAtlas;
16768
uniform sampler2D uLightMap;
16769
16770
uniform vec3 uLightBoxSize;
16771
uniform vec3 uLightBoxMin;
16772
uniform mat4 uModel;
16773
16774
uniform float uTime;
16775
uniform mat4 uViewProjection;
16776
uniform vec3 uCameraPos;
16777
16778
void FLWFinalizeNormal(inout vec3 normal) {
16779
mat3 m;
16780
m[0] = uModel[0].xyz;
16781
m[1] = uModel[1].xyz;
16782
m[2] = uModel[2].xyz;
16783
normal = m * normal;
16784
}
16785
16786
#if defined(VERTEX_SHADER)
16787
16788
out vec3 BoxCoord;
16789
16790
void FLWFinalizeWorldPos(inout vec4 worldPos) {
16791
worldPos = uModel * worldPos;
16792
16793
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
16794
16795
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
16796
16797
gl_Position = uViewProjection * worldPos;
16798
}
16799
16800
#elif defined(FRAGMENT_SHADER)
16801
16802
16803
#define ALPHA_DISCARD 0.1
16804
// optimize discard usage
16805
#if defined(ALPHA_DISCARD)
16806
#if defined(GL_ARB_conservative_depth)
16807
layout (depth_greater) out float gl_FragDepth;
16808
#endif
16809
#endif
16810
16811
in vec3 BoxCoord;
16812
16813
out vec4 FragColor;
16814
16815
vec4 FLWBlockTexture(vec2 texCoords) {
16816
return texture(uBlockAtlas, texCoords);
16817
}
16818
16819
void FLWFinalizeColor(vec4 color) {
16820
float a = color.a;
16821
float fog = clamp(FLWFogFactor(), 0., 1.);
16822
16823
color = mix(uFogColor, color, fog);
16824
color.a = a;
16825
16826
#if defined(ALPHA_DISCARD)
16827
if (color.a < ALPHA_DISCARD) {
16828
discard;
16829
}
16830
#endif
16831
16832
FragColor = color;
16833
}
16834
16835
vec4 FLWLight(vec2 lightCoords) {
16836
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
16837
16838
return texture(uLightMap, shiftLight(lightCoords));
16839
}
16840
16841
#endif
16842
16843
16844
mat4 rotate(vec3 axis, float angle) {
16845
float s = sin(angle);
16846
float c = cos(angle);
16847
float oc = 1. - c;
16848
16849
vec3 sa = axis * s;
16850
16851
mat4 mr = mat4(1.);
16852
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
16853
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
16854
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
16855
16856
return mr;
16857
}
16858
16859
mat4 rotation(vec3 rot) {
16860
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
16861
}
16862
16863
mat3 modelToNormal(mat4 mat) {
16864
// Discard the edges. This won't be accurate for scaled or skewed matrices,
16865
// but we don't have to work with those often.
16866
mat3 m;
16867
m[0] = mat[0].xyz;
16868
m[1] = mat[1].xyz;
16869
m[2] = mat[2].xyz;
16870
return m;
16871
}
16872
16873
#define PIOVER2 1.5707963268
16874
16875
vec4 quat(vec3 axis, float angle) {
16876
float halfAngle = angle * PIOVER2 / 180.0;
16877
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
16878
return vec4(axis.xyz * cs.y, cs.x);
16879
}
16880
16881
vec4 quatMult(vec4 q1, vec4 q2) {
16882
// disgustingly vectorized quaternion multiplication
16883
vec4 a = q1.w * q2.xyzw;
16884
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
16885
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
16886
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
16887
16888
return a + b + c + d;
16889
}
16890
16891
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
16892
vec3 i = q.xyz;
16893
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
16894
}
16895
16896
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
16897
return rotateVertexByQuat(v, quat(axis, angle));
16898
}
16899
16900
float diffuse(vec3 normal) {
16901
vec3 n2 = normal * normal * vec3(.6, .25, .8);
16902
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
16903
}
16904
struct Vertex {
16905
vec3 pos;
16906
vec2 texCoords;
16907
vec3 normal;
16908
};
16909
16910
struct BlockFrag {
16911
vec2 texCoords;
16912
vec4 color;
16913
float diffuse;
16914
vec2 light;
16915
};
16916
16917
#if defined(FRAGMENT_SHADER)
16918
void fragment(BlockFrag r) {
16919
vec4 tex = FLWBlockTexture(r.texCoords);
16920
16921
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
16922
16923
FLWFinalizeColor(color);
16924
}
16925
#endif
16926
#define PI 3.1415926538
16927
16928
16929
16930
16931
16932
struct Actor {
16933
vec3 pos;
16934
vec2 light;
16935
float offset;
16936
vec3 axis;
16937
vec4 rotation;
16938
vec3 rotationCenter;
16939
float speed;
16940
};
16941
16942
16943
16944
16945
#if defined(VERTEX_SHADER)
16946
BlockFrag vertex(Vertex v, Actor instance) {
16947
float degrees = instance.offset + uTime * instance.speed / 20.;
16948
//float angle = fract(degrees / 360.) * PI * 2.;
16949
16950
vec4 kineticRot = quat(instance.axis, degrees);
16951
vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
16952
16953
vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
16954
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
16955
16956
FLWFinalizeWorldPos(worldPos);
16957
FLWFinalizeNormal(norm);
16958
16959
BlockFrag b;
16960
b.diffuse = diffuse(norm);
16961
b.texCoords = v.texCoords;
16962
b.light = instance.light;
16963
16964
#if defined(DEBUG_NORMAL)
16965
b.color = vec4(norm, 1.);
16966
#else
16967
b.color = vec4(1.);
16968
#endif
16969
16970
return b;
16971
}
16972
#endif
16973
16974
in vec2 v2f_texCoords;
16975
in vec4 v2f_color;
16976
in float v2f_diffuse;
16977
in vec2 v2f_light;
16978
void main() {
16979
BlockFrag o;
16980
o.texCoords = v2f_texCoords;
16981
o.color = v2f_color;
16982
o.diffuse = v2f_diffuse;
16983
o.light = v2f_light;
16984
fragment(o);
16985
}
16986
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
16987
16988
[17:17:49] [Render thread/ERROR]: #version 150
16989
#extension GL_ARB_conservative_depth : enable
16990
#define VERTEX_SHADER
16991
#if defined(VERTEX_SHADER)
16992
out float FragDistance;
16993
#elif defined(FRAGMENT_SHADER)
16994
in float FragDistance;
16995
#endif
16996
uniform vec4 uFogColor;
16997
uniform vec2 uFogRange;
16998
16999
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
17000
float distXZ = length(worldPos.xz - cameraPos.xz);
17001
float distY = abs(worldPos.y - cameraPos.y);
17002
return max(distXZ, distY);
17003
}
17004
17005
float cylindrical_distance(vec3 worldPos) {
17006
float distXZ = length(worldPos.xz);
17007
float distY = abs(worldPos.y);
17008
return max(distXZ, distY);
17009
}
17010
17011
float FLWFogFactor() {
17012
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
17013
}
17014
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
17015
vec2 shiftLight(vec2 lm) {
17016
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
17017
}
17018
17019
17020
uniform sampler3D uLightVolume;
17021
17022
uniform sampler2D uBlockAtlas;
17023
uniform sampler2D uLightMap;
17024
17025
uniform vec3 uLightBoxSize;
17026
uniform vec3 uLightBoxMin;
17027
uniform mat4 uModel;
17028
17029
uniform float uTime;
17030
uniform mat4 uViewProjection;
17031
uniform vec3 uCameraPos;
17032
17033
void FLWFinalizeNormal(inout vec3 normal) {
17034
mat3 m;
17035
m[0] = uModel[0].xyz;
17036
m[1] = uModel[1].xyz;
17037
m[2] = uModel[2].xyz;
17038
normal = m * normal;
17039
}
17040
17041
#if defined(VERTEX_SHADER)
17042
17043
out vec3 BoxCoord;
17044
17045
void FLWFinalizeWorldPos(inout vec4 worldPos) {
17046
worldPos = uModel * worldPos;
17047
17048
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
17049
17050
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
17051
17052
gl_Position = uViewProjection * worldPos;
17053
}
17054
17055
#elif defined(FRAGMENT_SHADER)
17056
17057
17058
#define ALPHA_DISCARD 0.1
17059
// optimize discard usage
17060
#if defined(ALPHA_DISCARD)
17061
#if defined(GL_ARB_conservative_depth)
17062
layout (depth_greater) out float gl_FragDepth;
17063
#endif
17064
#endif
17065
17066
in vec3 BoxCoord;
17067
17068
out vec4 FragColor;
17069
17070
vec4 FLWBlockTexture(vec2 texCoords) {
17071
return texture(uBlockAtlas, texCoords);
17072
}
17073
17074
void FLWFinalizeColor(vec4 color) {
17075
float a = color.a;
17076
float fog = clamp(FLWFogFactor(), 0., 1.);
17077
17078
color = mix(uFogColor, color, fog);
17079
color.a = a;
17080
17081
#if defined(ALPHA_DISCARD)
17082
if (color.a < ALPHA_DISCARD) {
17083
discard;
17084
}
17085
#endif
17086
17087
FragColor = color;
17088
}
17089
17090
vec4 FLWLight(vec2 lightCoords) {
17091
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
17092
17093
return texture(uLightMap, shiftLight(lightCoords));
17094
}
17095
17096
#endif
17097
17098
17099
mat4 rotate(vec3 axis, float angle) {
17100
float s = sin(angle);
17101
float c = cos(angle);
17102
float oc = 1. - c;
17103
17104
vec3 sa = axis * s;
17105
17106
mat4 mr = mat4(1.);
17107
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
17108
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
17109
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
17110
17111
return mr;
17112
}
17113
17114
mat4 rotation(vec3 rot) {
17115
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
17116
}
17117
17118
mat3 modelToNormal(mat4 mat) {
17119
// Discard the edges. This won't be accurate for scaled or skewed matrices,
17120
// but we don't have to work with those often.
17121
mat3 m;
17122
m[0] = mat[0].xyz;
17123
m[1] = mat[1].xyz;
17124
m[2] = mat[2].xyz;
17125
return m;
17126
}
17127
17128
#define PIOVER2 1.5707963268
17129
17130
vec4 quat(vec3 axis, float angle) {
17131
float halfAngle = angle * PIOVER2 / 180.0;
17132
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
17133
return vec4(axis.xyz * cs.y, cs.x);
17134
}
17135
17136
vec4 quatMult(vec4 q1, vec4 q2) {
17137
// disgustingly vectorized quaternion multiplication
17138
vec4 a = q1.w * q2.xyzw;
17139
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
17140
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
17141
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
17142
17143
return a + b + c + d;
17144
}
17145
17146
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
17147
vec3 i = q.xyz;
17148
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
17149
}
17150
17151
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
17152
return rotateVertexByQuat(v, quat(axis, angle));
17153
}
17154
17155
float diffuse(vec3 normal) {
17156
vec3 n2 = normal * normal * vec3(.6, .25, .8);
17157
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
17158
}
17159
struct Vertex {
17160
vec3 pos;
17161
vec2 texCoords;
17162
vec3 normal;
17163
};
17164
17165
struct BlockFrag {
17166
vec2 texCoords;
17167
vec4 color;
17168
float diffuse;
17169
vec2 light;
17170
};
17171
17172
#if defined(FRAGMENT_SHADER)
17173
void fragment(BlockFrag r) {
17174
vec4 tex = FLWBlockTexture(r.texCoords);
17175
17176
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
17177
17178
FLWFinalizeColor(color);
17179
}
17180
#endif
17181
#define PI 3.1415926538
17182
17183
17184
17185
17186
17187
struct Flap {
17188
vec3 instancePos;
17189
vec2 light;
17190
vec3 segmentOffset;
17191
vec3 pivot;
17192
float horizontalAngle;
17193
float intensity;
17194
float flapScale;
17195
float flapness;
17196
};
17197
17198
17199
17200
17201
#if defined(VERTEX_SHADER)
17202
17203
float toRad(float degrees) {
17204
return fract(degrees / 360.) * PI * 2.;
17205
}
17206
17207
float getFlapAngle(float flapness, float intensity, float scale) {
17208
float absFlap = abs(flapness);
17209
17210
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
17211
17212
float halfAngle = angle * 0.5;
17213
17214
float which = step(0., flapness); // 0 if negative, 1 if positive
17215
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
17216
17217
return degrees;
17218
}
17219
17220
BlockFrag vertex(Vertex v, Flap flap) {
17221
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
17222
17223
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
17224
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
17225
17226
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
17227
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
17228
17229
vec4 worldPos = vec4(rotated, 1.);
17230
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
17231
17232
FLWFinalizeWorldPos(worldPos);
17233
FLWFinalizeNormal(norm);
17234
17235
BlockFrag b;
17236
b.diffuse = diffuse(norm);
17237
b.texCoords = v.texCoords;
17238
b.light = flap.light;
17239
#if defined(DEBUG_NORMAL)
17240
b.color = vec4(norm, 1.);
17241
#else
17242
b.color = vec4(1.);
17243
#endif
17244
return b;
17245
}
17246
#endif
17247
17248
in vec3 a_v_pos;
17249
in vec2 a_v_texCoords;
17250
in vec3 a_v_normal;
17251
in vec3 a_i_instancePos;
17252
in vec2 a_i_light;
17253
in vec3 a_i_segmentOffset;
17254
in vec3 a_i_pivot;
17255
in float a_i_horizontalAngle;
17256
in float a_i_intensity;
17257
in float a_i_flapScale;
17258
in float a_i_flapness;
17259
out vec2 v2f_texCoords;
17260
out vec4 v2f_color;
17261
out float v2f_diffuse;
17262
out vec2 v2f_light;
17263
void main() {
17264
Vertex v;
17265
v.pos = a_v_pos;
17266
v.texCoords = a_v_texCoords;
17267
v.normal = a_v_normal;
17268
Flap i;
17269
i.instancePos = a_i_instancePos;
17270
i.light = a_i_light;
17271
i.segmentOffset = a_i_segmentOffset;
17272
i.pivot = a_i_pivot;
17273
i.horizontalAngle = a_i_horizontalAngle;
17274
i.intensity = a_i_intensity;
17275
i.flapScale = a_i_flapScale;
17276
i.flapness = a_i_flapness;
17277
BlockFrag o = vertex(v, i);
17278
v2f_texCoords = o.texCoords;
17279
v2f_color = o.color;
17280
v2f_diffuse = o.diffuse;
17281
v2f_light = o.light;
17282
}
17283
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
17284
17285
[17:17:49] [Render thread/ERROR]: #version 150
17286
#extension GL_ARB_conservative_depth : enable
17287
#define FRAGMENT_SHADER
17288
#if defined(VERTEX_SHADER)
17289
out float FragDistance;
17290
#elif defined(FRAGMENT_SHADER)
17291
in float FragDistance;
17292
#endif
17293
uniform vec4 uFogColor;
17294
uniform vec2 uFogRange;
17295
17296
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
17297
float distXZ = length(worldPos.xz - cameraPos.xz);
17298
float distY = abs(worldPos.y - cameraPos.y);
17299
return max(distXZ, distY);
17300
}
17301
17302
float cylindrical_distance(vec3 worldPos) {
17303
float distXZ = length(worldPos.xz);
17304
float distY = abs(worldPos.y);
17305
return max(distXZ, distY);
17306
}
17307
17308
float FLWFogFactor() {
17309
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
17310
}
17311
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
17312
vec2 shiftLight(vec2 lm) {
17313
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
17314
}
17315
17316
17317
uniform sampler3D uLightVolume;
17318
17319
uniform sampler2D uBlockAtlas;
17320
uniform sampler2D uLightMap;
17321
17322
uniform vec3 uLightBoxSize;
17323
uniform vec3 uLightBoxMin;
17324
uniform mat4 uModel;
17325
17326
uniform float uTime;
17327
uniform mat4 uViewProjection;
17328
uniform vec3 uCameraPos;
17329
17330
void FLWFinalizeNormal(inout vec3 normal) {
17331
mat3 m;
17332
m[0] = uModel[0].xyz;
17333
m[1] = uModel[1].xyz;
17334
m[2] = uModel[2].xyz;
17335
normal = m * normal;
17336
}
17337
17338
#if defined(VERTEX_SHADER)
17339
17340
out vec3 BoxCoord;
17341
17342
void FLWFinalizeWorldPos(inout vec4 worldPos) {
17343
worldPos = uModel * worldPos;
17344
17345
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
17346
17347
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
17348
17349
gl_Position = uViewProjection * worldPos;
17350
}
17351
17352
#elif defined(FRAGMENT_SHADER)
17353
17354
17355
#define ALPHA_DISCARD 0.1
17356
// optimize discard usage
17357
#if defined(ALPHA_DISCARD)
17358
#if defined(GL_ARB_conservative_depth)
17359
layout (depth_greater) out float gl_FragDepth;
17360
#endif
17361
#endif
17362
17363
in vec3 BoxCoord;
17364
17365
out vec4 FragColor;
17366
17367
vec4 FLWBlockTexture(vec2 texCoords) {
17368
return texture(uBlockAtlas, texCoords);
17369
}
17370
17371
void FLWFinalizeColor(vec4 color) {
17372
float a = color.a;
17373
float fog = clamp(FLWFogFactor(), 0., 1.);
17374
17375
color = mix(uFogColor, color, fog);
17376
color.a = a;
17377
17378
#if defined(ALPHA_DISCARD)
17379
if (color.a < ALPHA_DISCARD) {
17380
discard;
17381
}
17382
#endif
17383
17384
FragColor = color;
17385
}
17386
17387
vec4 FLWLight(vec2 lightCoords) {
17388
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
17389
17390
return texture(uLightMap, shiftLight(lightCoords));
17391
}
17392
17393
#endif
17394
17395
17396
mat4 rotate(vec3 axis, float angle) {
17397
float s = sin(angle);
17398
float c = cos(angle);
17399
float oc = 1. - c;
17400
17401
vec3 sa = axis * s;
17402
17403
mat4 mr = mat4(1.);
17404
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
17405
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
17406
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
17407
17408
return mr;
17409
}
17410
17411
mat4 rotation(vec3 rot) {
17412
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
17413
}
17414
17415
mat3 modelToNormal(mat4 mat) {
17416
// Discard the edges. This won't be accurate for scaled or skewed matrices,
17417
// but we don't have to work with those often.
17418
mat3 m;
17419
m[0] = mat[0].xyz;
17420
m[1] = mat[1].xyz;
17421
m[2] = mat[2].xyz;
17422
return m;
17423
}
17424
17425
#define PIOVER2 1.5707963268
17426
17427
vec4 quat(vec3 axis, float angle) {
17428
float halfAngle = angle * PIOVER2 / 180.0;
17429
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
17430
return vec4(axis.xyz * cs.y, cs.x);
17431
}
17432
17433
vec4 quatMult(vec4 q1, vec4 q2) {
17434
// disgustingly vectorized quaternion multiplication
17435
vec4 a = q1.w * q2.xyzw;
17436
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
17437
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
17438
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
17439
17440
return a + b + c + d;
17441
}
17442
17443
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
17444
vec3 i = q.xyz;
17445
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
17446
}
17447
17448
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
17449
return rotateVertexByQuat(v, quat(axis, angle));
17450
}
17451
17452
float diffuse(vec3 normal) {
17453
vec3 n2 = normal * normal * vec3(.6, .25, .8);
17454
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
17455
}
17456
struct Vertex {
17457
vec3 pos;
17458
vec2 texCoords;
17459
vec3 normal;
17460
};
17461
17462
struct BlockFrag {
17463
vec2 texCoords;
17464
vec4 color;
17465
float diffuse;
17466
vec2 light;
17467
};
17468
17469
#if defined(FRAGMENT_SHADER)
17470
void fragment(BlockFrag r) {
17471
vec4 tex = FLWBlockTexture(r.texCoords);
17472
17473
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
17474
17475
FLWFinalizeColor(color);
17476
}
17477
#endif
17478
#define PI 3.1415926538
17479
17480
17481
17482
17483
17484
struct Flap {
17485
vec3 instancePos;
17486
vec2 light;
17487
vec3 segmentOffset;
17488
vec3 pivot;
17489
float horizontalAngle;
17490
float intensity;
17491
float flapScale;
17492
float flapness;
17493
};
17494
17495
17496
17497
17498
#if defined(VERTEX_SHADER)
17499
17500
float toRad(float degrees) {
17501
return fract(degrees / 360.) * PI * 2.;
17502
}
17503
17504
float getFlapAngle(float flapness, float intensity, float scale) {
17505
float absFlap = abs(flapness);
17506
17507
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
17508
17509
float halfAngle = angle * 0.5;
17510
17511
float which = step(0., flapness); // 0 if negative, 1 if positive
17512
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
17513
17514
return degrees;
17515
}
17516
17517
BlockFrag vertex(Vertex v, Flap flap) {
17518
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
17519
17520
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
17521
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
17522
17523
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
17524
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
17525
17526
vec4 worldPos = vec4(rotated, 1.);
17527
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
17528
17529
FLWFinalizeWorldPos(worldPos);
17530
FLWFinalizeNormal(norm);
17531
17532
BlockFrag b;
17533
b.diffuse = diffuse(norm);
17534
b.texCoords = v.texCoords;
17535
b.light = flap.light;
17536
#if defined(DEBUG_NORMAL)
17537
b.color = vec4(norm, 1.);
17538
#else
17539
b.color = vec4(1.);
17540
#endif
17541
return b;
17542
}
17543
#endif
17544
17545
in vec2 v2f_texCoords;
17546
in vec4 v2f_color;
17547
in float v2f_diffuse;
17548
in vec2 v2f_light;
17549
void main() {
17550
BlockFrag o;
17551
o.texCoords = v2f_texCoords;
17552
o.color = v2f_color;
17553
o.diffuse = v2f_diffuse;
17554
o.light = v2f_light;
17555
fragment(o);
17556
}
17557
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
17558
17559
[17:17:49] [Render thread/ERROR]: #version 150
17560
#extension GL_ARB_conservative_depth : enable
17561
#define VERTEX_SHADER
17562
#define DEBUG_NORMAL
17563
#if defined(VERTEX_SHADER)
17564
out float FragDistance;
17565
#elif defined(FRAGMENT_SHADER)
17566
in float FragDistance;
17567
#endif
17568
uniform vec4 uFogColor;
17569
uniform vec2 uFogRange;
17570
17571
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
17572
float distXZ = length(worldPos.xz - cameraPos.xz);
17573
float distY = abs(worldPos.y - cameraPos.y);
17574
return max(distXZ, distY);
17575
}
17576
17577
float cylindrical_distance(vec3 worldPos) {
17578
float distXZ = length(worldPos.xz);
17579
float distY = abs(worldPos.y);
17580
return max(distXZ, distY);
17581
}
17582
17583
float FLWFogFactor() {
17584
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
17585
}
17586
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
17587
vec2 shiftLight(vec2 lm) {
17588
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
17589
}
17590
17591
17592
uniform sampler3D uLightVolume;
17593
17594
uniform sampler2D uBlockAtlas;
17595
uniform sampler2D uLightMap;
17596
17597
uniform vec3 uLightBoxSize;
17598
uniform vec3 uLightBoxMin;
17599
uniform mat4 uModel;
17600
17601
uniform float uTime;
17602
uniform mat4 uViewProjection;
17603
uniform vec3 uCameraPos;
17604
17605
void FLWFinalizeNormal(inout vec3 normal) {
17606
mat3 m;
17607
m[0] = uModel[0].xyz;
17608
m[1] = uModel[1].xyz;
17609
m[2] = uModel[2].xyz;
17610
normal = m * normal;
17611
}
17612
17613
#if defined(VERTEX_SHADER)
17614
17615
out vec3 BoxCoord;
17616
17617
void FLWFinalizeWorldPos(inout vec4 worldPos) {
17618
worldPos = uModel * worldPos;
17619
17620
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
17621
17622
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
17623
17624
gl_Position = uViewProjection * worldPos;
17625
}
17626
17627
#elif defined(FRAGMENT_SHADER)
17628
17629
17630
#define ALPHA_DISCARD 0.1
17631
// optimize discard usage
17632
#if defined(ALPHA_DISCARD)
17633
#if defined(GL_ARB_conservative_depth)
17634
layout (depth_greater) out float gl_FragDepth;
17635
#endif
17636
#endif
17637
17638
in vec3 BoxCoord;
17639
17640
out vec4 FragColor;
17641
17642
vec4 FLWBlockTexture(vec2 texCoords) {
17643
return texture(uBlockAtlas, texCoords);
17644
}
17645
17646
void FLWFinalizeColor(vec4 color) {
17647
float a = color.a;
17648
float fog = clamp(FLWFogFactor(), 0., 1.);
17649
17650
color = mix(uFogColor, color, fog);
17651
color.a = a;
17652
17653
#if defined(ALPHA_DISCARD)
17654
if (color.a < ALPHA_DISCARD) {
17655
discard;
17656
}
17657
#endif
17658
17659
FragColor = color;
17660
}
17661
17662
vec4 FLWLight(vec2 lightCoords) {
17663
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
17664
17665
return texture(uLightMap, shiftLight(lightCoords));
17666
}
17667
17668
#endif
17669
17670
17671
mat4 rotate(vec3 axis, float angle) {
17672
float s = sin(angle);
17673
float c = cos(angle);
17674
float oc = 1. - c;
17675
17676
vec3 sa = axis * s;
17677
17678
mat4 mr = mat4(1.);
17679
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
17680
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
17681
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
17682
17683
return mr;
17684
}
17685
17686
mat4 rotation(vec3 rot) {
17687
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
17688
}
17689
17690
mat3 modelToNormal(mat4 mat) {
17691
// Discard the edges. This won't be accurate for scaled or skewed matrices,
17692
// but we don't have to work with those often.
17693
mat3 m;
17694
m[0] = mat[0].xyz;
17695
m[1] = mat[1].xyz;
17696
m[2] = mat[2].xyz;
17697
return m;
17698
}
17699
17700
#define PIOVER2 1.5707963268
17701
17702
vec4 quat(vec3 axis, float angle) {
17703
float halfAngle = angle * PIOVER2 / 180.0;
17704
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
17705
return vec4(axis.xyz * cs.y, cs.x);
17706
}
17707
17708
vec4 quatMult(vec4 q1, vec4 q2) {
17709
// disgustingly vectorized quaternion multiplication
17710
vec4 a = q1.w * q2.xyzw;
17711
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
17712
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
17713
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
17714
17715
return a + b + c + d;
17716
}
17717
17718
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
17719
vec3 i = q.xyz;
17720
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
17721
}
17722
17723
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
17724
return rotateVertexByQuat(v, quat(axis, angle));
17725
}
17726
17727
float diffuse(vec3 normal) {
17728
vec3 n2 = normal * normal * vec3(.6, .25, .8);
17729
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
17730
}
17731
struct Vertex {
17732
vec3 pos;
17733
vec2 texCoords;
17734
vec3 normal;
17735
};
17736
17737
struct BlockFrag {
17738
vec2 texCoords;
17739
vec4 color;
17740
float diffuse;
17741
vec2 light;
17742
};
17743
17744
#if defined(FRAGMENT_SHADER)
17745
void fragment(BlockFrag r) {
17746
vec4 tex = FLWBlockTexture(r.texCoords);
17747
17748
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
17749
17750
FLWFinalizeColor(color);
17751
}
17752
#endif
17753
#define PI 3.1415926538
17754
17755
17756
17757
17758
17759
struct Flap {
17760
vec3 instancePos;
17761
vec2 light;
17762
vec3 segmentOffset;
17763
vec3 pivot;
17764
float horizontalAngle;
17765
float intensity;
17766
float flapScale;
17767
float flapness;
17768
};
17769
17770
17771
17772
17773
#if defined(VERTEX_SHADER)
17774
17775
float toRad(float degrees) {
17776
return fract(degrees / 360.) * PI * 2.;
17777
}
17778
17779
float getFlapAngle(float flapness, float intensity, float scale) {
17780
float absFlap = abs(flapness);
17781
17782
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
17783
17784
float halfAngle = angle * 0.5;
17785
17786
float which = step(0., flapness); // 0 if negative, 1 if positive
17787
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
17788
17789
return degrees;
17790
}
17791
17792
BlockFrag vertex(Vertex v, Flap flap) {
17793
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
17794
17795
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
17796
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
17797
17798
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
17799
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
17800
17801
vec4 worldPos = vec4(rotated, 1.);
17802
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
17803
17804
FLWFinalizeWorldPos(worldPos);
17805
FLWFinalizeNormal(norm);
17806
17807
BlockFrag b;
17808
b.diffuse = diffuse(norm);
17809
b.texCoords = v.texCoords;
17810
b.light = flap.light;
17811
#if defined(DEBUG_NORMAL)
17812
b.color = vec4(norm, 1.);
17813
#else
17814
b.color = vec4(1.);
17815
#endif
17816
return b;
17817
}
17818
#endif
17819
17820
in vec3 a_v_pos;
17821
in vec2 a_v_texCoords;
17822
in vec3 a_v_normal;
17823
in vec3 a_i_instancePos;
17824
in vec2 a_i_light;
17825
in vec3 a_i_segmentOffset;
17826
in vec3 a_i_pivot;
17827
in float a_i_horizontalAngle;
17828
in float a_i_intensity;
17829
in float a_i_flapScale;
17830
in float a_i_flapness;
17831
out vec2 v2f_texCoords;
17832
out vec4 v2f_color;
17833
out float v2f_diffuse;
17834
out vec2 v2f_light;
17835
void main() {
17836
Vertex v;
17837
v.pos = a_v_pos;
17838
v.texCoords = a_v_texCoords;
17839
v.normal = a_v_normal;
17840
Flap i;
17841
i.instancePos = a_i_instancePos;
17842
i.light = a_i_light;
17843
i.segmentOffset = a_i_segmentOffset;
17844
i.pivot = a_i_pivot;
17845
i.horizontalAngle = a_i_horizontalAngle;
17846
i.intensity = a_i_intensity;
17847
i.flapScale = a_i_flapScale;
17848
i.flapness = a_i_flapness;
17849
BlockFrag o = vertex(v, i);
17850
v2f_texCoords = o.texCoords;
17851
v2f_color = o.color;
17852
v2f_diffuse = o.diffuse;
17853
v2f_light = o.light;
17854
}
17855
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:flap: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
17856
17857
[17:17:49] [Render thread/ERROR]: #version 150
17858
#extension GL_ARB_conservative_depth : enable
17859
#define FRAGMENT_SHADER
17860
#define DEBUG_NORMAL
17861
#if defined(VERTEX_SHADER)
17862
out float FragDistance;
17863
#elif defined(FRAGMENT_SHADER)
17864
in float FragDistance;
17865
#endif
17866
uniform vec4 uFogColor;
17867
uniform vec2 uFogRange;
17868
17869
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
17870
float distXZ = length(worldPos.xz - cameraPos.xz);
17871
float distY = abs(worldPos.y - cameraPos.y);
17872
return max(distXZ, distY);
17873
}
17874
17875
float cylindrical_distance(vec3 worldPos) {
17876
float distXZ = length(worldPos.xz);
17877
float distY = abs(worldPos.y);
17878
return max(distXZ, distY);
17879
}
17880
17881
float FLWFogFactor() {
17882
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
17883
}
17884
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
17885
vec2 shiftLight(vec2 lm) {
17886
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
17887
}
17888
17889
17890
uniform sampler3D uLightVolume;
17891
17892
uniform sampler2D uBlockAtlas;
17893
uniform sampler2D uLightMap;
17894
17895
uniform vec3 uLightBoxSize;
17896
uniform vec3 uLightBoxMin;
17897
uniform mat4 uModel;
17898
17899
uniform float uTime;
17900
uniform mat4 uViewProjection;
17901
uniform vec3 uCameraPos;
17902
17903
void FLWFinalizeNormal(inout vec3 normal) {
17904
mat3 m;
17905
m[0] = uModel[0].xyz;
17906
m[1] = uModel[1].xyz;
17907
m[2] = uModel[2].xyz;
17908
normal = m * normal;
17909
}
17910
17911
#if defined(VERTEX_SHADER)
17912
17913
out vec3 BoxCoord;
17914
17915
void FLWFinalizeWorldPos(inout vec4 worldPos) {
17916
worldPos = uModel * worldPos;
17917
17918
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
17919
17920
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
17921
17922
gl_Position = uViewProjection * worldPos;
17923
}
17924
17925
#elif defined(FRAGMENT_SHADER)
17926
17927
17928
#define ALPHA_DISCARD 0.1
17929
// optimize discard usage
17930
#if defined(ALPHA_DISCARD)
17931
#if defined(GL_ARB_conservative_depth)
17932
layout (depth_greater) out float gl_FragDepth;
17933
#endif
17934
#endif
17935
17936
in vec3 BoxCoord;
17937
17938
out vec4 FragColor;
17939
17940
vec4 FLWBlockTexture(vec2 texCoords) {
17941
return texture(uBlockAtlas, texCoords);
17942
}
17943
17944
void FLWFinalizeColor(vec4 color) {
17945
float a = color.a;
17946
float fog = clamp(FLWFogFactor(), 0., 1.);
17947
17948
color = mix(uFogColor, color, fog);
17949
color.a = a;
17950
17951
#if defined(ALPHA_DISCARD)
17952
if (color.a < ALPHA_DISCARD) {
17953
discard;
17954
}
17955
#endif
17956
17957
FragColor = color;
17958
}
17959
17960
vec4 FLWLight(vec2 lightCoords) {
17961
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
17962
17963
return texture(uLightMap, shiftLight(lightCoords));
17964
}
17965
17966
#endif
17967
17968
17969
mat4 rotate(vec3 axis, float angle) {
17970
float s = sin(angle);
17971
float c = cos(angle);
17972
float oc = 1. - c;
17973
17974
vec3 sa = axis * s;
17975
17976
mat4 mr = mat4(1.);
17977
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
17978
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
17979
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
17980
17981
return mr;
17982
}
17983
17984
mat4 rotation(vec3 rot) {
17985
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
17986
}
17987
17988
mat3 modelToNormal(mat4 mat) {
17989
// Discard the edges. This won't be accurate for scaled or skewed matrices,
17990
// but we don't have to work with those often.
17991
mat3 m;
17992
m[0] = mat[0].xyz;
17993
m[1] = mat[1].xyz;
17994
m[2] = mat[2].xyz;
17995
return m;
17996
}
17997
17998
#define PIOVER2 1.5707963268
17999
18000
vec4 quat(vec3 axis, float angle) {
18001
float halfAngle = angle * PIOVER2 / 180.0;
18002
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
18003
return vec4(axis.xyz * cs.y, cs.x);
18004
}
18005
18006
vec4 quatMult(vec4 q1, vec4 q2) {
18007
// disgustingly vectorized quaternion multiplication
18008
vec4 a = q1.w * q2.xyzw;
18009
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
18010
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
18011
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
18012
18013
return a + b + c + d;
18014
}
18015
18016
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
18017
vec3 i = q.xyz;
18018
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
18019
}
18020
18021
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
18022
return rotateVertexByQuat(v, quat(axis, angle));
18023
}
18024
18025
float diffuse(vec3 normal) {
18026
vec3 n2 = normal * normal * vec3(.6, .25, .8);
18027
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
18028
}
18029
struct Vertex {
18030
vec3 pos;
18031
vec2 texCoords;
18032
vec3 normal;
18033
};
18034
18035
struct BlockFrag {
18036
vec2 texCoords;
18037
vec4 color;
18038
float diffuse;
18039
vec2 light;
18040
};
18041
18042
#if defined(FRAGMENT_SHADER)
18043
void fragment(BlockFrag r) {
18044
vec4 tex = FLWBlockTexture(r.texCoords);
18045
18046
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
18047
18048
FLWFinalizeColor(color);
18049
}
18050
#endif
18051
#define PI 3.1415926538
18052
18053
18054
18055
18056
18057
struct Flap {
18058
vec3 instancePos;
18059
vec2 light;
18060
vec3 segmentOffset;
18061
vec3 pivot;
18062
float horizontalAngle;
18063
float intensity;
18064
float flapScale;
18065
float flapness;
18066
};
18067
18068
18069
18070
18071
#if defined(VERTEX_SHADER)
18072
18073
float toRad(float degrees) {
18074
return fract(degrees / 360.) * PI * 2.;
18075
}
18076
18077
float getFlapAngle(float flapness, float intensity, float scale) {
18078
float absFlap = abs(flapness);
18079
18080
float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
18081
18082
float halfAngle = angle * 0.5;
18083
18084
float which = step(0., flapness); // 0 if negative, 1 if positive
18085
float degrees = which * halfAngle + (1. - which) * angle; // branchless conditional multiply
18086
18087
return degrees;
18088
}
18089
18090
BlockFrag vertex(Vertex v, Flap flap) {
18091
float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
18092
18093
vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
18094
vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
18095
18096
vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
18097
rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
18098
18099
vec4 worldPos = vec4(rotated, 1.);
18100
vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
18101
18102
FLWFinalizeWorldPos(worldPos);
18103
FLWFinalizeNormal(norm);
18104
18105
BlockFrag b;
18106
b.diffuse = diffuse(norm);
18107
b.texCoords = v.texCoords;
18108
b.light = flap.light;
18109
#if defined(DEBUG_NORMAL)
18110
b.color = vec4(norm, 1.);
18111
#else
18112
b.color = vec4(1.);
18113
#endif
18114
return b;
18115
}
18116
#endif
18117
18118
in vec2 v2f_texCoords;
18119
in vec4 v2f_color;
18120
in float v2f_diffuse;
18121
in vec2 v2f_light;
18122
void main() {
18123
BlockFrag o;
18124
o.texCoords = v2f_texCoords;
18125
o.color = v2f_color;
18126
o.diffuse = v2f_diffuse;
18127
o.light = v2f_light;
18128
fragment(o);
18129
}
18130
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
18131
18132
[17:17:49] [Render thread/ERROR]: #version 150
18133
#extension GL_ARB_conservative_depth : enable
18134
#define VERTEX_SHADER
18135
#if defined(VERTEX_SHADER)
18136
out float FragDistance;
18137
#elif defined(FRAGMENT_SHADER)
18138
in float FragDistance;
18139
#endif
18140
uniform vec4 uFogColor;
18141
uniform vec2 uFogRange;
18142
18143
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
18144
float distXZ = length(worldPos.xz - cameraPos.xz);
18145
float distY = abs(worldPos.y - cameraPos.y);
18146
return max(distXZ, distY);
18147
}
18148
18149
float cylindrical_distance(vec3 worldPos) {
18150
float distXZ = length(worldPos.xz);
18151
float distY = abs(worldPos.y);
18152
return max(distXZ, distY);
18153
}
18154
18155
float FLWFogFactor() {
18156
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
18157
}
18158
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
18159
vec2 shiftLight(vec2 lm) {
18160
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
18161
}
18162
18163
18164
uniform sampler3D uLightVolume;
18165
18166
uniform sampler2D uBlockAtlas;
18167
uniform sampler2D uLightMap;
18168
18169
uniform vec3 uLightBoxSize;
18170
uniform vec3 uLightBoxMin;
18171
uniform mat4 uModel;
18172
18173
uniform float uTime;
18174
uniform mat4 uViewProjection;
18175
uniform vec3 uCameraPos;
18176
18177
void FLWFinalizeNormal(inout vec3 normal) {
18178
mat3 m;
18179
m[0] = uModel[0].xyz;
18180
m[1] = uModel[1].xyz;
18181
m[2] = uModel[2].xyz;
18182
normal = m * normal;
18183
}
18184
18185
#if defined(VERTEX_SHADER)
18186
18187
out vec3 BoxCoord;
18188
18189
void FLWFinalizeWorldPos(inout vec4 worldPos) {
18190
worldPos = uModel * worldPos;
18191
18192
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
18193
18194
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
18195
18196
gl_Position = uViewProjection * worldPos;
18197
}
18198
18199
#elif defined(FRAGMENT_SHADER)
18200
18201
18202
#define ALPHA_DISCARD 0.1
18203
// optimize discard usage
18204
#if defined(ALPHA_DISCARD)
18205
#if defined(GL_ARB_conservative_depth)
18206
layout (depth_greater) out float gl_FragDepth;
18207
#endif
18208
#endif
18209
18210
in vec3 BoxCoord;
18211
18212
out vec4 FragColor;
18213
18214
vec4 FLWBlockTexture(vec2 texCoords) {
18215
return texture(uBlockAtlas, texCoords);
18216
}
18217
18218
void FLWFinalizeColor(vec4 color) {
18219
float a = color.a;
18220
float fog = clamp(FLWFogFactor(), 0., 1.);
18221
18222
color = mix(uFogColor, color, fog);
18223
color.a = a;
18224
18225
#if defined(ALPHA_DISCARD)
18226
if (color.a < ALPHA_DISCARD) {
18227
discard;
18228
}
18229
#endif
18230
18231
FragColor = color;
18232
}
18233
18234
vec4 FLWLight(vec2 lightCoords) {
18235
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
18236
18237
return texture(uLightMap, shiftLight(lightCoords));
18238
}
18239
18240
#endif
18241
18242
18243
#define PIOVER2 1.5707963268
18244
18245
vec4 quat(vec3 axis, float angle) {
18246
float halfAngle = angle * PIOVER2 / 180.0;
18247
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
18248
return vec4(axis.xyz * cs.y, cs.x);
18249
}
18250
18251
vec4 quatMult(vec4 q1, vec4 q2) {
18252
// disgustingly vectorized quaternion multiplication
18253
vec4 a = q1.w * q2.xyzw;
18254
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
18255
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
18256
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
18257
18258
return a + b + c + d;
18259
}
18260
18261
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
18262
vec3 i = q.xyz;
18263
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
18264
}
18265
18266
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
18267
return rotateVertexByQuat(v, quat(axis, angle));
18268
}
18269
18270
mat4 rotate(vec3 axis, float angle) {
18271
float s = sin(angle);
18272
float c = cos(angle);
18273
float oc = 1. - c;
18274
18275
vec3 sa = axis * s;
18276
18277
mat4 mr = mat4(1.);
18278
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
18279
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
18280
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
18281
18282
return mr;
18283
}
18284
18285
mat4 rotation(vec3 rot) {
18286
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
18287
}
18288
18289
mat3 modelToNormal(mat4 mat) {
18290
// Discard the edges. This won't be accurate for scaled or skewed matrices,
18291
// but we don't have to work with those often.
18292
mat3 m;
18293
m[0] = mat[0].xyz;
18294
m[1] = mat[1].xyz;
18295
m[2] = mat[2].xyz;
18296
return m;
18297
}
18298
18299
float diffuse(vec3 normal) {
18300
vec3 n2 = normal * normal * vec3(.6, .25, .8);
18301
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
18302
}
18303
struct Vertex {
18304
vec3 pos;
18305
vec2 texCoords;
18306
vec3 normal;
18307
};
18308
18309
struct BlockFrag {
18310
vec2 texCoords;
18311
vec4 color;
18312
float diffuse;
18313
vec2 light;
18314
};
18315
18316
#if defined(FRAGMENT_SHADER)
18317
void fragment(BlockFrag r) {
18318
vec4 tex = FLWBlockTexture(r.texCoords);
18319
18320
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
18321
18322
FLWFinalizeColor(color);
18323
}
18324
#endif
18325
#define PI 3.1415926538
18326
18327
18328
18329
18330
18331
struct Belt {
18332
vec2 light;
18333
vec4 color;
18334
vec3 pos;
18335
float speed;
18336
float offset;
18337
vec4 rotation;
18338
vec2 sourceTexture;
18339
vec4 scrollTexture;
18340
float scrollMult;
18341
};
18342
18343
18344
18345
18346
#if defined(VERTEX_SHADER)
18347
BlockFrag vertex(Vertex v, Belt instance) {
18348
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
18349
18350
vec4 worldPos = vec4(rotated, 1.);
18351
18352
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
18353
18354
FLWFinalizeWorldPos(worldPos);
18355
FLWFinalizeNormal(norm);
18356
18357
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
18358
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
18359
18360
BlockFrag b;
18361
b.diffuse = diffuse(norm);
18362
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
18363
b.light = instance.light;
18364
18365
#if defined(DEBUG_RAINBOW)
18366
b.color = instance.color;
18367
#elif defined(DEBUG_NORMAL)
18368
b.color = vec4(norm, 1.);
18369
#else
18370
b.color = vec4(1.);
18371
#endif
18372
18373
return b;
18374
}
18375
#endif
18376
18377
in vec3 a_v_pos;
18378
in vec2 a_v_texCoords;
18379
in vec3 a_v_normal;
18380
in vec2 a_i_light;
18381
in vec4 a_i_color;
18382
in vec3 a_i_pos;
18383
in float a_i_speed;
18384
in float a_i_offset;
18385
in vec4 a_i_rotation;
18386
in vec2 a_i_sourceTexture;
18387
in vec4 a_i_scrollTexture;
18388
in float a_i_scrollMult;
18389
out vec2 v2f_texCoords;
18390
out vec4 v2f_color;
18391
out float v2f_diffuse;
18392
out vec2 v2f_light;
18393
void main() {
18394
Vertex v;
18395
v.pos = a_v_pos;
18396
v.texCoords = a_v_texCoords;
18397
v.normal = a_v_normal;
18398
Belt i;
18399
i.light = a_i_light;
18400
i.color = a_i_color;
18401
i.pos = a_i_pos;
18402
i.speed = a_i_speed;
18403
i.offset = a_i_offset;
18404
i.rotation = a_i_rotation;
18405
i.sourceTexture = a_i_sourceTexture;
18406
i.scrollTexture = a_i_scrollTexture;
18407
i.scrollMult = a_i_scrollMult;
18408
BlockFrag o = vertex(v, i);
18409
v2f_texCoords = o.texCoords;
18410
v2f_color = o.color;
18411
v2f_diffuse = o.diffuse;
18412
v2f_light = o.light;
18413
}
18414
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
18415
18416
[17:17:49] [Render thread/ERROR]: #version 150
18417
#extension GL_ARB_conservative_depth : enable
18418
#define FRAGMENT_SHADER
18419
#if defined(VERTEX_SHADER)
18420
out float FragDistance;
18421
#elif defined(FRAGMENT_SHADER)
18422
in float FragDistance;
18423
#endif
18424
uniform vec4 uFogColor;
18425
uniform vec2 uFogRange;
18426
18427
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
18428
float distXZ = length(worldPos.xz - cameraPos.xz);
18429
float distY = abs(worldPos.y - cameraPos.y);
18430
return max(distXZ, distY);
18431
}
18432
18433
float cylindrical_distance(vec3 worldPos) {
18434
float distXZ = length(worldPos.xz);
18435
float distY = abs(worldPos.y);
18436
return max(distXZ, distY);
18437
}
18438
18439
float FLWFogFactor() {
18440
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
18441
}
18442
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
18443
vec2 shiftLight(vec2 lm) {
18444
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
18445
}
18446
18447
18448
uniform sampler3D uLightVolume;
18449
18450
uniform sampler2D uBlockAtlas;
18451
uniform sampler2D uLightMap;
18452
18453
uniform vec3 uLightBoxSize;
18454
uniform vec3 uLightBoxMin;
18455
uniform mat4 uModel;
18456
18457
uniform float uTime;
18458
uniform mat4 uViewProjection;
18459
uniform vec3 uCameraPos;
18460
18461
void FLWFinalizeNormal(inout vec3 normal) {
18462
mat3 m;
18463
m[0] = uModel[0].xyz;
18464
m[1] = uModel[1].xyz;
18465
m[2] = uModel[2].xyz;
18466
normal = m * normal;
18467
}
18468
18469
#if defined(VERTEX_SHADER)
18470
18471
out vec3 BoxCoord;
18472
18473
void FLWFinalizeWorldPos(inout vec4 worldPos) {
18474
worldPos = uModel * worldPos;
18475
18476
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
18477
18478
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
18479
18480
gl_Position = uViewProjection * worldPos;
18481
}
18482
18483
#elif defined(FRAGMENT_SHADER)
18484
18485
18486
#define ALPHA_DISCARD 0.1
18487
// optimize discard usage
18488
#if defined(ALPHA_DISCARD)
18489
#if defined(GL_ARB_conservative_depth)
18490
layout (depth_greater) out float gl_FragDepth;
18491
#endif
18492
#endif
18493
18494
in vec3 BoxCoord;
18495
18496
out vec4 FragColor;
18497
18498
vec4 FLWBlockTexture(vec2 texCoords) {
18499
return texture(uBlockAtlas, texCoords);
18500
}
18501
18502
void FLWFinalizeColor(vec4 color) {
18503
float a = color.a;
18504
float fog = clamp(FLWFogFactor(), 0., 1.);
18505
18506
color = mix(uFogColor, color, fog);
18507
color.a = a;
18508
18509
#if defined(ALPHA_DISCARD)
18510
if (color.a < ALPHA_DISCARD) {
18511
discard;
18512
}
18513
#endif
18514
18515
FragColor = color;
18516
}
18517
18518
vec4 FLWLight(vec2 lightCoords) {
18519
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
18520
18521
return texture(uLightMap, shiftLight(lightCoords));
18522
}
18523
18524
#endif
18525
18526
18527
#define PIOVER2 1.5707963268
18528
18529
vec4 quat(vec3 axis, float angle) {
18530
float halfAngle = angle * PIOVER2 / 180.0;
18531
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
18532
return vec4(axis.xyz * cs.y, cs.x);
18533
}
18534
18535
vec4 quatMult(vec4 q1, vec4 q2) {
18536
// disgustingly vectorized quaternion multiplication
18537
vec4 a = q1.w * q2.xyzw;
18538
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
18539
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
18540
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
18541
18542
return a + b + c + d;
18543
}
18544
18545
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
18546
vec3 i = q.xyz;
18547
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
18548
}
18549
18550
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
18551
return rotateVertexByQuat(v, quat(axis, angle));
18552
}
18553
18554
mat4 rotate(vec3 axis, float angle) {
18555
float s = sin(angle);
18556
float c = cos(angle);
18557
float oc = 1. - c;
18558
18559
vec3 sa = axis * s;
18560
18561
mat4 mr = mat4(1.);
18562
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
18563
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
18564
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
18565
18566
return mr;
18567
}
18568
18569
mat4 rotation(vec3 rot) {
18570
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
18571
}
18572
18573
mat3 modelToNormal(mat4 mat) {
18574
// Discard the edges. This won't be accurate for scaled or skewed matrices,
18575
// but we don't have to work with those often.
18576
mat3 m;
18577
m[0] = mat[0].xyz;
18578
m[1] = mat[1].xyz;
18579
m[2] = mat[2].xyz;
18580
return m;
18581
}
18582
18583
float diffuse(vec3 normal) {
18584
vec3 n2 = normal * normal * vec3(.6, .25, .8);
18585
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
18586
}
18587
struct Vertex {
18588
vec3 pos;
18589
vec2 texCoords;
18590
vec3 normal;
18591
};
18592
18593
struct BlockFrag {
18594
vec2 texCoords;
18595
vec4 color;
18596
float diffuse;
18597
vec2 light;
18598
};
18599
18600
#if defined(FRAGMENT_SHADER)
18601
void fragment(BlockFrag r) {
18602
vec4 tex = FLWBlockTexture(r.texCoords);
18603
18604
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
18605
18606
FLWFinalizeColor(color);
18607
}
18608
#endif
18609
#define PI 3.1415926538
18610
18611
18612
18613
18614
18615
struct Belt {
18616
vec2 light;
18617
vec4 color;
18618
vec3 pos;
18619
float speed;
18620
float offset;
18621
vec4 rotation;
18622
vec2 sourceTexture;
18623
vec4 scrollTexture;
18624
float scrollMult;
18625
};
18626
18627
18628
18629
18630
#if defined(VERTEX_SHADER)
18631
BlockFrag vertex(Vertex v, Belt instance) {
18632
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
18633
18634
vec4 worldPos = vec4(rotated, 1.);
18635
18636
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
18637
18638
FLWFinalizeWorldPos(worldPos);
18639
FLWFinalizeNormal(norm);
18640
18641
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
18642
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
18643
18644
BlockFrag b;
18645
b.diffuse = diffuse(norm);
18646
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
18647
b.light = instance.light;
18648
18649
#if defined(DEBUG_RAINBOW)
18650
b.color = instance.color;
18651
#elif defined(DEBUG_NORMAL)
18652
b.color = vec4(norm, 1.);
18653
#else
18654
b.color = vec4(1.);
18655
#endif
18656
18657
return b;
18658
}
18659
#endif
18660
18661
in vec2 v2f_texCoords;
18662
in vec4 v2f_color;
18663
in float v2f_diffuse;
18664
in vec2 v2f_light;
18665
void main() {
18666
BlockFrag o;
18667
o.texCoords = v2f_texCoords;
18668
o.color = v2f_color;
18669
o.diffuse = v2f_diffuse;
18670
o.light = v2f_light;
18671
fragment(o);
18672
}
18673
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
18674
18675
[17:17:49] [Render thread/ERROR]: #version 150
18676
#extension GL_ARB_conservative_depth : enable
18677
#define VERTEX_SHADER
18678
#define DEBUG_RAINBOW
18679
#if defined(VERTEX_SHADER)
18680
out float FragDistance;
18681
#elif defined(FRAGMENT_SHADER)
18682
in float FragDistance;
18683
#endif
18684
uniform vec4 uFogColor;
18685
uniform vec2 uFogRange;
18686
18687
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
18688
float distXZ = length(worldPos.xz - cameraPos.xz);
18689
float distY = abs(worldPos.y - cameraPos.y);
18690
return max(distXZ, distY);
18691
}
18692
18693
float cylindrical_distance(vec3 worldPos) {
18694
float distXZ = length(worldPos.xz);
18695
float distY = abs(worldPos.y);
18696
return max(distXZ, distY);
18697
}
18698
18699
float FLWFogFactor() {
18700
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
18701
}
18702
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
18703
vec2 shiftLight(vec2 lm) {
18704
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
18705
}
18706
18707
18708
uniform sampler3D uLightVolume;
18709
18710
uniform sampler2D uBlockAtlas;
18711
uniform sampler2D uLightMap;
18712
18713
uniform vec3 uLightBoxSize;
18714
uniform vec3 uLightBoxMin;
18715
uniform mat4 uModel;
18716
18717
uniform float uTime;
18718
uniform mat4 uViewProjection;
18719
uniform vec3 uCameraPos;
18720
18721
void FLWFinalizeNormal(inout vec3 normal) {
18722
mat3 m;
18723
m[0] = uModel[0].xyz;
18724
m[1] = uModel[1].xyz;
18725
m[2] = uModel[2].xyz;
18726
normal = m * normal;
18727
}
18728
18729
#if defined(VERTEX_SHADER)
18730
18731
out vec3 BoxCoord;
18732
18733
void FLWFinalizeWorldPos(inout vec4 worldPos) {
18734
worldPos = uModel * worldPos;
18735
18736
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
18737
18738
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
18739
18740
gl_Position = uViewProjection * worldPos;
18741
}
18742
18743
#elif defined(FRAGMENT_SHADER)
18744
18745
18746
#define ALPHA_DISCARD 0.1
18747
// optimize discard usage
18748
#if defined(ALPHA_DISCARD)
18749
#if defined(GL_ARB_conservative_depth)
18750
layout (depth_greater) out float gl_FragDepth;
18751
#endif
18752
#endif
18753
18754
in vec3 BoxCoord;
18755
18756
out vec4 FragColor;
18757
18758
vec4 FLWBlockTexture(vec2 texCoords) {
18759
return texture(uBlockAtlas, texCoords);
18760
}
18761
18762
void FLWFinalizeColor(vec4 color) {
18763
float a = color.a;
18764
float fog = clamp(FLWFogFactor(), 0., 1.);
18765
18766
color = mix(uFogColor, color, fog);
18767
color.a = a;
18768
18769
#if defined(ALPHA_DISCARD)
18770
if (color.a < ALPHA_DISCARD) {
18771
discard;
18772
}
18773
#endif
18774
18775
FragColor = color;
18776
}
18777
18778
vec4 FLWLight(vec2 lightCoords) {
18779
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
18780
18781
return texture(uLightMap, shiftLight(lightCoords));
18782
}
18783
18784
#endif
18785
18786
18787
#define PIOVER2 1.5707963268
18788
18789
vec4 quat(vec3 axis, float angle) {
18790
float halfAngle = angle * PIOVER2 / 180.0;
18791
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
18792
return vec4(axis.xyz * cs.y, cs.x);
18793
}
18794
18795
vec4 quatMult(vec4 q1, vec4 q2) {
18796
// disgustingly vectorized quaternion multiplication
18797
vec4 a = q1.w * q2.xyzw;
18798
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
18799
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
18800
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
18801
18802
return a + b + c + d;
18803
}
18804
18805
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
18806
vec3 i = q.xyz;
18807
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
18808
}
18809
18810
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
18811
return rotateVertexByQuat(v, quat(axis, angle));
18812
}
18813
18814
mat4 rotate(vec3 axis, float angle) {
18815
float s = sin(angle);
18816
float c = cos(angle);
18817
float oc = 1. - c;
18818
18819
vec3 sa = axis * s;
18820
18821
mat4 mr = mat4(1.);
18822
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
18823
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
18824
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
18825
18826
return mr;
18827
}
18828
18829
mat4 rotation(vec3 rot) {
18830
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
18831
}
18832
18833
mat3 modelToNormal(mat4 mat) {
18834
// Discard the edges. This won't be accurate for scaled or skewed matrices,
18835
// but we don't have to work with those often.
18836
mat3 m;
18837
m[0] = mat[0].xyz;
18838
m[1] = mat[1].xyz;
18839
m[2] = mat[2].xyz;
18840
return m;
18841
}
18842
18843
float diffuse(vec3 normal) {
18844
vec3 n2 = normal * normal * vec3(.6, .25, .8);
18845
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
18846
}
18847
struct Vertex {
18848
vec3 pos;
18849
vec2 texCoords;
18850
vec3 normal;
18851
};
18852
18853
struct BlockFrag {
18854
vec2 texCoords;
18855
vec4 color;
18856
float diffuse;
18857
vec2 light;
18858
};
18859
18860
#if defined(FRAGMENT_SHADER)
18861
void fragment(BlockFrag r) {
18862
vec4 tex = FLWBlockTexture(r.texCoords);
18863
18864
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
18865
18866
FLWFinalizeColor(color);
18867
}
18868
#endif
18869
#define PI 3.1415926538
18870
18871
18872
18873
18874
18875
struct Belt {
18876
vec2 light;
18877
vec4 color;
18878
vec3 pos;
18879
float speed;
18880
float offset;
18881
vec4 rotation;
18882
vec2 sourceTexture;
18883
vec4 scrollTexture;
18884
float scrollMult;
18885
};
18886
18887
18888
18889
18890
#if defined(VERTEX_SHADER)
18891
BlockFrag vertex(Vertex v, Belt instance) {
18892
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
18893
18894
vec4 worldPos = vec4(rotated, 1.);
18895
18896
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
18897
18898
FLWFinalizeWorldPos(worldPos);
18899
FLWFinalizeNormal(norm);
18900
18901
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
18902
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
18903
18904
BlockFrag b;
18905
b.diffuse = diffuse(norm);
18906
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
18907
b.light = instance.light;
18908
18909
#if defined(DEBUG_RAINBOW)
18910
b.color = instance.color;
18911
#elif defined(DEBUG_NORMAL)
18912
b.color = vec4(norm, 1.);
18913
#else
18914
b.color = vec4(1.);
18915
#endif
18916
18917
return b;
18918
}
18919
#endif
18920
18921
in vec3 a_v_pos;
18922
in vec2 a_v_texCoords;
18923
in vec3 a_v_normal;
18924
in vec2 a_i_light;
18925
in vec4 a_i_color;
18926
in vec3 a_i_pos;
18927
in float a_i_speed;
18928
in float a_i_offset;
18929
in vec4 a_i_rotation;
18930
in vec2 a_i_sourceTexture;
18931
in vec4 a_i_scrollTexture;
18932
in float a_i_scrollMult;
18933
out vec2 v2f_texCoords;
18934
out vec4 v2f_color;
18935
out float v2f_diffuse;
18936
out vec2 v2f_light;
18937
void main() {
18938
Vertex v;
18939
v.pos = a_v_pos;
18940
v.texCoords = a_v_texCoords;
18941
v.normal = a_v_normal;
18942
Belt i;
18943
i.light = a_i_light;
18944
i.color = a_i_color;
18945
i.pos = a_i_pos;
18946
i.speed = a_i_speed;
18947
i.offset = a_i_offset;
18948
i.rotation = a_i_rotation;
18949
i.sourceTexture = a_i_sourceTexture;
18950
i.scrollTexture = a_i_scrollTexture;
18951
i.scrollMult = a_i_scrollMult;
18952
BlockFrag o = vertex(v, i);
18953
v2f_texCoords = o.texCoords;
18954
v2f_color = o.color;
18955
v2f_diffuse = o.diffuse;
18956
v2f_light = o.light;
18957
}
18958
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
18959
18960
[17:17:49] [Render thread/ERROR]: #version 150
18961
#extension GL_ARB_conservative_depth : enable
18962
#define FRAGMENT_SHADER
18963
#define DEBUG_RAINBOW
18964
#if defined(VERTEX_SHADER)
18965
out float FragDistance;
18966
#elif defined(FRAGMENT_SHADER)
18967
in float FragDistance;
18968
#endif
18969
uniform vec4 uFogColor;
18970
uniform vec2 uFogRange;
18971
18972
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
18973
float distXZ = length(worldPos.xz - cameraPos.xz);
18974
float distY = abs(worldPos.y - cameraPos.y);
18975
return max(distXZ, distY);
18976
}
18977
18978
float cylindrical_distance(vec3 worldPos) {
18979
float distXZ = length(worldPos.xz);
18980
float distY = abs(worldPos.y);
18981
return max(distXZ, distY);
18982
}
18983
18984
float FLWFogFactor() {
18985
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
18986
}
18987
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
18988
vec2 shiftLight(vec2 lm) {
18989
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
18990
}
18991
18992
18993
uniform sampler3D uLightVolume;
18994
18995
uniform sampler2D uBlockAtlas;
18996
uniform sampler2D uLightMap;
18997
18998
uniform vec3 uLightBoxSize;
18999
uniform vec3 uLightBoxMin;
19000
uniform mat4 uModel;
19001
19002
uniform float uTime;
19003
uniform mat4 uViewProjection;
19004
uniform vec3 uCameraPos;
19005
19006
void FLWFinalizeNormal(inout vec3 normal) {
19007
mat3 m;
19008
m[0] = uModel[0].xyz;
19009
m[1] = uModel[1].xyz;
19010
m[2] = uModel[2].xyz;
19011
normal = m * normal;
19012
}
19013
19014
#if defined(VERTEX_SHADER)
19015
19016
out vec3 BoxCoord;
19017
19018
void FLWFinalizeWorldPos(inout vec4 worldPos) {
19019
worldPos = uModel * worldPos;
19020
19021
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
19022
19023
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
19024
19025
gl_Position = uViewProjection * worldPos;
19026
}
19027
19028
#elif defined(FRAGMENT_SHADER)
19029
19030
19031
#define ALPHA_DISCARD 0.1
19032
// optimize discard usage
19033
#if defined(ALPHA_DISCARD)
19034
#if defined(GL_ARB_conservative_depth)
19035
layout (depth_greater) out float gl_FragDepth;
19036
#endif
19037
#endif
19038
19039
in vec3 BoxCoord;
19040
19041
out vec4 FragColor;
19042
19043
vec4 FLWBlockTexture(vec2 texCoords) {
19044
return texture(uBlockAtlas, texCoords);
19045
}
19046
19047
void FLWFinalizeColor(vec4 color) {
19048
float a = color.a;
19049
float fog = clamp(FLWFogFactor(), 0., 1.);
19050
19051
color = mix(uFogColor, color, fog);
19052
color.a = a;
19053
19054
#if defined(ALPHA_DISCARD)
19055
if (color.a < ALPHA_DISCARD) {
19056
discard;
19057
}
19058
#endif
19059
19060
FragColor = color;
19061
}
19062
19063
vec4 FLWLight(vec2 lightCoords) {
19064
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
19065
19066
return texture(uLightMap, shiftLight(lightCoords));
19067
}
19068
19069
#endif
19070
19071
19072
#define PIOVER2 1.5707963268
19073
19074
vec4 quat(vec3 axis, float angle) {
19075
float halfAngle = angle * PIOVER2 / 180.0;
19076
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
19077
return vec4(axis.xyz * cs.y, cs.x);
19078
}
19079
19080
vec4 quatMult(vec4 q1, vec4 q2) {
19081
// disgustingly vectorized quaternion multiplication
19082
vec4 a = q1.w * q2.xyzw;
19083
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
19084
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
19085
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
19086
19087
return a + b + c + d;
19088
}
19089
19090
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
19091
vec3 i = q.xyz;
19092
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
19093
}
19094
19095
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
19096
return rotateVertexByQuat(v, quat(axis, angle));
19097
}
19098
19099
mat4 rotate(vec3 axis, float angle) {
19100
float s = sin(angle);
19101
float c = cos(angle);
19102
float oc = 1. - c;
19103
19104
vec3 sa = axis * s;
19105
19106
mat4 mr = mat4(1.);
19107
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
19108
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
19109
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
19110
19111
return mr;
19112
}
19113
19114
mat4 rotation(vec3 rot) {
19115
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
19116
}
19117
19118
mat3 modelToNormal(mat4 mat) {
19119
// Discard the edges. This won't be accurate for scaled or skewed matrices,
19120
// but we don't have to work with those often.
19121
mat3 m;
19122
m[0] = mat[0].xyz;
19123
m[1] = mat[1].xyz;
19124
m[2] = mat[2].xyz;
19125
return m;
19126
}
19127
19128
float diffuse(vec3 normal) {
19129
vec3 n2 = normal * normal * vec3(.6, .25, .8);
19130
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
19131
}
19132
struct Vertex {
19133
vec3 pos;
19134
vec2 texCoords;
19135
vec3 normal;
19136
};
19137
19138
struct BlockFrag {
19139
vec2 texCoords;
19140
vec4 color;
19141
float diffuse;
19142
vec2 light;
19143
};
19144
19145
#if defined(FRAGMENT_SHADER)
19146
void fragment(BlockFrag r) {
19147
vec4 tex = FLWBlockTexture(r.texCoords);
19148
19149
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
19150
19151
FLWFinalizeColor(color);
19152
}
19153
#endif
19154
#define PI 3.1415926538
19155
19156
19157
19158
19159
19160
struct Belt {
19161
vec2 light;
19162
vec4 color;
19163
vec3 pos;
19164
float speed;
19165
float offset;
19166
vec4 rotation;
19167
vec2 sourceTexture;
19168
vec4 scrollTexture;
19169
float scrollMult;
19170
};
19171
19172
19173
19174
19175
#if defined(VERTEX_SHADER)
19176
BlockFrag vertex(Vertex v, Belt instance) {
19177
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
19178
19179
vec4 worldPos = vec4(rotated, 1.);
19180
19181
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
19182
19183
FLWFinalizeWorldPos(worldPos);
19184
FLWFinalizeNormal(norm);
19185
19186
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
19187
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
19188
19189
BlockFrag b;
19190
b.diffuse = diffuse(norm);
19191
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
19192
b.light = instance.light;
19193
19194
#if defined(DEBUG_RAINBOW)
19195
b.color = instance.color;
19196
#elif defined(DEBUG_NORMAL)
19197
b.color = vec4(norm, 1.);
19198
#else
19199
b.color = vec4(1.);
19200
#endif
19201
19202
return b;
19203
}
19204
#endif
19205
19206
in vec2 v2f_texCoords;
19207
in vec4 v2f_color;
19208
in float v2f_diffuse;
19209
in vec2 v2f_light;
19210
void main() {
19211
BlockFrag o;
19212
o.texCoords = v2f_texCoords;
19213
o.color = v2f_color;
19214
o.diffuse = v2f_diffuse;
19215
o.light = v2f_light;
19216
fragment(o);
19217
}
19218
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
19219
19220
[17:17:49] [Render thread/ERROR]: #version 150
19221
#extension GL_ARB_conservative_depth : enable
19222
#define VERTEX_SHADER
19223
#define DEBUG_NORMAL
19224
#if defined(VERTEX_SHADER)
19225
out float FragDistance;
19226
#elif defined(FRAGMENT_SHADER)
19227
in float FragDistance;
19228
#endif
19229
uniform vec4 uFogColor;
19230
uniform vec2 uFogRange;
19231
19232
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
19233
float distXZ = length(worldPos.xz - cameraPos.xz);
19234
float distY = abs(worldPos.y - cameraPos.y);
19235
return max(distXZ, distY);
19236
}
19237
19238
float cylindrical_distance(vec3 worldPos) {
19239
float distXZ = length(worldPos.xz);
19240
float distY = abs(worldPos.y);
19241
return max(distXZ, distY);
19242
}
19243
19244
float FLWFogFactor() {
19245
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
19246
}
19247
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
19248
vec2 shiftLight(vec2 lm) {
19249
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
19250
}
19251
19252
19253
uniform sampler3D uLightVolume;
19254
19255
uniform sampler2D uBlockAtlas;
19256
uniform sampler2D uLightMap;
19257
19258
uniform vec3 uLightBoxSize;
19259
uniform vec3 uLightBoxMin;
19260
uniform mat4 uModel;
19261
19262
uniform float uTime;
19263
uniform mat4 uViewProjection;
19264
uniform vec3 uCameraPos;
19265
19266
void FLWFinalizeNormal(inout vec3 normal) {
19267
mat3 m;
19268
m[0] = uModel[0].xyz;
19269
m[1] = uModel[1].xyz;
19270
m[2] = uModel[2].xyz;
19271
normal = m * normal;
19272
}
19273
19274
#if defined(VERTEX_SHADER)
19275
19276
out vec3 BoxCoord;
19277
19278
void FLWFinalizeWorldPos(inout vec4 worldPos) {
19279
worldPos = uModel * worldPos;
19280
19281
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
19282
19283
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
19284
19285
gl_Position = uViewProjection * worldPos;
19286
}
19287
19288
#elif defined(FRAGMENT_SHADER)
19289
19290
19291
#define ALPHA_DISCARD 0.1
19292
// optimize discard usage
19293
#if defined(ALPHA_DISCARD)
19294
#if defined(GL_ARB_conservative_depth)
19295
layout (depth_greater) out float gl_FragDepth;
19296
#endif
19297
#endif
19298
19299
in vec3 BoxCoord;
19300
19301
out vec4 FragColor;
19302
19303
vec4 FLWBlockTexture(vec2 texCoords) {
19304
return texture(uBlockAtlas, texCoords);
19305
}
19306
19307
void FLWFinalizeColor(vec4 color) {
19308
float a = color.a;
19309
float fog = clamp(FLWFogFactor(), 0., 1.);
19310
19311
color = mix(uFogColor, color, fog);
19312
color.a = a;
19313
19314
#if defined(ALPHA_DISCARD)
19315
if (color.a < ALPHA_DISCARD) {
19316
discard;
19317
}
19318
#endif
19319
19320
FragColor = color;
19321
}
19322
19323
vec4 FLWLight(vec2 lightCoords) {
19324
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
19325
19326
return texture(uLightMap, shiftLight(lightCoords));
19327
}
19328
19329
#endif
19330
19331
19332
#define PIOVER2 1.5707963268
19333
19334
vec4 quat(vec3 axis, float angle) {
19335
float halfAngle = angle * PIOVER2 / 180.0;
19336
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
19337
return vec4(axis.xyz * cs.y, cs.x);
19338
}
19339
19340
vec4 quatMult(vec4 q1, vec4 q2) {
19341
// disgustingly vectorized quaternion multiplication
19342
vec4 a = q1.w * q2.xyzw;
19343
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
19344
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
19345
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
19346
19347
return a + b + c + d;
19348
}
19349
19350
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
19351
vec3 i = q.xyz;
19352
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
19353
}
19354
19355
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
19356
return rotateVertexByQuat(v, quat(axis, angle));
19357
}
19358
19359
mat4 rotate(vec3 axis, float angle) {
19360
float s = sin(angle);
19361
float c = cos(angle);
19362
float oc = 1. - c;
19363
19364
vec3 sa = axis * s;
19365
19366
mat4 mr = mat4(1.);
19367
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
19368
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
19369
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
19370
19371
return mr;
19372
}
19373
19374
mat4 rotation(vec3 rot) {
19375
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
19376
}
19377
19378
mat3 modelToNormal(mat4 mat) {
19379
// Discard the edges. This won't be accurate for scaled or skewed matrices,
19380
// but we don't have to work with those often.
19381
mat3 m;
19382
m[0] = mat[0].xyz;
19383
m[1] = mat[1].xyz;
19384
m[2] = mat[2].xyz;
19385
return m;
19386
}
19387
19388
float diffuse(vec3 normal) {
19389
vec3 n2 = normal * normal * vec3(.6, .25, .8);
19390
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
19391
}
19392
struct Vertex {
19393
vec3 pos;
19394
vec2 texCoords;
19395
vec3 normal;
19396
};
19397
19398
struct BlockFrag {
19399
vec2 texCoords;
19400
vec4 color;
19401
float diffuse;
19402
vec2 light;
19403
};
19404
19405
#if defined(FRAGMENT_SHADER)
19406
void fragment(BlockFrag r) {
19407
vec4 tex = FLWBlockTexture(r.texCoords);
19408
19409
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
19410
19411
FLWFinalizeColor(color);
19412
}
19413
#endif
19414
#define PI 3.1415926538
19415
19416
19417
19418
19419
19420
struct Belt {
19421
vec2 light;
19422
vec4 color;
19423
vec3 pos;
19424
float speed;
19425
float offset;
19426
vec4 rotation;
19427
vec2 sourceTexture;
19428
vec4 scrollTexture;
19429
float scrollMult;
19430
};
19431
19432
19433
19434
19435
#if defined(VERTEX_SHADER)
19436
BlockFrag vertex(Vertex v, Belt instance) {
19437
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
19438
19439
vec4 worldPos = vec4(rotated, 1.);
19440
19441
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
19442
19443
FLWFinalizeWorldPos(worldPos);
19444
FLWFinalizeNormal(norm);
19445
19446
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
19447
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
19448
19449
BlockFrag b;
19450
b.diffuse = diffuse(norm);
19451
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
19452
b.light = instance.light;
19453
19454
#if defined(DEBUG_RAINBOW)
19455
b.color = instance.color;
19456
#elif defined(DEBUG_NORMAL)
19457
b.color = vec4(norm, 1.);
19458
#else
19459
b.color = vec4(1.);
19460
#endif
19461
19462
return b;
19463
}
19464
#endif
19465
19466
in vec3 a_v_pos;
19467
in vec2 a_v_texCoords;
19468
in vec3 a_v_normal;
19469
in vec2 a_i_light;
19470
in vec4 a_i_color;
19471
in vec3 a_i_pos;
19472
in float a_i_speed;
19473
in float a_i_offset;
19474
in vec4 a_i_rotation;
19475
in vec2 a_i_sourceTexture;
19476
in vec4 a_i_scrollTexture;
19477
in float a_i_scrollMult;
19478
out vec2 v2f_texCoords;
19479
out vec4 v2f_color;
19480
out float v2f_diffuse;
19481
out vec2 v2f_light;
19482
void main() {
19483
Vertex v;
19484
v.pos = a_v_pos;
19485
v.texCoords = a_v_texCoords;
19486
v.normal = a_v_normal;
19487
Belt i;
19488
i.light = a_i_light;
19489
i.color = a_i_color;
19490
i.pos = a_i_pos;
19491
i.speed = a_i_speed;
19492
i.offset = a_i_offset;
19493
i.rotation = a_i_rotation;
19494
i.sourceTexture = a_i_sourceTexture;
19495
i.scrollTexture = a_i_scrollTexture;
19496
i.scrollMult = a_i_scrollMult;
19497
BlockFrag o = vertex(v, i);
19498
v2f_texCoords = o.texCoords;
19499
v2f_color = o.color;
19500
v2f_diffuse = o.diffuse;
19501
v2f_light = o.light;
19502
}
19503
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:belt: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
19504
19505
[17:17:49] [Render thread/ERROR]: #version 150
19506
#extension GL_ARB_conservative_depth : enable
19507
#define FRAGMENT_SHADER
19508
#define DEBUG_NORMAL
19509
#if defined(VERTEX_SHADER)
19510
out float FragDistance;
19511
#elif defined(FRAGMENT_SHADER)
19512
in float FragDistance;
19513
#endif
19514
uniform vec4 uFogColor;
19515
uniform vec2 uFogRange;
19516
19517
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
19518
float distXZ = length(worldPos.xz - cameraPos.xz);
19519
float distY = abs(worldPos.y - cameraPos.y);
19520
return max(distXZ, distY);
19521
}
19522
19523
float cylindrical_distance(vec3 worldPos) {
19524
float distXZ = length(worldPos.xz);
19525
float distY = abs(worldPos.y);
19526
return max(distXZ, distY);
19527
}
19528
19529
float FLWFogFactor() {
19530
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
19531
}
19532
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
19533
vec2 shiftLight(vec2 lm) {
19534
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
19535
}
19536
19537
19538
uniform sampler3D uLightVolume;
19539
19540
uniform sampler2D uBlockAtlas;
19541
uniform sampler2D uLightMap;
19542
19543
uniform vec3 uLightBoxSize;
19544
uniform vec3 uLightBoxMin;
19545
uniform mat4 uModel;
19546
19547
uniform float uTime;
19548
uniform mat4 uViewProjection;
19549
uniform vec3 uCameraPos;
19550
19551
void FLWFinalizeNormal(inout vec3 normal) {
19552
mat3 m;
19553
m[0] = uModel[0].xyz;
19554
m[1] = uModel[1].xyz;
19555
m[2] = uModel[2].xyz;
19556
normal = m * normal;
19557
}
19558
19559
#if defined(VERTEX_SHADER)
19560
19561
out vec3 BoxCoord;
19562
19563
void FLWFinalizeWorldPos(inout vec4 worldPos) {
19564
worldPos = uModel * worldPos;
19565
19566
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
19567
19568
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
19569
19570
gl_Position = uViewProjection * worldPos;
19571
}
19572
19573
#elif defined(FRAGMENT_SHADER)
19574
19575
19576
#define ALPHA_DISCARD 0.1
19577
// optimize discard usage
19578
#if defined(ALPHA_DISCARD)
19579
#if defined(GL_ARB_conservative_depth)
19580
layout (depth_greater) out float gl_FragDepth;
19581
#endif
19582
#endif
19583
19584
in vec3 BoxCoord;
19585
19586
out vec4 FragColor;
19587
19588
vec4 FLWBlockTexture(vec2 texCoords) {
19589
return texture(uBlockAtlas, texCoords);
19590
}
19591
19592
void FLWFinalizeColor(vec4 color) {
19593
float a = color.a;
19594
float fog = clamp(FLWFogFactor(), 0., 1.);
19595
19596
color = mix(uFogColor, color, fog);
19597
color.a = a;
19598
19599
#if defined(ALPHA_DISCARD)
19600
if (color.a < ALPHA_DISCARD) {
19601
discard;
19602
}
19603
#endif
19604
19605
FragColor = color;
19606
}
19607
19608
vec4 FLWLight(vec2 lightCoords) {
19609
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
19610
19611
return texture(uLightMap, shiftLight(lightCoords));
19612
}
19613
19614
#endif
19615
19616
19617
#define PIOVER2 1.5707963268
19618
19619
vec4 quat(vec3 axis, float angle) {
19620
float halfAngle = angle * PIOVER2 / 180.0;
19621
vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
19622
return vec4(axis.xyz * cs.y, cs.x);
19623
}
19624
19625
vec4 quatMult(vec4 q1, vec4 q2) {
19626
// disgustingly vectorized quaternion multiplication
19627
vec4 a = q1.w * q2.xyzw;
19628
vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
19629
vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
19630
vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
19631
19632
return a + b + c + d;
19633
}
19634
19635
vec3 rotateVertexByQuat(vec3 v, vec4 q) {
19636
vec3 i = q.xyz;
19637
return v + 2.0 * cross(i, cross(i, v) + q.w * v);
19638
}
19639
19640
vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
19641
return rotateVertexByQuat(v, quat(axis, angle));
19642
}
19643
19644
mat4 rotate(vec3 axis, float angle) {
19645
float s = sin(angle);
19646
float c = cos(angle);
19647
float oc = 1. - c;
19648
19649
vec3 sa = axis * s;
19650
19651
mat4 mr = mat4(1.);
19652
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
19653
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
19654
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
19655
19656
return mr;
19657
}
19658
19659
mat4 rotation(vec3 rot) {
19660
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
19661
}
19662
19663
mat3 modelToNormal(mat4 mat) {
19664
// Discard the edges. This won't be accurate for scaled or skewed matrices,
19665
// but we don't have to work with those often.
19666
mat3 m;
19667
m[0] = mat[0].xyz;
19668
m[1] = mat[1].xyz;
19669
m[2] = mat[2].xyz;
19670
return m;
19671
}
19672
19673
float diffuse(vec3 normal) {
19674
vec3 n2 = normal * normal * vec3(.6, .25, .8);
19675
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
19676
}
19677
struct Vertex {
19678
vec3 pos;
19679
vec2 texCoords;
19680
vec3 normal;
19681
};
19682
19683
struct BlockFrag {
19684
vec2 texCoords;
19685
vec4 color;
19686
float diffuse;
19687
vec2 light;
19688
};
19689
19690
#if defined(FRAGMENT_SHADER)
19691
void fragment(BlockFrag r) {
19692
vec4 tex = FLWBlockTexture(r.texCoords);
19693
19694
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
19695
19696
FLWFinalizeColor(color);
19697
}
19698
#endif
19699
#define PI 3.1415926538
19700
19701
19702
19703
19704
19705
struct Belt {
19706
vec2 light;
19707
vec4 color;
19708
vec3 pos;
19709
float speed;
19710
float offset;
19711
vec4 rotation;
19712
vec2 sourceTexture;
19713
vec4 scrollTexture;
19714
float scrollMult;
19715
};
19716
19717
19718
19719
19720
#if defined(VERTEX_SHADER)
19721
BlockFrag vertex(Vertex v, Belt instance) {
19722
vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
19723
19724
vec4 worldPos = vec4(rotated, 1.);
19725
19726
vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
19727
19728
FLWFinalizeWorldPos(worldPos);
19729
FLWFinalizeNormal(norm);
19730
19731
float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
19732
float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
19733
19734
BlockFrag b;
19735
b.diffuse = diffuse(norm);
19736
b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
19737
b.light = instance.light;
19738
19739
#if defined(DEBUG_RAINBOW)
19740
b.color = instance.color;
19741
#elif defined(DEBUG_NORMAL)
19742
b.color = vec4(norm, 1.);
19743
#else
19744
b.color = vec4(1.);
19745
#endif
19746
19747
return b;
19748
}
19749
#endif
19750
19751
in vec2 v2f_texCoords;
19752
in vec4 v2f_color;
19753
in float v2f_diffuse;
19754
in vec2 v2f_light;
19755
void main() {
19756
BlockFrag o;
19757
o.texCoords = v2f_texCoords;
19758
o.color = v2f_color;
19759
o.diffuse = v2f_diffuse;
19760
o.light = v2f_light;
19761
fragment(o);
19762
}
19763
[17:17:49] [Render thread/INFO]: Loading context 'create:context/contraption'
19764
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_structure: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
19765
19766
[17:17:49] [Render thread/ERROR]: #version 150
19767
#extension GL_ARB_conservative_depth : enable
19768
#define VERTEX_SHADER
19769
#if defined(VERTEX_SHADER)
19770
out float FragDistance;
19771
#elif defined(FRAGMENT_SHADER)
19772
in float FragDistance;
19773
#endif
19774
uniform vec4 uFogColor;
19775
uniform vec2 uFogRange;
19776
19777
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
19778
float distXZ = length(worldPos.xz - cameraPos.xz);
19779
float distY = abs(worldPos.y - cameraPos.y);
19780
return max(distXZ, distY);
19781
}
19782
19783
float cylindrical_distance(vec3 worldPos) {
19784
float distXZ = length(worldPos.xz);
19785
float distY = abs(worldPos.y);
19786
return max(distXZ, distY);
19787
}
19788
19789
float FLWFogFactor() {
19790
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
19791
}
19792
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
19793
vec2 shiftLight(vec2 lm) {
19794
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
19795
}
19796
19797
19798
uniform sampler3D uLightVolume;
19799
19800
uniform sampler2D uBlockAtlas;
19801
uniform sampler2D uLightMap;
19802
19803
uniform vec3 uLightBoxSize;
19804
uniform vec3 uLightBoxMin;
19805
uniform mat4 uModel;
19806
19807
uniform float uTime;
19808
uniform mat4 uViewProjection;
19809
uniform vec3 uCameraPos;
19810
19811
void FLWFinalizeNormal(inout vec3 normal) {
19812
mat3 m;
19813
m[0] = uModel[0].xyz;
19814
m[1] = uModel[1].xyz;
19815
m[2] = uModel[2].xyz;
19816
normal = m * normal;
19817
}
19818
19819
#if defined(VERTEX_SHADER)
19820
19821
out vec3 BoxCoord;
19822
19823
void FLWFinalizeWorldPos(inout vec4 worldPos) {
19824
worldPos = uModel * worldPos;
19825
19826
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
19827
19828
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
19829
19830
gl_Position = uViewProjection * worldPos;
19831
}
19832
19833
#elif defined(FRAGMENT_SHADER)
19834
19835
19836
#define ALPHA_DISCARD 0.1
19837
// optimize discard usage
19838
#if defined(ALPHA_DISCARD)
19839
#if defined(GL_ARB_conservative_depth)
19840
layout (depth_greater) out float gl_FragDepth;
19841
#endif
19842
#endif
19843
19844
in vec3 BoxCoord;
19845
19846
out vec4 FragColor;
19847
19848
vec4 FLWBlockTexture(vec2 texCoords) {
19849
return texture(uBlockAtlas, texCoords);
19850
}
19851
19852
void FLWFinalizeColor(vec4 color) {
19853
float a = color.a;
19854
float fog = clamp(FLWFogFactor(), 0., 1.);
19855
19856
color = mix(uFogColor, color, fog);
19857
color.a = a;
19858
19859
#if defined(ALPHA_DISCARD)
19860
if (color.a < ALPHA_DISCARD) {
19861
discard;
19862
}
19863
#endif
19864
19865
FragColor = color;
19866
}
19867
19868
vec4 FLWLight(vec2 lightCoords) {
19869
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
19870
19871
return texture(uLightMap, shiftLight(lightCoords));
19872
}
19873
19874
#endif
19875
19876
19877
mat4 rotate(vec3 axis, float angle) {
19878
float s = sin(angle);
19879
float c = cos(angle);
19880
float oc = 1. - c;
19881
19882
vec3 sa = axis * s;
19883
19884
mat4 mr = mat4(1.);
19885
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
19886
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
19887
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
19888
19889
return mr;
19890
}
19891
19892
mat4 rotation(vec3 rot) {
19893
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
19894
}
19895
19896
mat3 modelToNormal(mat4 mat) {
19897
// Discard the edges. This won't be accurate for scaled or skewed matrices,
19898
// but we don't have to work with those often.
19899
mat3 m;
19900
m[0] = mat[0].xyz;
19901
m[1] = mat[1].xyz;
19902
m[2] = mat[2].xyz;
19903
return m;
19904
}
19905
19906
float diffuse(vec3 normal) {
19907
vec3 n2 = normal * normal * vec3(.6, .25, .8);
19908
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
19909
}
19910
19911
struct BlockFrag {
19912
vec2 texCoords;
19913
vec4 color;
19914
float diffuse;
19915
vec2 light;
19916
};
19917
19918
#if defined(FRAGMENT_SHADER)
19919
void fragment(BlockFrag r) {
19920
vec4 tex = FLWBlockTexture(r.texCoords);
19921
19922
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
19923
19924
FLWFinalizeColor(color);
19925
}
19926
#endif
19927
#define PI 3.1415926538
19928
19929
19930
19931
19932
struct Vertex {
19933
vec3 pos;
19934
vec4 color;
19935
vec2 texCoords;
19936
vec2 modelLight;
19937
vec3 normal;
19938
};
19939
19940
19941
19942
#if defined(VERTEX_SHADER)
19943
BlockFrag vertex(Vertex v) {
19944
vec4 worldPos = vec4(v.pos, 1.);
19945
vec3 norm = v.normal;
19946
19947
FLWFinalizeWorldPos(worldPos);
19948
FLWFinalizeNormal(norm);
19949
19950
BlockFrag b;
19951
b.diffuse = diffuse(norm);
19952
b.texCoords = v.texCoords;
19953
b.light = v.modelLight;
19954
19955
#if defined(DEBUG_NORMAL)
19956
b.color = vec4(norm, 1.);
19957
#else
19958
b.color = v.color;
19959
#endif
19960
19961
return b;
19962
}
19963
#endif
19964
19965
in vec3 a_v_pos;
19966
in vec4 a_v_color;
19967
in vec2 a_v_texCoords;
19968
in vec2 a_v_modelLight;
19969
in vec3 a_v_normal;
19970
out vec2 v2f_texCoords;
19971
out vec4 v2f_color;
19972
out float v2f_diffuse;
19973
out vec2 v2f_light;
19974
void main() {
19975
Vertex v;
19976
v.pos = a_v_pos;
19977
v.color = a_v_color;
19978
v.texCoords = a_v_texCoords;
19979
v.modelLight = a_v_modelLight;
19980
v.normal = a_v_normal;
19981
BlockFrag o = vertex(v);
19982
v2f_texCoords = o.texCoords;
19983
v2f_color = o.color;
19984
v2f_diffuse = o.diffuse;
19985
v2f_light = o.light;
19986
}
19987
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_structure: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
19988
19989
[17:17:49] [Render thread/ERROR]: #version 150
19990
#extension GL_ARB_conservative_depth : enable
19991
#define FRAGMENT_SHADER
19992
#if defined(VERTEX_SHADER)
19993
out float FragDistance;
19994
#elif defined(FRAGMENT_SHADER)
19995
in float FragDistance;
19996
#endif
19997
uniform vec4 uFogColor;
19998
uniform vec2 uFogRange;
19999
20000
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
20001
float distXZ = length(worldPos.xz - cameraPos.xz);
20002
float distY = abs(worldPos.y - cameraPos.y);
20003
return max(distXZ, distY);
20004
}
20005
20006
float cylindrical_distance(vec3 worldPos) {
20007
float distXZ = length(worldPos.xz);
20008
float distY = abs(worldPos.y);
20009
return max(distXZ, distY);
20010
}
20011
20012
float FLWFogFactor() {
20013
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
20014
}
20015
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
20016
vec2 shiftLight(vec2 lm) {
20017
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
20018
}
20019
20020
20021
uniform sampler3D uLightVolume;
20022
20023
uniform sampler2D uBlockAtlas;
20024
uniform sampler2D uLightMap;
20025
20026
uniform vec3 uLightBoxSize;
20027
uniform vec3 uLightBoxMin;
20028
uniform mat4 uModel;
20029
20030
uniform float uTime;
20031
uniform mat4 uViewProjection;
20032
uniform vec3 uCameraPos;
20033
20034
void FLWFinalizeNormal(inout vec3 normal) {
20035
mat3 m;
20036
m[0] = uModel[0].xyz;
20037
m[1] = uModel[1].xyz;
20038
m[2] = uModel[2].xyz;
20039
normal = m * normal;
20040
}
20041
20042
#if defined(VERTEX_SHADER)
20043
20044
out vec3 BoxCoord;
20045
20046
void FLWFinalizeWorldPos(inout vec4 worldPos) {
20047
worldPos = uModel * worldPos;
20048
20049
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
20050
20051
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
20052
20053
gl_Position = uViewProjection * worldPos;
20054
}
20055
20056
#elif defined(FRAGMENT_SHADER)
20057
20058
20059
#define ALPHA_DISCARD 0.1
20060
// optimize discard usage
20061
#if defined(ALPHA_DISCARD)
20062
#if defined(GL_ARB_conservative_depth)
20063
layout (depth_greater) out float gl_FragDepth;
20064
#endif
20065
#endif
20066
20067
in vec3 BoxCoord;
20068
20069
out vec4 FragColor;
20070
20071
vec4 FLWBlockTexture(vec2 texCoords) {
20072
return texture(uBlockAtlas, texCoords);
20073
}
20074
20075
void FLWFinalizeColor(vec4 color) {
20076
float a = color.a;
20077
float fog = clamp(FLWFogFactor(), 0., 1.);
20078
20079
color = mix(uFogColor, color, fog);
20080
color.a = a;
20081
20082
#if defined(ALPHA_DISCARD)
20083
if (color.a < ALPHA_DISCARD) {
20084
discard;
20085
}
20086
#endif
20087
20088
FragColor = color;
20089
}
20090
20091
vec4 FLWLight(vec2 lightCoords) {
20092
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
20093
20094
return texture(uLightMap, shiftLight(lightCoords));
20095
}
20096
20097
#endif
20098
20099
20100
mat4 rotate(vec3 axis, float angle) {
20101
float s = sin(angle);
20102
float c = cos(angle);
20103
float oc = 1. - c;
20104
20105
vec3 sa = axis * s;
20106
20107
mat4 mr = mat4(1.);
20108
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
20109
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
20110
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
20111
20112
return mr;
20113
}
20114
20115
mat4 rotation(vec3 rot) {
20116
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
20117
}
20118
20119
mat3 modelToNormal(mat4 mat) {
20120
// Discard the edges. This won't be accurate for scaled or skewed matrices,
20121
// but we don't have to work with those often.
20122
mat3 m;
20123
m[0] = mat[0].xyz;
20124
m[1] = mat[1].xyz;
20125
m[2] = mat[2].xyz;
20126
return m;
20127
}
20128
20129
float diffuse(vec3 normal) {
20130
vec3 n2 = normal * normal * vec3(.6, .25, .8);
20131
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
20132
}
20133
20134
struct BlockFrag {
20135
vec2 texCoords;
20136
vec4 color;
20137
float diffuse;
20138
vec2 light;
20139
};
20140
20141
#if defined(FRAGMENT_SHADER)
20142
void fragment(BlockFrag r) {
20143
vec4 tex = FLWBlockTexture(r.texCoords);
20144
20145
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
20146
20147
FLWFinalizeColor(color);
20148
}
20149
#endif
20150
#define PI 3.1415926538
20151
20152
20153
20154
20155
struct Vertex {
20156
vec3 pos;
20157
vec4 color;
20158
vec2 texCoords;
20159
vec2 modelLight;
20160
vec3 normal;
20161
};
20162
20163
20164
20165
#if defined(VERTEX_SHADER)
20166
BlockFrag vertex(Vertex v) {
20167
vec4 worldPos = vec4(v.pos, 1.);
20168
vec3 norm = v.normal;
20169
20170
FLWFinalizeWorldPos(worldPos);
20171
FLWFinalizeNormal(norm);
20172
20173
BlockFrag b;
20174
b.diffuse = diffuse(norm);
20175
b.texCoords = v.texCoords;
20176
b.light = v.modelLight;
20177
20178
#if defined(DEBUG_NORMAL)
20179
b.color = vec4(norm, 1.);
20180
#else
20181
b.color = v.color;
20182
#endif
20183
20184
return b;
20185
}
20186
#endif
20187
20188
in vec2 v2f_texCoords;
20189
in vec4 v2f_color;
20190
in float v2f_diffuse;
20191
in vec2 v2f_light;
20192
void main() {
20193
BlockFrag o;
20194
o.texCoords = v2f_texCoords;
20195
o.color = v2f_color;
20196
o.diffuse = v2f_diffuse;
20197
o.light = v2f_light;
20198
fragment(o);
20199
}
20200
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_structure: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
20201
20202
[17:17:49] [Render thread/ERROR]: #version 150
20203
#extension GL_ARB_conservative_depth : enable
20204
#define VERTEX_SHADER
20205
#define DEBUG_NORMAL
20206
#if defined(VERTEX_SHADER)
20207
out float FragDistance;
20208
#elif defined(FRAGMENT_SHADER)
20209
in float FragDistance;
20210
#endif
20211
uniform vec4 uFogColor;
20212
uniform vec2 uFogRange;
20213
20214
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
20215
float distXZ = length(worldPos.xz - cameraPos.xz);
20216
float distY = abs(worldPos.y - cameraPos.y);
20217
return max(distXZ, distY);
20218
}
20219
20220
float cylindrical_distance(vec3 worldPos) {
20221
float distXZ = length(worldPos.xz);
20222
float distY = abs(worldPos.y);
20223
return max(distXZ, distY);
20224
}
20225
20226
float FLWFogFactor() {
20227
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
20228
}
20229
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
20230
vec2 shiftLight(vec2 lm) {
20231
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
20232
}
20233
20234
20235
uniform sampler3D uLightVolume;
20236
20237
uniform sampler2D uBlockAtlas;
20238
uniform sampler2D uLightMap;
20239
20240
uniform vec3 uLightBoxSize;
20241
uniform vec3 uLightBoxMin;
20242
uniform mat4 uModel;
20243
20244
uniform float uTime;
20245
uniform mat4 uViewProjection;
20246
uniform vec3 uCameraPos;
20247
20248
void FLWFinalizeNormal(inout vec3 normal) {
20249
mat3 m;
20250
m[0] = uModel[0].xyz;
20251
m[1] = uModel[1].xyz;
20252
m[2] = uModel[2].xyz;
20253
normal = m * normal;
20254
}
20255
20256
#if defined(VERTEX_SHADER)
20257
20258
out vec3 BoxCoord;
20259
20260
void FLWFinalizeWorldPos(inout vec4 worldPos) {
20261
worldPos = uModel * worldPos;
20262
20263
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
20264
20265
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
20266
20267
gl_Position = uViewProjection * worldPos;
20268
}
20269
20270
#elif defined(FRAGMENT_SHADER)
20271
20272
20273
#define ALPHA_DISCARD 0.1
20274
// optimize discard usage
20275
#if defined(ALPHA_DISCARD)
20276
#if defined(GL_ARB_conservative_depth)
20277
layout (depth_greater) out float gl_FragDepth;
20278
#endif
20279
#endif
20280
20281
in vec3 BoxCoord;
20282
20283
out vec4 FragColor;
20284
20285
vec4 FLWBlockTexture(vec2 texCoords) {
20286
return texture(uBlockAtlas, texCoords);
20287
}
20288
20289
void FLWFinalizeColor(vec4 color) {
20290
float a = color.a;
20291
float fog = clamp(FLWFogFactor(), 0., 1.);
20292
20293
color = mix(uFogColor, color, fog);
20294
color.a = a;
20295
20296
#if defined(ALPHA_DISCARD)
20297
if (color.a < ALPHA_DISCARD) {
20298
discard;
20299
}
20300
#endif
20301
20302
FragColor = color;
20303
}
20304
20305
vec4 FLWLight(vec2 lightCoords) {
20306
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
20307
20308
return texture(uLightMap, shiftLight(lightCoords));
20309
}
20310
20311
#endif
20312
20313
20314
mat4 rotate(vec3 axis, float angle) {
20315
float s = sin(angle);
20316
float c = cos(angle);
20317
float oc = 1. - c;
20318
20319
vec3 sa = axis * s;
20320
20321
mat4 mr = mat4(1.);
20322
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
20323
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
20324
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
20325
20326
return mr;
20327
}
20328
20329
mat4 rotation(vec3 rot) {
20330
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
20331
}
20332
20333
mat3 modelToNormal(mat4 mat) {
20334
// Discard the edges. This won't be accurate for scaled or skewed matrices,
20335
// but we don't have to work with those often.
20336
mat3 m;
20337
m[0] = mat[0].xyz;
20338
m[1] = mat[1].xyz;
20339
m[2] = mat[2].xyz;
20340
return m;
20341
}
20342
20343
float diffuse(vec3 normal) {
20344
vec3 n2 = normal * normal * vec3(.6, .25, .8);
20345
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
20346
}
20347
20348
struct BlockFrag {
20349
vec2 texCoords;
20350
vec4 color;
20351
float diffuse;
20352
vec2 light;
20353
};
20354
20355
#if defined(FRAGMENT_SHADER)
20356
void fragment(BlockFrag r) {
20357
vec4 tex = FLWBlockTexture(r.texCoords);
20358
20359
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
20360
20361
FLWFinalizeColor(color);
20362
}
20363
#endif
20364
#define PI 3.1415926538
20365
20366
20367
20368
20369
struct Vertex {
20370
vec3 pos;
20371
vec4 color;
20372
vec2 texCoords;
20373
vec2 modelLight;
20374
vec3 normal;
20375
};
20376
20377
20378
20379
#if defined(VERTEX_SHADER)
20380
BlockFrag vertex(Vertex v) {
20381
vec4 worldPos = vec4(v.pos, 1.);
20382
vec3 norm = v.normal;
20383
20384
FLWFinalizeWorldPos(worldPos);
20385
FLWFinalizeNormal(norm);
20386
20387
BlockFrag b;
20388
b.diffuse = diffuse(norm);
20389
b.texCoords = v.texCoords;
20390
b.light = v.modelLight;
20391
20392
#if defined(DEBUG_NORMAL)
20393
b.color = vec4(norm, 1.);
20394
#else
20395
b.color = v.color;
20396
#endif
20397
20398
return b;
20399
}
20400
#endif
20401
20402
in vec3 a_v_pos;
20403
in vec4 a_v_color;
20404
in vec2 a_v_texCoords;
20405
in vec2 a_v_modelLight;
20406
in vec3 a_v_normal;
20407
out vec2 v2f_texCoords;
20408
out vec4 v2f_color;
20409
out float v2f_diffuse;
20410
out vec2 v2f_light;
20411
void main() {
20412
Vertex v;
20413
v.pos = a_v_pos;
20414
v.color = a_v_color;
20415
v.texCoords = a_v_texCoords;
20416
v.modelLight = a_v_modelLight;
20417
v.normal = a_v_normal;
20418
BlockFrag o = vertex(v);
20419
v2f_texCoords = o.texCoords;
20420
v2f_color = o.color;
20421
v2f_diffuse = o.diffuse;
20422
v2f_light = o.light;
20423
}
20424
[17:17:49] [Render thread/ERROR]: Shader compilation log for create:contraption_structure: WARNING: 0:2: warning(#62) enable/warn/disable extension is not found. Extension "GL_ARB_conservative_depth" is not supported
20425
20426
[17:17:49] [Render thread/ERROR]: #version 150
20427
#extension GL_ARB_conservative_depth : enable
20428
#define FRAGMENT_SHADER
20429
#define DEBUG_NORMAL
20430
#if defined(VERTEX_SHADER)
20431
out float FragDistance;
20432
#elif defined(FRAGMENT_SHADER)
20433
in float FragDistance;
20434
#endif
20435
uniform vec4 uFogColor;
20436
uniform vec2 uFogRange;
20437
20438
float cylindrical_distance(vec3 worldPos, vec3 cameraPos) {
20439
float distXZ = length(worldPos.xz - cameraPos.xz);
20440
float distY = abs(worldPos.y - cameraPos.y);
20441
return max(distXZ, distY);
20442
}
20443
20444
float cylindrical_distance(vec3 worldPos) {
20445
float distXZ = length(worldPos.xz);
20446
float distY = abs(worldPos.y);
20447
return max(distXZ, distY);
20448
}
20449
20450
float FLWFogFactor() {
20451
return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
20452
}
20453
// Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
20454
vec2 shiftLight(vec2 lm) {
20455
return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
20456
}
20457
20458
20459
uniform sampler3D uLightVolume;
20460
20461
uniform sampler2D uBlockAtlas;
20462
uniform sampler2D uLightMap;
20463
20464
uniform vec3 uLightBoxSize;
20465
uniform vec3 uLightBoxMin;
20466
uniform mat4 uModel;
20467
20468
uniform float uTime;
20469
uniform mat4 uViewProjection;
20470
uniform vec3 uCameraPos;
20471
20472
void FLWFinalizeNormal(inout vec3 normal) {
20473
mat3 m;
20474
m[0] = uModel[0].xyz;
20475
m[1] = uModel[1].xyz;
20476
m[2] = uModel[2].xyz;
20477
normal = m * normal;
20478
}
20479
20480
#if defined(VERTEX_SHADER)
20481
20482
out vec3 BoxCoord;
20483
20484
void FLWFinalizeWorldPos(inout vec4 worldPos) {
20485
worldPos = uModel * worldPos;
20486
20487
BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
20488
20489
FragDistance = max(length(worldPos.xz), abs(worldPos.y)); // cylindrical fog
20490
20491
gl_Position = uViewProjection * worldPos;
20492
}
20493
20494
#elif defined(FRAGMENT_SHADER)
20495
20496
20497
#define ALPHA_DISCARD 0.1
20498
// optimize discard usage
20499
#if defined(ALPHA_DISCARD)
20500
#if defined(GL_ARB_conservative_depth)
20501
layout (depth_greater) out float gl_FragDepth;
20502
#endif
20503
#endif
20504
20505
in vec3 BoxCoord;
20506
20507
out vec4 FragColor;
20508
20509
vec4 FLWBlockTexture(vec2 texCoords) {
20510
return texture(uBlockAtlas, texCoords);
20511
}
20512
20513
void FLWFinalizeColor(vec4 color) {
20514
float a = color.a;
20515
float fog = clamp(FLWFogFactor(), 0., 1.);
20516
20517
color = mix(uFogColor, color, fog);
20518
color.a = a;
20519
20520
#if defined(ALPHA_DISCARD)
20521
if (color.a < ALPHA_DISCARD) {
20522
discard;
20523
}
20524
#endif
20525
20526
FragColor = color;
20527
}
20528
20529
vec4 FLWLight(vec2 lightCoords) {
20530
lightCoords = max(lightCoords, texture(uLightVolume, BoxCoord).rg);
20531
20532
return texture(uLightMap, shiftLight(lightCoords));
20533
}
20534
20535
#endif
20536
20537
20538
mat4 rotate(vec3 axis, float angle) {
20539
float s = sin(angle);
20540
float c = cos(angle);
20541
float oc = 1. - c;
20542
20543
vec3 sa = axis * s;
20544
20545
mat4 mr = mat4(1.);
20546
mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
20547
mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
20548
mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
20549
20550
return mr;
20551
}
20552
20553
mat4 rotation(vec3 rot) {
20554
return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
20555
}
20556
20557
mat3 modelToNormal(mat4 mat) {
20558
// Discard the edges. This won't be accurate for scaled or skewed matrices,
20559
// but we don't have to work with those often.
20560
mat3 m;
20561
m[0] = mat[0].xyz;
20562
m[1] = mat[1].xyz;
20563
m[2] = mat[2].xyz;
20564
return m;
20565
}
20566
20567
float diffuse(vec3 normal) {
20568
vec3 n2 = normal * normal * vec3(.6, .25, .8);
20569
return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
20570
}
20571
20572
struct BlockFrag {
20573
vec2 texCoords;
20574
vec4 color;
20575
float diffuse;
20576
vec2 light;
20577
};
20578
20579
#if defined(FRAGMENT_SHADER)
20580
void fragment(BlockFrag r) {
20581
vec4 tex = FLWBlockTexture(r.texCoords);
20582
20583
vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
20584
20585
FLWFinalizeColor(color);
20586
}
20587
#endif
20588
#define PI 3.1415926538
20589
20590
20591
20592
20593
struct Vertex {
20594
vec3 pos;
20595
vec4 color;
20596
vec2 texCoords;
20597
vec2 modelLight;
20598
vec3 normal;
20599
};
20600
20601
20602
20603
#if defined(VERTEX_SHADER)
20604
BlockFrag vertex(Vertex v) {
20605
vec4 worldPos = vec4(v.pos, 1.);
20606
vec3 norm = v.normal;
20607
20608
FLWFinalizeWorldPos(worldPos);
20609
FLWFinalizeNormal(norm);
20610
20611
BlockFrag b;
20612
b.diffuse = diffuse(norm);
20613
b.texCoords = v.texCoords;
20614
b.light = v.modelLight;
20615
20616
#if defined(DEBUG_NORMAL)
20617
b.color = vec4(norm, 1.);
20618
#else
20619
b.color = v.color;
20620
#endif
20621
20622
return b;
20623
}
20624
#endif
20625
20626
in vec2 v2f_texCoords;
20627
in vec4 v2f_color;
20628
in float v2f_diffuse;
20629
in vec2 v2f_light;
20630
void main() {
20631
BlockFrag o;
20632
o.texCoords = v2f_texCoords;
20633
o.color = v2f_color;
20634
o.diffuse = v2f_diffuse;
20635
o.light = v2f_light;
20636
fragment(o);
20637
}
20638
[17:17:49] [Render thread/INFO]: Loaded all shader programs.
20639
[17:17:52] [Render thread/INFO]: OpenAL initialized on device OpenAL Soft on Headset Earphone (HyperX Virtual Surround Sound)
20640
[17:17:52] [Render thread/INFO]: Sound engine started
20641
[17:17:52] [Render thread/INFO]: Created: 2048x1024x4 minecraft:textures/atlas/blocks.png-atlas
20642
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 56
20643
[17:17:53] [Render thread/INFO]: Created: 256x128x4 minecraft:textures/atlas/signs.png-atlas
20644
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20645
[17:17:53] [Render thread/INFO]: Created: 512x512x4 minecraft:textures/atlas/banner_patterns.png-atlas
20646
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20647
[17:17:53] [Render thread/INFO]: Created: 512x512x4 minecraft:textures/atlas/shield_patterns.png-atlas
20648
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20649
[17:17:53] [Render thread/INFO]: Created: 256x256x4 minecraft:textures/atlas/chest.png-atlas
20650
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20651
[17:17:53] [Render thread/INFO]: Created: 512x256x4 minecraft:textures/atlas/beds.png-atlas
20652
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20653
[17:17:53] [Render thread/INFO]: Created: 512x256x4 minecraft:textures/atlas/shulker_boxes.png-atlas
20654
[17:17:53] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20655
[17:17:55] [Render thread/INFO]: Created: 256x256x0 minecraft:textures/atlas/particles.png-atlas
20656
[17:17:56] [Render thread/INFO]: [OptiFine] Animated sprites: 1
20657
[17:17:56] [Render thread/INFO]: Created: 256x256x0 minecraft:textures/atlas/paintings.png-atlas
20658
[17:17:56] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20659
[17:17:56] [Render thread/INFO]: Created: 128x128x0 minecraft:textures/atlas/mob_effects.png-atlas
20660
[17:17:56] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20661
[17:17:56] [Render thread/INFO]: Created: 128x256x0 jei:textures/atlas/gui.png-atlas
20662
[17:17:56] [Render thread/INFO]: [OptiFine] Animated sprites: 0
20663
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button
20664
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button
20665
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button_cheat
20666
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button_cheat
20667
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_previous
20668
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_previous
20669
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_next
20670
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_next
20671
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: minecraft:missingno
20672
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: minecraft:missingno
20673
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/info
20674
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/info
20675
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/recipe_transfer
20676
[17:17:56] [Render thread/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/recipe_transfer
20677
[17:17:56] [Render thread/INFO]: [OptiFine] *** Reloading custom textures ***
20678
[17:17:56] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20679
[17:17:56] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20680
[17:17:56] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20681
[17:18:06] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20682
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: creeper, name: armor
20683
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: minecart, name: dirt
20684
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: chest_minecart, name: dirt
20685
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: command_block_minecart, name: dirt
20686
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: furnace_minecart, name: dirt
20687
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: hopper_minecart, name: dirt
20688
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: tnt_minecart, name: dirt
20689
[17:18:06] [Render thread/WARN]: [OptiFine] Model renderer not found, model: spawner_minecart, name: dirt
20690
[17:18:07] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20691
[17:18:07] [Render thread/WARN]: [OptiFine] Unknown resource pack file: mod_resources
20692
[17:18:07] [Render thread/INFO]: [OptiFine] Disable Forge light pipeline
20693
[17:18:07] [Render thread/INFO]: [OptiFine] Set ForgeConfig.CLIENT.experimentalForgeLightPipelineEnabled=false
20694
[17:18:14] [Render thread/INFO]: Connecting to Femboiihooters.aternos.me, 25565
20695
[17:18:14] [Netty Client IO #2/INFO]: Connected to a vanilla server. Catching up missing behaviour.
20696
[11Jan2022 17:18:15.585] [Render thread/INFO] [com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService/]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD'
20697
[17:19:01] [Render thread/INFO]: Stopping!
This log will be saved for 3 months from its last view.
Report abuse