So I played create mod for over a year and never had a problem, but now the game just crashes when something moves (i.e mechanical pistons, windmills, gantry carriages etc) and I dont know what to do anymore, I changed the configs, disabled all mods and nothing works
Here are the logs:
[12:41:02] [main/INFO]: ModLauncher running: args [--username, Vulpes_Ignis, --version, create sad face, --gameDir, C:\Users\user\AppData\Roaming\.minecraft\versions\create sad face, --assetsDir, C:\Users\user\AppData\Roaming\.minecraft\assets, --assetIndex, 1.16, --uuid, 1182d9b928f8470fa996501056e8834b, --accessToken, ????????, --userType, mojang, --versionType, release, --width, 925, --height, 530, --launchTarget, fmlclient, --fml.forgeVersion, 36.2.39, --fml.mcVersion, 1.16.5, --fml.forgeGroup, net.minecraftforge, --fml.mcpVersion, 20210115.111550]
[12:41:02] [main/INFO]: ModLauncher 8.1.3+8.1.3+main-8.1.x.c94d18ec starting: java version 1.8.0_51 by Oracle Corporation
[12:41:02] [main/WARN]: LEGACY JDK DETECTED, SECURED JAR HANDLING DISABLED
[12:41:02] [main/INFO]: OptiFineTransformationService.onLoad
[12:41:02] [main/INFO]: OptiFine ZIP file: C:\Users\user\AppData\Roaming\.minecraft\versions\create sad face\mods\OptiFine-1.16.5_HD_U_G8_pre2.jar
[12:41:02] [main/INFO]: Target.PRE_CLASS is available
[12:41:03] [main/INFO]: Added Lets Encrypt root certificates as additional trust
[12:41:03] [main/INFO]: SpongePowered MIXIN Subsystem Version=0.8.4 Source=file:/C:/Users/user/AppData/Roaming/.minecraft/libraries/org/spongepowered/mixin/0.8.4/mixin-0.8.4.jar Service=ModLauncher Env=CLIENT
[12:41:03] [main/INFO]: OptiFineTransformationService.initialize
[12:41:05] [main/INFO]: OptiFineTransformationService.transformers
[12:41:05] [main/INFO]: Targets: 308
[12:41:07] [main/INFO]: additionalClassesLocator: [optifine., net.optifine.]
[12:41:07] [main/INFO]: Launching target 'fmlclient' with arguments [--version, create sad face, --gameDir, C:\Users\user\AppData\Roaming\.minecraft\versions\create sad face, --assetsDir, C:\Users\user\AppData\Roaming\.minecraft\assets, --uuid, 1182d9b928f8470fa996501056e8834b, --username, Vulpes_Ignis, --assetIndex, 1.16, --accessToken, ????????, --userType, mojang, --versionType, release, --width, 925, --height, 530]
[12:41:27] [main/INFO]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD'
[12:41:27] [main/INFO]: Setting user: Vulpes_Ignis
[12:41:28] [main/INFO]: [OptiFine] (Reflector) Class not present: net.minecraft.launchwrapper.Launch
[12:41:28] [main/INFO]: Backend library: LWJGL version 3.2.2 build 10
[12:41:28] [main/INFO]: [OptiFine]
[12:41:28] [main/INFO]: [OptiFine] OptiFine_1.16.5_HD_U_G8_pre2
[12:41:28] [main/INFO]: [OptiFine] Build: 20210305-002749
[12:41:28] [main/INFO]: [OptiFine] OS: Windows 7 (amd64) version 6.1
[12:41:28] [main/INFO]: [OptiFine] Java: 1.8.0_51, Oracle Corporation
[12:41:28] [main/INFO]: [OptiFine] VM: Java HotSpot(TM) 64-Bit Server VM (mixed mode), Oracle Corporation
[12:41:28] [main/INFO]: [OptiFine] LWJGL: 3.3.0 Win32 WGL EGL OSMesa VisualC DLL
[12:41:28] [main/INFO]: [OptiFine] OpenGL: Mobile Intel(R) 4 Series Express Chipset Family, version 2.1.0 - Build 8.15.10.2555, Intel
[12:41:28] [main/INFO]: [OptiFine] OpenGL Version: 2.1.0
[12:41:28] [main/INFO]: [OptiFine] OpenGL Fancy fog: Not available (GL_NV_fog_distance)
[12:41:28] [main/INFO]: [OptiFine] Maximum texture size: 4096x4096
[12:41:28] [main/INFO]: [Shaders] OpenGL Version: 2.1.0 - Build 8.15.10.2555
[12:41:28] [main/INFO]: [Shaders] Vendor: Intel
[12:41:28] [main/INFO]: [Shaders] Renderer: Mobile Intel(R) 4 Series Express Chipset Family
[12:41:28] [main/INFO]: [Shaders] Capabilities: 2.0 2.1 - - -
[12:41:28] [main/INFO]: [Shaders] GL_MAX_DRAW_BUFFERS: 8
[12:41:28] [main/INFO]: [Shaders] GL_MAX_COLOR_ATTACHMENTS_EXT: 8
[12:41:28] [main/INFO]: [Shaders] GL_MAX_TEXTURE_IMAGE_UNITS: 16
[12:41:28] [main/INFO]: [Shaders] Load shaders configuration.
[12:41:28] [main/INFO]: [Shaders] Save shaders configuration.
[12:41:28] [main/INFO]: [Shaders] No shaderpack loaded.
[12:41:28] [VersionCheck/INFO]: [OptiFine] Checking for new version
[12:41:28] [main/INFO]: [OptiFine] (Reflector) Class not present: net.minecraftforge.fml.common.Loader
[12:41:28] [main/INFO]: [OptiFine] VboRegions not supported, missing: OpenGL 1.3, ARB_copy_buffer
[12:41:29] [VersionCheck/INFO]: [OptiFine] Version found: G7
[12:41:29] [modloading-worker-1/INFO]: Forge mod loading, version 36.2.39, for MC 1.16.5 with MCP 20210115.111550
[12:41:29] [modloading-worker-1/INFO]: MinecraftForge v36.2.39 Initialized
[12:41:30] [modloading-worker-0/INFO]: Optifine detected.
[12:41:30] [modloading-worker-0/INFO]: No shader config found.
[12:41:30] [modloading-worker-1/INFO]: Detected new forge version, registering events reflectively.
[12:41:39] [main/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.
[12:41:39] [main/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.
[12:41:42] [main/INFO]: Narrator library for x64 successfully loaded
[12:41:42] [main/INFO]: Reloading ResourceManager: Default, Mod Resources
[12:41:42] [main/INFO]: [OptiFine] *** Reloading textures ***
[12:41:42] [main/INFO]: [OptiFine] Resource packs: Mod Resources
[12:41:43] [main/INFO]: [OptiFine] *** Reflector Forge ***
[12:41:43] [main/INFO]: [OptiFine] (Reflector) Class not present: mods.betterfoliage.client.BetterFoliageClient
[12:41:43] [main/WARN]: [OptiFine] (Reflector) More than one method found: net.minecraftforge.client.ForgeHooksClient.renderMainMenu
[12:41:43] [main/WARN]: [OptiFine] (Reflector) - public static void net.minecraftforge.client.ForgeHooksClient.renderMainMenu(net.minecraft.client.gui.screen.MainMenuScreen,com.mojang.blaze3d.matrix.MatrixStack,net.minecraft.client.gui.FontRenderer,int,int,int)
[12:41:43] [main/WARN]: [OptiFine] (Reflector) - public static void net.minecraftforge.client.ForgeHooksClient.renderMainMenu(net.minecraft.client.gui.screen.MainMenuScreen,com.mojang.blaze3d.matrix.MatrixStack,net.minecraft.client.gui.FontRenderer,int,int)
[12:41:43] [main/INFO]: [OptiFine] (Reflector) Field not present: net.minecraftforge.client.model.pipeline.LightUtil.itemConsumer
[12:41:43] [main/INFO]: [OptiFine] (Reflector) Field not present: net.minecraftforge.client.model.pipeline.LightUtil.tessellator
[12:41:43] [main/INFO]: [OptiFine] (Reflector) Class not present: net.minecraftforge.fml.common.ModContainer
[12:41:43] [main/INFO]: [OptiFine] *** Reflector Vanilla ***
[12:41:51] [Worker-Main-2/INFO]: [OptiFine] Multitexture: false
[12:42:00] [Worker-Main-3/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:42:00] [Worker-Main-3/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:42:00] [Worker-Main-3/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:42:00] [Worker-Main-3/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:02] [Worker-Main-3/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] Multipass connected textures: false
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/00_glass_white/glass_pane_white.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/00_glass_white/glass_white.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/01_glass_orange/glass_orange.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/01_glass_orange/glass_pane_orange.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/02_glass_magenta/glass_magenta.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/02_glass_magenta/glass_pane_magenta.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/03_glass_light_blue/glass_light_blue.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/03_glass_light_blue/glass_pane_light_blue.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/04_glass_yellow/glass_pane_yellow.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/04_glass_yellow/glass_yellow.properties
[12:42:02] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/05_glass_lime/glass_lime.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/05_glass_lime/glass_pane_lime.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/06_glass_pink/glass_pane_pink.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/06_glass_pink/glass_pink.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/07_glass_gray/glass_gray.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/07_glass_gray/glass_pane_gray.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/08_glass_light_gray/glass_light_gray.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/08_glass_light_gray/glass_pane_light_gray.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/09_glass_cyan/glass_cyan.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/09_glass_cyan/glass_pane_cyan.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/10_glass_purple/glass_pane_purple.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/10_glass_purple/glass_purple.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/11_glass_blue/glass_blue.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/11_glass_blue/glass_pane_blue.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/12_glass_brown/glass_brown.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/12_glass_brown/glass_pane_brown.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/13_glass_green/glass_green.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/13_glass_green/glass_pane_green.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/14_glass_red/glass_pane_red.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/14_glass_red/glass_red.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/15_glass_black/glass_black.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/15_glass_black/glass_pane_black.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/20_glass/glass.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/20_glass/glass_pane.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/30_bookshelf/bookshelf.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/40_sandstone/sandstone.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] ConnectedTextures: optifine/ctm/default/41_red_sandstone/red_sandstone.properties
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] Multipass connected textures: false
[12:42:03] [Worker-Main-3/INFO]: [OptiFine] BetterGrass: Parsing default configuration optifine/bettergrass.properties
[12:42:12] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 4
[12:42:12] [Worker-Main-4/INFO]: [OptiFine] Multitexture: false
[12:42:12] [Worker-Main-5/INFO]: [OptiFine] Multitexture: false
[12:42:12] [Forge Version Check/INFO]: [forge] Starting version check at https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json
[12:42:13] [Worker-Main-6/INFO]: [OptiFine] Multitexture: false
[12:42:13] [Worker-Main-2/INFO]: [OptiFine] Scaled non power of 2: jei:gui/icons/recipe_transfer, 7 -> 14
[12:42:14] [Forge Version Check/INFO]: [forge] Found status: AHEAD Current: 36.2.39 Target: null
[12:42:18] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:18] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:18] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:18] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Multitexture: false
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Sprite size: 64
[12:42:19] [Worker-Main-3/INFO]: [OptiFine] Mipmap levels: 6
[12:42:20] [main/INFO]: No shader config found.
[12:42:20] [main/INFO]: Loading context 'flywheel:context/crumbling'
[12:42:20] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:42:20] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: float diffuse(vec3 normal) {
57: vec3 n2 = normal * normal * vec3(.6, .25, .8);
58: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
59: }
60:
61:
62: struct Rotating {
63: vec2 light;
64: vec4 color;
65: vec3 pos;
66: float speed;
67: float offset;
68: vec3 axis;
69: };
70:
71:
72: struct Vertex {
73: vec3 pos;
74: vec3 normal;
75: vec2 texCoords;
76: };
77:
78: struct BlockFrag {
79: vec2 texCoords;
80: vec4 color;
81: float diffuse;
82: vec2 light;
83: };
84:
85: mat4 kineticRotation(float offset, float speed, vec3 axis) {
86: float degrees = offset + uTime * speed * 3./10.;
87: float angle = fract(degrees / 360.) * PI * 2.;
88:
89: return rotate(axis, angle);
90: }
91:
92: BlockFrag FLWMain(Vertex v, Rotating instance) {
93: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
94:
95: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
96: worldPos += vec4(instance.pos + .5, 0.);
97:
98: vec3 norm = modelToNormal(spin) * v.normal;
99:
100: FLWFinalizeWorldPos(worldPos);
101: FLWFinalizeNormal(norm);
102:
103: BlockFrag b;
104: b.diffuse = diffuse(norm);
105: b.texCoords = v.texCoords;
106: b.light = instance.light;
107:
108: #if defined(DEBUG_RAINBOW)
109: b.color = instance.color;
110: #elif defined(DEBUG_NORMAL)
111: b.color = vec4(norm, 1.);
112: #else
113: b.color = vec4(1.);
114: #endif
115:
116: return b;
117: }
118: attribute vec3 a_v_pos;
119: attribute vec3 a_v_normal;
120: attribute vec2 a_v_texCoords;
121:
122: attribute vec2 a_i_light;
123: attribute vec4 a_i_color;
124: attribute vec3 a_i_pos;
125: attribute float a_i_speed;
126: attribute float a_i_offset;
127: attribute vec3 a_i_axis;
128:
129:
130: varying vec2 v2f_texCoords;
131: varying vec4 v2f_color;
132: varying float v2f_diffuse;
133: varying vec2 v2f_light;
134:
135:
136: void main() {
137: Vertex v;
138: v.pos = a_v_pos;
139: v.normal = a_v_normal;
140: v.texCoords = a_v_texCoords;
141:
142:
143: Rotating i;
144: i.light = a_i_light;
145: i.color = a_i_color;
146: i.pos = a_i_pos;
147: i.speed = a_i_speed;
148: i.offset = a_i_offset;
149: i.axis = a_i_axis;
150:
151:
152: BlockFrag o = FLWMain(v, i);
153:
154: v2f_texCoords = o.texCoords;
155: v2f_color = o.color;
156: v2f_diffuse = o.diffuse;
157: v2f_light = o.light;
158:
159: }
[12:42:20] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:20] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:20] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:42:20] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: float diffuse(vec3 normal) {
57: vec3 n2 = normal * normal * vec3(.6, .25, .8);
58: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
59: }
60:
61:
62: struct Rotating {
63: vec2 light;
64: vec4 color;
65: vec3 pos;
66: float speed;
67: float offset;
68: vec3 axis;
69: };
70:
71:
72: struct Vertex {
73: vec3 pos;
74: vec3 normal;
75: vec2 texCoords;
76: };
77:
78: struct BlockFrag {
79: vec2 texCoords;
80: vec4 color;
81: float diffuse;
82: vec2 light;
83: };
84:
85: mat4 kineticRotation(float offset, float speed, vec3 axis) {
86: float degrees = offset + uTime * speed * 3./10.;
87: float angle = fract(degrees / 360.) * PI * 2.;
88:
89: return rotate(axis, angle);
90: }
91:
92: BlockFrag FLWMain(Vertex v, Rotating instance) {
93: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
94:
95: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
96: worldPos += vec4(instance.pos + .5, 0.);
97:
98: vec3 norm = modelToNormal(spin) * v.normal;
99:
100: FLWFinalizeWorldPos(worldPos);
101: FLWFinalizeNormal(norm);
102:
103: BlockFrag b;
104: b.diffuse = diffuse(norm);
105: b.texCoords = v.texCoords;
106: b.light = instance.light;
107:
108: #if defined(DEBUG_RAINBOW)
109: b.color = instance.color;
110: #elif defined(DEBUG_NORMAL)
111: b.color = vec4(norm, 1.);
112: #else
113: b.color = vec4(1.);
114: #endif
115:
116: return b;
117: }
118: attribute vec3 a_v_pos;
119: attribute vec3 a_v_normal;
120: attribute vec2 a_v_texCoords;
121:
122: attribute vec2 a_i_light;
123: attribute vec4 a_i_color;
124: attribute vec3 a_i_pos;
125: attribute float a_i_speed;
126: attribute float a_i_offset;
127: attribute vec3 a_i_axis;
128:
129:
130: varying vec2 v2f_texCoords;
131: varying vec4 v2f_color;
132: varying float v2f_diffuse;
133: varying vec2 v2f_light;
134:
135:
136: void main() {
137: Vertex v;
138: v.pos = a_v_pos;
139: v.normal = a_v_normal;
140: v.texCoords = a_v_texCoords;
141:
142:
143: Rotating i;
144: i.light = a_i_light;
145: i.color = a_i_color;
146: i.pos = a_i_pos;
147: i.speed = a_i_speed;
148: i.offset = a_i_offset;
149: i.axis = a_i_axis;
150:
151:
152: BlockFrag o = FLWMain(v, i);
153:
154: v2f_texCoords = o.texCoords;
155: v2f_color = o.color;
156: v2f_diffuse = o.diffuse;
157: v2f_light = o.light;
158:
159: }
[12:42:21] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:21] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:21] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:42:21] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: float diffuse(vec3 normal) {
58: vec3 n2 = normal * normal * vec3(.6, .25, .8);
59: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
60: }
61:
62:
63: struct Rotating {
64: vec2 light;
65: vec4 color;
66: vec3 pos;
67: float speed;
68: float offset;
69: vec3 axis;
70: };
71:
72:
73: struct Vertex {
74: vec3 pos;
75: vec3 normal;
76: vec2 texCoords;
77: };
78:
79: struct BlockFrag {
80: vec2 texCoords;
81: vec4 color;
82: float diffuse;
83: vec2 light;
84: };
85:
86: mat4 kineticRotation(float offset, float speed, vec3 axis) {
87: float degrees = offset + uTime * speed * 3./10.;
88: float angle = fract(degrees / 360.) * PI * 2.;
89:
90: return rotate(axis, angle);
91: }
92:
93: BlockFrag FLWMain(Vertex v, Rotating instance) {
94: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
95:
96: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
97: worldPos += vec4(instance.pos + .5, 0.);
98:
99: vec3 norm = modelToNormal(spin) * v.normal;
100:
101: FLWFinalizeWorldPos(worldPos);
102: FLWFinalizeNormal(norm);
103:
104: BlockFrag b;
105: b.diffuse = diffuse(norm);
106: b.texCoords = v.texCoords;
107: b.light = instance.light;
108:
109: #if defined(DEBUG_RAINBOW)
110: b.color = instance.color;
111: #elif defined(DEBUG_NORMAL)
112: b.color = vec4(norm, 1.);
113: #else
114: b.color = vec4(1.);
115: #endif
116:
117: return b;
118: }
119: attribute vec3 a_v_pos;
120: attribute vec3 a_v_normal;
121: attribute vec2 a_v_texCoords;
122:
123: attribute vec2 a_i_light;
124: attribute vec4 a_i_color;
125: attribute vec3 a_i_pos;
126: attribute float a_i_speed;
127: attribute float a_i_offset;
128: attribute vec3 a_i_axis;
129:
130:
131: varying vec2 v2f_texCoords;
132: varying vec4 v2f_color;
133: varying float v2f_diffuse;
134: varying vec2 v2f_light;
135:
136:
137: void main() {
138: Vertex v;
139: v.pos = a_v_pos;
140: v.normal = a_v_normal;
141: v.texCoords = a_v_texCoords;
142:
143:
144: Rotating i;
145: i.light = a_i_light;
146: i.color = a_i_color;
147: i.pos = a_i_pos;
148: i.speed = a_i_speed;
149: i.offset = a_i_offset;
150: i.axis = a_i_axis;
151:
152:
153: BlockFrag o = FLWMain(v, i);
154:
155: v2f_texCoords = o.texCoords;
156: v2f_color = o.color;
157: v2f_diffuse = o.diffuse;
158: v2f_light = o.light;
159:
160: }
[12:42:23] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:23] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:23] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:42:23] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: float diffuse(vec3 normal) {
58: vec3 n2 = normal * normal * vec3(.6, .25, .8);
59: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
60: }
61:
62:
63: struct Rotating {
64: vec2 light;
65: vec4 color;
66: vec3 pos;
67: float speed;
68: float offset;
69: vec3 axis;
70: };
71:
72:
73: struct Vertex {
74: vec3 pos;
75: vec3 normal;
76: vec2 texCoords;
77: };
78:
79: struct BlockFrag {
80: vec2 texCoords;
81: vec4 color;
82: float diffuse;
83: vec2 light;
84: };
85:
86: mat4 kineticRotation(float offset, float speed, vec3 axis) {
87: float degrees = offset + uTime * speed * 3./10.;
88: float angle = fract(degrees / 360.) * PI * 2.;
89:
90: return rotate(axis, angle);
91: }
92:
93: BlockFrag FLWMain(Vertex v, Rotating instance) {
94: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
95:
96: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
97: worldPos += vec4(instance.pos + .5, 0.);
98:
99: vec3 norm = modelToNormal(spin) * v.normal;
100:
101: FLWFinalizeWorldPos(worldPos);
102: FLWFinalizeNormal(norm);
103:
104: BlockFrag b;
105: b.diffuse = diffuse(norm);
106: b.texCoords = v.texCoords;
107: b.light = instance.light;
108:
109: #if defined(DEBUG_RAINBOW)
110: b.color = instance.color;
111: #elif defined(DEBUG_NORMAL)
112: b.color = vec4(norm, 1.);
113: #else
114: b.color = vec4(1.);
115: #endif
116:
117: return b;
118: }
119: attribute vec3 a_v_pos;
120: attribute vec3 a_v_normal;
121: attribute vec2 a_v_texCoords;
122:
123: attribute vec2 a_i_light;
124: attribute vec4 a_i_color;
125: attribute vec3 a_i_pos;
126: attribute float a_i_speed;
127: attribute float a_i_offset;
128: attribute vec3 a_i_axis;
129:
130:
131: varying vec2 v2f_texCoords;
132: varying vec4 v2f_color;
133: varying float v2f_diffuse;
134: varying vec2 v2f_light;
135:
136:
137: void main() {
138: Vertex v;
139: v.pos = a_v_pos;
140: v.normal = a_v_normal;
141: v.texCoords = a_v_texCoords;
142:
143:
144: Rotating i;
145: i.light = a_i_light;
146: i.color = a_i_color;
147: i.pos = a_i_pos;
148: i.speed = a_i_speed;
149: i.offset = a_i_offset;
150: i.axis = a_i_axis;
151:
152:
153: BlockFrag o = FLWMain(v, i);
154:
155: v2f_texCoords = o.texCoords;
156: v2f_color = o.color;
157: v2f_diffuse = o.diffuse;
158: v2f_light = o.light;
159:
160: }
[12:42:24] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:24] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:24] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:42:24] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: float diffuse(vec3 normal) {
56: vec3 n2 = normal * normal * vec3(.6, .25, .8);
57: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
58: }
59:
60:
61: struct Rotating {
62: vec2 light;
63: vec4 color;
64: vec3 pos;
65: float speed;
66: float offset;
67: vec3 axis;
68: };
69:
70:
71: struct Vertex {
72: vec3 pos;
73: vec3 normal;
74: vec2 texCoords;
75: };
76:
77: struct BlockFrag {
78: vec2 texCoords;
79: vec4 color;
80: float diffuse;
81: vec2 light;
82: };
83:
84: mat4 kineticRotation(float offset, float speed, vec3 axis) {
85: float degrees = offset + uTime * speed * 3./10.;
86: float angle = fract(degrees / 360.) * PI * 2.;
87:
88: return rotate(axis, angle);
89: }
90:
91: BlockFrag FLWMain(Vertex v, Rotating instance) {
92: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
93:
94: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
95: worldPos += vec4(instance.pos + .5, 0.);
96:
97: vec3 norm = modelToNormal(spin) * v.normal;
98:
99: FLWFinalizeWorldPos(worldPos);
100: FLWFinalizeNormal(norm);
101:
102: BlockFrag b;
103: b.diffuse = diffuse(norm);
104: b.texCoords = v.texCoords;
105: b.light = instance.light;
106:
107: #if defined(DEBUG_RAINBOW)
108: b.color = instance.color;
109: #elif defined(DEBUG_NORMAL)
110: b.color = vec4(norm, 1.);
111: #else
112: b.color = vec4(1.);
113: #endif
114:
115: return b;
116: }
117: attribute vec3 a_v_pos;
118: attribute vec3 a_v_normal;
119: attribute vec2 a_v_texCoords;
120:
121: attribute vec2 a_i_light;
122: attribute vec4 a_i_color;
123: attribute vec3 a_i_pos;
124: attribute float a_i_speed;
125: attribute float a_i_offset;
126: attribute vec3 a_i_axis;
127:
128:
129: varying vec2 v2f_texCoords;
130: varying vec4 v2f_color;
131: varying float v2f_diffuse;
132: varying vec2 v2f_light;
133:
134:
135: void main() {
136: Vertex v;
137: v.pos = a_v_pos;
138: v.normal = a_v_normal;
139: v.texCoords = a_v_texCoords;
140:
141:
142: Rotating i;
143: i.light = a_i_light;
144: i.color = a_i_color;
145: i.pos = a_i_pos;
146: i.speed = a_i_speed;
147: i.offset = a_i_offset;
148: i.axis = a_i_axis;
149:
150:
151: BlockFrag o = FLWMain(v, i);
152:
153: v2f_texCoords = o.texCoords;
154: v2f_color = o.color;
155: v2f_diffuse = o.diffuse;
156: v2f_light = o.light;
157:
158: }
[12:42:24] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:24] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:42:24] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:42:24] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: #define PIOVER2 1.5707963268
57:
58: vec4 quat(vec3 axis, float angle) {
59: float halfAngle = angle * PIOVER2 / 180.0;
60: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
61: return vec4(axis.xyz * cs.y, cs.x);
62: }
63:
64: vec4 quatMult(vec4 q1, vec4 q2) {
65: // disgustingly vectorized quaternion multiplication
66: vec4 a = q1.w * q2.xyzw;
67: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
68: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
69: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
70:
71: return a + b + c + d;
72: }
73:
74: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
75: vec3 i = q.xyz;
76: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
77: }
78:
79: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
80: return rotateVertexByQuat(v, quat(axis, angle));
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Actor {
90: vec3 pos;
91: vec2 light;
92: float offset;
93: vec3 axis;
94: vec4 rotation;
95: vec3 rotationCenter;
96: float speed;
97: };
98:
99:
100: struct Vertex {
101: vec3 pos;
102: vec3 normal;
103: vec2 texCoords;
104: };
105:
106: struct BlockFrag {
107: vec2 texCoords;
108: vec4 color;
109: float diffuse;
110: vec2 light;
111: };
112:
113: BlockFrag FLWMain(Vertex v, Actor instance) {
114: float degrees = instance.offset + uTime * instance.speed / 20.;
115: //float angle = fract(degrees / 360.) * PI * 2.;
116:
117: vec4 kineticRot = quat(instance.axis, degrees);
118: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
119:
120: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
121: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: BlockFrag b;
127: b.diffuse = diffuse(norm);
128: b.texCoords = v.texCoords;
129: b.light = instance.light;
130:
131: #if defined(DEBUG_NORMAL)
132: b.color = vec4(norm, 1.);
133: #else
134: b.color = vec4(1.);
135: #endif
136:
137: return b;
138: }
139: attribute vec3 a_v_pos;
140: attribute vec3 a_v_normal;
141: attribute vec2 a_v_texCoords;
142:
143: attribute vec3 a_i_pos;
144: attribute vec2 a_i_light;
145: attribute float a_i_offset;
146: attribute vec3 a_i_axis;
147: attribute vec4 a_i_rotation;
148: attribute vec3 a_i_rotationCenter;
149: attribute float a_i_speed;
150:
151:
152: varying vec2 v2f_texCoords;
153: varying vec4 v2f_color;
154: varying float v2f_diffuse;
155: varying vec2 v2f_light;
156:
157:
158: void main() {
159: Vertex v;
160: v.pos = a_v_pos;
161: v.normal = a_v_normal;
162: v.texCoords = a_v_texCoords;
163:
164:
165: Actor i;
166: i.pos = a_i_pos;
167: i.light = a_i_light;
168: i.offset = a_i_offset;
169: i.axis = a_i_axis;
170: i.rotation = a_i_rotation;
171: i.rotationCenter = a_i_rotationCenter;
172: i.speed = a_i_speed;
173:
174:
175: BlockFrag o = FLWMain(v, i);
176:
177: v2f_texCoords = o.texCoords;
178: v2f_color = o.color;
179: v2f_diffuse = o.diffuse;
180: v2f_light = o.light;
181:
182: }
[12:42:24] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:24] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:24] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:42:24] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Actor {
91: vec3 pos;
92: vec2 light;
93: float offset;
94: vec3 axis;
95: vec4 rotation;
96: vec3 rotationCenter;
97: float speed;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Actor instance) {
115: float degrees = instance.offset + uTime * instance.speed / 20.;
116: //float angle = fract(degrees / 360.) * PI * 2.;
117:
118: vec4 kineticRot = quat(instance.axis, degrees);
119: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
120:
121: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
122: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
123:
124: FLWFinalizeWorldPos(worldPos);
125: FLWFinalizeNormal(norm);
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords;
130: b.light = instance.light;
131:
132: #if defined(DEBUG_NORMAL)
133: b.color = vec4(norm, 1.);
134: #else
135: b.color = vec4(1.);
136: #endif
137:
138: return b;
139: }
140: attribute vec3 a_v_pos;
141: attribute vec3 a_v_normal;
142: attribute vec2 a_v_texCoords;
143:
144: attribute vec3 a_i_pos;
145: attribute vec2 a_i_light;
146: attribute float a_i_offset;
147: attribute vec3 a_i_axis;
148: attribute vec4 a_i_rotation;
149: attribute vec3 a_i_rotationCenter;
150: attribute float a_i_speed;
151:
152:
153: varying vec2 v2f_texCoords;
154: varying vec4 v2f_color;
155: varying float v2f_diffuse;
156: varying vec2 v2f_light;
157:
158:
159: void main() {
160: Vertex v;
161: v.pos = a_v_pos;
162: v.normal = a_v_normal;
163: v.texCoords = a_v_texCoords;
164:
165:
166: Actor i;
167: i.pos = a_i_pos;
168: i.light = a_i_light;
169: i.offset = a_i_offset;
170: i.axis = a_i_axis;
171: i.rotation = a_i_rotation;
172: i.rotationCenter = a_i_rotationCenter;
173: i.speed = a_i_speed;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:42:24] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:24] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:24] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:42:24] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Actor {
91: vec3 pos;
92: vec2 light;
93: float offset;
94: vec3 axis;
95: vec4 rotation;
96: vec3 rotationCenter;
97: float speed;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Actor instance) {
115: float degrees = instance.offset + uTime * instance.speed / 20.;
116: //float angle = fract(degrees / 360.) * PI * 2.;
117:
118: vec4 kineticRot = quat(instance.axis, degrees);
119: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
120:
121: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
122: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
123:
124: FLWFinalizeWorldPos(worldPos);
125: FLWFinalizeNormal(norm);
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords;
130: b.light = instance.light;
131:
132: #if defined(DEBUG_NORMAL)
133: b.color = vec4(norm, 1.);
134: #else
135: b.color = vec4(1.);
136: #endif
137:
138: return b;
139: }
140: attribute vec3 a_v_pos;
141: attribute vec3 a_v_normal;
142: attribute vec2 a_v_texCoords;
143:
144: attribute vec3 a_i_pos;
145: attribute vec2 a_i_light;
146: attribute float a_i_offset;
147: attribute vec3 a_i_axis;
148: attribute vec4 a_i_rotation;
149: attribute vec3 a_i_rotationCenter;
150: attribute float a_i_speed;
151:
152:
153: varying vec2 v2f_texCoords;
154: varying vec4 v2f_color;
155: varying float v2f_diffuse;
156: varying vec2 v2f_light;
157:
158:
159: void main() {
160: Vertex v;
161: v.pos = a_v_pos;
162: v.normal = a_v_normal;
163: v.texCoords = a_v_texCoords;
164:
165:
166: Actor i;
167: i.pos = a_i_pos;
168: i.light = a_i_light;
169: i.offset = a_i_offset;
170: i.axis = a_i_axis;
171: i.rotation = a_i_rotation;
172: i.rotationCenter = a_i_rotationCenter;
173: i.speed = a_i_speed;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:42:24] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:24] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:25] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:42:25] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Actor {
89: vec3 pos;
90: vec2 light;
91: float offset;
92: vec3 axis;
93: vec4 rotation;
94: vec3 rotationCenter;
95: float speed;
96: };
97:
98:
99: struct Vertex {
100: vec3 pos;
101: vec3 normal;
102: vec2 texCoords;
103: };
104:
105: struct BlockFrag {
106: vec2 texCoords;
107: vec4 color;
108: float diffuse;
109: vec2 light;
110: };
111:
112: BlockFrag FLWMain(Vertex v, Actor instance) {
113: float degrees = instance.offset + uTime * instance.speed / 20.;
114: //float angle = fract(degrees / 360.) * PI * 2.;
115:
116: vec4 kineticRot = quat(instance.axis, degrees);
117: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
118:
119: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
120: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: BlockFrag b;
126: b.diffuse = diffuse(norm);
127: b.texCoords = v.texCoords;
128: b.light = instance.light;
129:
130: #if defined(DEBUG_NORMAL)
131: b.color = vec4(norm, 1.);
132: #else
133: b.color = vec4(1.);
134: #endif
135:
136: return b;
137: }
138: attribute vec3 a_v_pos;
139: attribute vec3 a_v_normal;
140: attribute vec2 a_v_texCoords;
141:
142: attribute vec3 a_i_pos;
143: attribute vec2 a_i_light;
144: attribute float a_i_offset;
145: attribute vec3 a_i_axis;
146: attribute vec4 a_i_rotation;
147: attribute vec3 a_i_rotationCenter;
148: attribute float a_i_speed;
149:
150:
151: varying vec2 v2f_texCoords;
152: varying vec4 v2f_color;
153: varying float v2f_diffuse;
154: varying vec2 v2f_light;
155:
156:
157: void main() {
158: Vertex v;
159: v.pos = a_v_pos;
160: v.normal = a_v_normal;
161: v.texCoords = a_v_texCoords;
162:
163:
164: Actor i;
165: i.pos = a_i_pos;
166: i.light = a_i_light;
167: i.offset = a_i_offset;
168: i.axis = a_i_axis;
169: i.rotation = a_i_rotation;
170: i.rotationCenter = a_i_rotationCenter;
171: i.speed = a_i_speed;
172:
173:
174: BlockFrag o = FLWMain(v, i);
175:
176: v2f_texCoords = o.texCoords;
177: v2f_color = o.color;
178: v2f_diffuse = o.diffuse;
179: v2f_light = o.light;
180:
181: }
[12:42:26] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:26] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:42:26] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:42:26] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: #define PIOVER2 1.5707963268
57:
58: vec4 quat(vec3 axis, float angle) {
59: float halfAngle = angle * PIOVER2 / 180.0;
60: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
61: return vec4(axis.xyz * cs.y, cs.x);
62: }
63:
64: vec4 quatMult(vec4 q1, vec4 q2) {
65: // disgustingly vectorized quaternion multiplication
66: vec4 a = q1.w * q2.xyzw;
67: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
68: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
69: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
70:
71: return a + b + c + d;
72: }
73:
74: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
75: vec3 i = q.xyz;
76: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
77: }
78:
79: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
80: return rotateVertexByQuat(v, quat(axis, angle));
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Flap {
90: vec3 instancePos;
91: vec2 light;
92: vec3 segmentOffset;
93: vec3 pivot;
94: float horizontalAngle;
95: float intensity;
96: float flapScale;
97: float flapness;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114:
115: float toRad(float degrees) {
116: return fract(degrees / 360.) * PI * 2.;
117: }
118:
119: float getFlapAngle(float flapness, float intensity, float scale) {
120: float absFlap = abs(flapness);
121:
122: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
123:
124: float halfAngle = angle * 0.5;
125:
126: float which = step(0., flapness);// 0 if negative, 1 if positive
127: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
128:
129: return degrees;
130: }
131:
132: BlockFrag FLWMain(Vertex v, Flap flap) {
133: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
134:
135: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
136: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
137:
138: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
139: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
140:
141: vec4 worldPos = vec4(rotated, 1.);
142: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
143:
144: FLWFinalizeWorldPos(worldPos);
145: FLWFinalizeNormal(norm);
146:
147: BlockFrag b;
148: b.diffuse = diffuse(norm);
149: b.texCoords = v.texCoords;
150: b.light = flap.light;
151: #if defined(DEBUG_NORMAL)
152: b.color = vec4(norm, 1.);
153: #else
154: b.color = vec4(1.);
155: #endif
156: return b;
157: }
158: attribute vec3 a_v_pos;
159: attribute vec3 a_v_normal;
160: attribute vec2 a_v_texCoords;
161:
162: attribute vec3 a_i_instancePos;
163: attribute vec2 a_i_light;
164: attribute vec3 a_i_segmentOffset;
165: attribute vec3 a_i_pivot;
166: attribute float a_i_horizontalAngle;
167: attribute float a_i_intensity;
168: attribute float a_i_flapScale;
169: attribute float a_i_flapness;
170:
171:
172: varying vec2 v2f_texCoords;
173: varying vec4 v2f_color;
174: varying float v2f_diffuse;
175: varying vec2 v2f_light;
176:
177:
178: void main() {
179: Vertex v;
180: v.pos = a_v_pos;
181: v.normal = a_v_normal;
182: v.texCoords = a_v_texCoords;
183:
184:
185: Flap i;
186: i.instancePos = a_i_instancePos;
187: i.light = a_i_light;
188: i.segmentOffset = a_i_segmentOffset;
189: i.pivot = a_i_pivot;
190: i.horizontalAngle = a_i_horizontalAngle;
191: i.intensity = a_i_intensity;
192: i.flapScale = a_i_flapScale;
193: i.flapness = a_i_flapness;
194:
195:
196: BlockFrag o = FLWMain(v, i);
197:
198: v2f_texCoords = o.texCoords;
199: v2f_color = o.color;
200: v2f_diffuse = o.diffuse;
201: v2f_light = o.light;
202:
203: }
[12:42:27] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:27] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:30] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:42:30] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Flap {
91: vec3 instancePos;
92: vec2 light;
93: vec3 segmentOffset;
94: vec3 pivot;
95: float horizontalAngle;
96: float intensity;
97: float flapScale;
98: float flapness;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115:
116: float toRad(float degrees) {
117: return fract(degrees / 360.) * PI * 2.;
118: }
119:
120: float getFlapAngle(float flapness, float intensity, float scale) {
121: float absFlap = abs(flapness);
122:
123: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
124:
125: float halfAngle = angle * 0.5;
126:
127: float which = step(0., flapness);// 0 if negative, 1 if positive
128: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
129:
130: return degrees;
131: }
132:
133: BlockFrag FLWMain(Vertex v, Flap flap) {
134: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
135:
136: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
137: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
138:
139: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
140: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
141:
142: vec4 worldPos = vec4(rotated, 1.);
143: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
144:
145: FLWFinalizeWorldPos(worldPos);
146: FLWFinalizeNormal(norm);
147:
148: BlockFrag b;
149: b.diffuse = diffuse(norm);
150: b.texCoords = v.texCoords;
151: b.light = flap.light;
152: #if defined(DEBUG_NORMAL)
153: b.color = vec4(norm, 1.);
154: #else
155: b.color = vec4(1.);
156: #endif
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec3 a_i_instancePos;
164: attribute vec2 a_i_light;
165: attribute vec3 a_i_segmentOffset;
166: attribute vec3 a_i_pivot;
167: attribute float a_i_horizontalAngle;
168: attribute float a_i_intensity;
169: attribute float a_i_flapScale;
170: attribute float a_i_flapness;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Flap i;
187: i.instancePos = a_i_instancePos;
188: i.light = a_i_light;
189: i.segmentOffset = a_i_segmentOffset;
190: i.pivot = a_i_pivot;
191: i.horizontalAngle = a_i_horizontalAngle;
192: i.intensity = a_i_intensity;
193: i.flapScale = a_i_flapScale;
194: i.flapness = a_i_flapness;
195:
196:
197: BlockFrag o = FLWMain(v, i);
198:
199: v2f_texCoords = o.texCoords;
200: v2f_color = o.color;
201: v2f_diffuse = o.diffuse;
202: v2f_light = o.light;
203:
204: }
[12:42:33] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:33] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:33] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:42:33] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Flap {
91: vec3 instancePos;
92: vec2 light;
93: vec3 segmentOffset;
94: vec3 pivot;
95: float horizontalAngle;
96: float intensity;
97: float flapScale;
98: float flapness;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115:
116: float toRad(float degrees) {
117: return fract(degrees / 360.) * PI * 2.;
118: }
119:
120: float getFlapAngle(float flapness, float intensity, float scale) {
121: float absFlap = abs(flapness);
122:
123: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
124:
125: float halfAngle = angle * 0.5;
126:
127: float which = step(0., flapness);// 0 if negative, 1 if positive
128: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
129:
130: return degrees;
131: }
132:
133: BlockFrag FLWMain(Vertex v, Flap flap) {
134: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
135:
136: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
137: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
138:
139: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
140: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
141:
142: vec4 worldPos = vec4(rotated, 1.);
143: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
144:
145: FLWFinalizeWorldPos(worldPos);
146: FLWFinalizeNormal(norm);
147:
148: BlockFrag b;
149: b.diffuse = diffuse(norm);
150: b.texCoords = v.texCoords;
151: b.light = flap.light;
152: #if defined(DEBUG_NORMAL)
153: b.color = vec4(norm, 1.);
154: #else
155: b.color = vec4(1.);
156: #endif
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec3 a_i_instancePos;
164: attribute vec2 a_i_light;
165: attribute vec3 a_i_segmentOffset;
166: attribute vec3 a_i_pivot;
167: attribute float a_i_horizontalAngle;
168: attribute float a_i_intensity;
169: attribute float a_i_flapScale;
170: attribute float a_i_flapness;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Flap i;
187: i.instancePos = a_i_instancePos;
188: i.light = a_i_light;
189: i.segmentOffset = a_i_segmentOffset;
190: i.pivot = a_i_pivot;
191: i.horizontalAngle = a_i_horizontalAngle;
192: i.intensity = a_i_intensity;
193: i.flapScale = a_i_flapScale;
194: i.flapness = a_i_flapness;
195:
196:
197: BlockFrag o = FLWMain(v, i);
198:
199: v2f_texCoords = o.texCoords;
200: v2f_color = o.color;
201: v2f_diffuse = o.diffuse;
202: v2f_light = o.light;
203:
204: }
[12:42:35] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:35] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:37] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:42:37] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Flap {
89: vec3 instancePos;
90: vec2 light;
91: vec3 segmentOffset;
92: vec3 pivot;
93: float horizontalAngle;
94: float intensity;
95: float flapScale;
96: float flapness;
97: };
98:
99:
100: struct Vertex {
101: vec3 pos;
102: vec3 normal;
103: vec2 texCoords;
104: };
105:
106: struct BlockFrag {
107: vec2 texCoords;
108: vec4 color;
109: float diffuse;
110: vec2 light;
111: };
112:
113:
114: float toRad(float degrees) {
115: return fract(degrees / 360.) * PI * 2.;
116: }
117:
118: float getFlapAngle(float flapness, float intensity, float scale) {
119: float absFlap = abs(flapness);
120:
121: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
122:
123: float halfAngle = angle * 0.5;
124:
125: float which = step(0., flapness);// 0 if negative, 1 if positive
126: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
127:
128: return degrees;
129: }
130:
131: BlockFrag FLWMain(Vertex v, Flap flap) {
132: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
133:
134: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
135: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
136:
137: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
138: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
139:
140: vec4 worldPos = vec4(rotated, 1.);
141: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
142:
143: FLWFinalizeWorldPos(worldPos);
144: FLWFinalizeNormal(norm);
145:
146: BlockFrag b;
147: b.diffuse = diffuse(norm);
148: b.texCoords = v.texCoords;
149: b.light = flap.light;
150: #if defined(DEBUG_NORMAL)
151: b.color = vec4(norm, 1.);
152: #else
153: b.color = vec4(1.);
154: #endif
155: return b;
156: }
157: attribute vec3 a_v_pos;
158: attribute vec3 a_v_normal;
159: attribute vec2 a_v_texCoords;
160:
161: attribute vec3 a_i_instancePos;
162: attribute vec2 a_i_light;
163: attribute vec3 a_i_segmentOffset;
164: attribute vec3 a_i_pivot;
165: attribute float a_i_horizontalAngle;
166: attribute float a_i_intensity;
167: attribute float a_i_flapScale;
168: attribute float a_i_flapness;
169:
170:
171: varying vec2 v2f_texCoords;
172: varying vec4 v2f_color;
173: varying float v2f_diffuse;
174: varying vec2 v2f_light;
175:
176:
177: void main() {
178: Vertex v;
179: v.pos = a_v_pos;
180: v.normal = a_v_normal;
181: v.texCoords = a_v_texCoords;
182:
183:
184: Flap i;
185: i.instancePos = a_i_instancePos;
186: i.light = a_i_light;
187: i.segmentOffset = a_i_segmentOffset;
188: i.pivot = a_i_pivot;
189: i.horizontalAngle = a_i_horizontalAngle;
190: i.intensity = a_i_intensity;
191: i.flapScale = a_i_flapScale;
192: i.flapness = a_i_flapness;
193:
194:
195: BlockFrag o = FLWMain(v, i);
196:
197: v2f_texCoords = o.texCoords;
198: v2f_color = o.color;
199: v2f_diffuse = o.diffuse;
200: v2f_light = o.light;
201:
202: }
[12:42:41] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:41] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:42:41] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:42:41] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: uniform float uTime;
5: uniform mat4 uViewProjection;
6: uniform vec3 uCameraPos;
7:
8: #if defined(USE_FOG)
9: varying float FragDistance;
10: #endif
11:
12: void FLWFinalizeWorldPos(inout vec4 worldPos) {
13: #if defined(USE_FOG)
14: FragDistance = length(worldPos.xyz - uCameraPos);
15: #endif
16:
17: gl_Position = uViewProjection * worldPos;
18: }
19:
20: void FLWFinalizeNormal(inout vec3 normal) {
21: // noop
22: }
23:
24:
25: mat4 rotate(vec3 axis, float angle) {
26: float s = sin(angle);
27: float c = cos(angle);
28: float oc = 1. - c;
29:
30: vec3 sa = axis * s;
31:
32: mat4 mr = mat4(1.);
33: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
34: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
35: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
36:
37: return mr;
38: }
39:
40: mat4 rotation(vec3 rot) {
41: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
42: }
43:
44: mat3 modelToNormal(mat4 mat) {
45: // Discard the edges. This won't be accurate for scaled or skewed matrices,
46: // but we don't have to work with those often.
47: mat3 m;
48: m[0] = mat[0].xyz;
49: m[1] = mat[1].xyz;
50: m[2] = mat[2].xyz;
51: return m;
52: }
53:
54: #define PIOVER2 1.5707963268
55:
56: vec4 quat(vec3 axis, float angle) {
57: float halfAngle = angle * PIOVER2 / 180.0;
58: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
59: return vec4(axis.xyz * cs.y, cs.x);
60: }
61:
62: vec4 quatMult(vec4 q1, vec4 q2) {
63: // disgustingly vectorized quaternion multiplication
64: vec4 a = q1.w * q2.xyzw;
65: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
66: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
67: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
68:
69: return a + b + c + d;
70: }
71:
72: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
73: vec3 i = q.xyz;
74: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
75: }
76:
77: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
78: return rotateVertexByQuat(v, quat(axis, angle));
79: }
80:
81: float diffuse(vec3 normal) {
82: vec3 n2 = normal * normal * vec3(.6, .25, .8);
83: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
84: }
85:
86:
87: struct Oriented {
88: vec2 light;
89: vec4 color;
90: vec3 pos;
91: vec3 pivot;
92: vec4 rotation;
93: };
94:
95:
96: struct Vertex {
97: vec3 pos;
98: vec3 normal;
99: vec2 texCoords;
100: };
101:
102: struct BlockFrag {
103: vec2 texCoords;
104: vec4 color;
105: float diffuse;
106: vec2 light;
107: };
108:
109: BlockFrag FLWMain(Vertex v, Oriented o) {
110: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
111:
112: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
113:
114: FLWFinalizeWorldPos(worldPos);
115: FLWFinalizeNormal(norm);
116:
117: BlockFrag b;
118: b.diffuse = diffuse(norm);
119: b.texCoords = v.texCoords;
120: b.light = o.light;
121: #if defined(DEBUG_NORMAL)
122: b.color = vec4(norm, 1.);
123: #else
124: b.color = o.color;
125: #endif
126: return b;
127: }
128: attribute vec3 a_v_pos;
129: attribute vec3 a_v_normal;
130: attribute vec2 a_v_texCoords;
131:
132: attribute vec2 a_i_light;
133: attribute vec4 a_i_color;
134: attribute vec3 a_i_pos;
135: attribute vec3 a_i_pivot;
136: attribute vec4 a_i_rotation;
137:
138:
139: varying vec2 v2f_texCoords;
140: varying vec4 v2f_color;
141: varying float v2f_diffuse;
142: varying vec2 v2f_light;
143:
144:
145: void main() {
146: Vertex v;
147: v.pos = a_v_pos;
148: v.normal = a_v_normal;
149: v.texCoords = a_v_texCoords;
150:
151:
152: Oriented i;
153: i.light = a_i_light;
154: i.color = a_i_color;
155: i.pos = a_i_pos;
156: i.pivot = a_i_pivot;
157: i.rotation = a_i_rotation;
158:
159:
160: BlockFrag o = FLWMain(v, i);
161:
162: v2f_texCoords = o.texCoords;
163: v2f_color = o.color;
164: v2f_diffuse = o.diffuse;
165: v2f_light = o.light;
166:
167: }
[12:42:43] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:43] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:43] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:42:43] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Oriented {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: vec3 pivot;
93: vec4 rotation;
94: };
95:
96:
97: struct Vertex {
98: vec3 pos;
99: vec3 normal;
100: vec2 texCoords;
101: };
102:
103: struct BlockFrag {
104: vec2 texCoords;
105: vec4 color;
106: float diffuse;
107: vec2 light;
108: };
109:
110: BlockFrag FLWMain(Vertex v, Oriented o) {
111: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
112:
113: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = o.light;
122: #if defined(DEBUG_NORMAL)
123: b.color = vec4(norm, 1.);
124: #else
125: b.color = o.color;
126: #endif
127: return b;
128: }
129: attribute vec3 a_v_pos;
130: attribute vec3 a_v_normal;
131: attribute vec2 a_v_texCoords;
132:
133: attribute vec2 a_i_light;
134: attribute vec4 a_i_color;
135: attribute vec3 a_i_pos;
136: attribute vec3 a_i_pivot;
137: attribute vec4 a_i_rotation;
138:
139:
140: varying vec2 v2f_texCoords;
141: varying vec4 v2f_color;
142: varying float v2f_diffuse;
143: varying vec2 v2f_light;
144:
145:
146: void main() {
147: Vertex v;
148: v.pos = a_v_pos;
149: v.normal = a_v_normal;
150: v.texCoords = a_v_texCoords;
151:
152:
153: Oriented i;
154: i.light = a_i_light;
155: i.color = a_i_color;
156: i.pos = a_i_pos;
157: i.pivot = a_i_pivot;
158: i.rotation = a_i_rotation;
159:
160:
161: BlockFrag o = FLWMain(v, i);
162:
163: v2f_texCoords = o.texCoords;
164: v2f_color = o.color;
165: v2f_diffuse = o.diffuse;
166: v2f_light = o.light;
167:
168: }
[12:42:43] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:43] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:43] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:42:43] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Oriented {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: vec3 pivot;
93: vec4 rotation;
94: };
95:
96:
97: struct Vertex {
98: vec3 pos;
99: vec3 normal;
100: vec2 texCoords;
101: };
102:
103: struct BlockFrag {
104: vec2 texCoords;
105: vec4 color;
106: float diffuse;
107: vec2 light;
108: };
109:
110: BlockFrag FLWMain(Vertex v, Oriented o) {
111: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
112:
113: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = o.light;
122: #if defined(DEBUG_NORMAL)
123: b.color = vec4(norm, 1.);
124: #else
125: b.color = o.color;
126: #endif
127: return b;
128: }
129: attribute vec3 a_v_pos;
130: attribute vec3 a_v_normal;
131: attribute vec2 a_v_texCoords;
132:
133: attribute vec2 a_i_light;
134: attribute vec4 a_i_color;
135: attribute vec3 a_i_pos;
136: attribute vec3 a_i_pivot;
137: attribute vec4 a_i_rotation;
138:
139:
140: varying vec2 v2f_texCoords;
141: varying vec4 v2f_color;
142: varying float v2f_diffuse;
143: varying vec2 v2f_light;
144:
145:
146: void main() {
147: Vertex v;
148: v.pos = a_v_pos;
149: v.normal = a_v_normal;
150: v.texCoords = a_v_texCoords;
151:
152:
153: Oriented i;
154: i.light = a_i_light;
155: i.color = a_i_color;
156: i.pos = a_i_pos;
157: i.pivot = a_i_pivot;
158: i.rotation = a_i_rotation;
159:
160:
161: BlockFrag o = FLWMain(v, i);
162:
163: v2f_texCoords = o.texCoords;
164: v2f_color = o.color;
165: v2f_diffuse = o.diffuse;
166: v2f_light = o.light;
167:
168: }
[12:42:44] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:44] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:44] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:42:44] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2:
3: uniform float uTime;
4: uniform mat4 uViewProjection;
5: uniform vec3 uCameraPos;
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: void FLWFinalizeWorldPos(inout vec4 worldPos) {
12: #if defined(USE_FOG)
13: FragDistance = length(worldPos.xyz - uCameraPos);
14: #endif
15:
16: gl_Position = uViewProjection * worldPos;
17: }
18:
19: void FLWFinalizeNormal(inout vec3 normal) {
20: // noop
21: }
22:
23:
24: mat4 rotate(vec3 axis, float angle) {
25: float s = sin(angle);
26: float c = cos(angle);
27: float oc = 1. - c;
28:
29: vec3 sa = axis * s;
30:
31: mat4 mr = mat4(1.);
32: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
33: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
34: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
35:
36: return mr;
37: }
38:
39: mat4 rotation(vec3 rot) {
40: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
41: }
42:
43: mat3 modelToNormal(mat4 mat) {
44: // Discard the edges. This won't be accurate for scaled or skewed matrices,
45: // but we don't have to work with those often.
46: mat3 m;
47: m[0] = mat[0].xyz;
48: m[1] = mat[1].xyz;
49: m[2] = mat[2].xyz;
50: return m;
51: }
52:
53: #define PIOVER2 1.5707963268
54:
55: vec4 quat(vec3 axis, float angle) {
56: float halfAngle = angle * PIOVER2 / 180.0;
57: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
58: return vec4(axis.xyz * cs.y, cs.x);
59: }
60:
61: vec4 quatMult(vec4 q1, vec4 q2) {
62: // disgustingly vectorized quaternion multiplication
63: vec4 a = q1.w * q2.xyzw;
64: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
65: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
66: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
67:
68: return a + b + c + d;
69: }
70:
71: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
72: vec3 i = q.xyz;
73: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
74: }
75:
76: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
77: return rotateVertexByQuat(v, quat(axis, angle));
78: }
79:
80: float diffuse(vec3 normal) {
81: vec3 n2 = normal * normal * vec3(.6, .25, .8);
82: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
83: }
84:
85:
86: struct Oriented {
87: vec2 light;
88: vec4 color;
89: vec3 pos;
90: vec3 pivot;
91: vec4 rotation;
92: };
93:
94:
95: struct Vertex {
96: vec3 pos;
97: vec3 normal;
98: vec2 texCoords;
99: };
100:
101: struct BlockFrag {
102: vec2 texCoords;
103: vec4 color;
104: float diffuse;
105: vec2 light;
106: };
107:
108: BlockFrag FLWMain(Vertex v, Oriented o) {
109: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
110:
111: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
112:
113: FLWFinalizeWorldPos(worldPos);
114: FLWFinalizeNormal(norm);
115:
116: BlockFrag b;
117: b.diffuse = diffuse(norm);
118: b.texCoords = v.texCoords;
119: b.light = o.light;
120: #if defined(DEBUG_NORMAL)
121: b.color = vec4(norm, 1.);
122: #else
123: b.color = o.color;
124: #endif
125: return b;
126: }
127: attribute vec3 a_v_pos;
128: attribute vec3 a_v_normal;
129: attribute vec2 a_v_texCoords;
130:
131: attribute vec2 a_i_light;
132: attribute vec4 a_i_color;
133: attribute vec3 a_i_pos;
134: attribute vec3 a_i_pivot;
135: attribute vec4 a_i_rotation;
136:
137:
138: varying vec2 v2f_texCoords;
139: varying vec4 v2f_color;
140: varying float v2f_diffuse;
141: varying vec2 v2f_light;
142:
143:
144: void main() {
145: Vertex v;
146: v.pos = a_v_pos;
147: v.normal = a_v_normal;
148: v.texCoords = a_v_texCoords;
149:
150:
151: Oriented i;
152: i.light = a_i_light;
153: i.color = a_i_color;
154: i.pos = a_i_pos;
155: i.pivot = a_i_pivot;
156: i.rotation = a_i_rotation;
157:
158:
159: BlockFrag o = FLWMain(v, i);
160:
161: v2f_texCoords = o.texCoords;
162: v2f_color = o.color;
163: v2f_diffuse = o.diffuse;
164: v2f_light = o.light;
165:
166: }
[12:42:46] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:46] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:42:46] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:42:46] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: uniform float uTime;
5: uniform mat4 uViewProjection;
6: uniform vec3 uCameraPos;
7:
8: #if defined(USE_FOG)
9: varying float FragDistance;
10: #endif
11:
12: void FLWFinalizeWorldPos(inout vec4 worldPos) {
13: #if defined(USE_FOG)
14: FragDistance = length(worldPos.xyz - uCameraPos);
15: #endif
16:
17: gl_Position = uViewProjection * worldPos;
18: }
19:
20: void FLWFinalizeNormal(inout vec3 normal) {
21: // noop
22: }
23:
24:
25: float diffuse(vec3 normal) {
26: vec3 n2 = normal * normal * vec3(.6, .25, .8);
27: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
28: }
29:
30:
31: struct Vertex {
32: vec3 pos;
33: vec3 normal;
34: vec2 texCoords;
35: };
36:
37: struct BlockFrag {
38: vec2 texCoords;
39: vec4 color;
40: float diffuse;
41: vec2 light;
42: };
43:
44:
45: struct Instance {
46: vec2 light;
47: vec4 color;
48: mat4 transform;
49: mat3 normalMat;
50: };
51:
52: BlockFrag FLWMain(Vertex v, Instance i) {
53: vec4 worldPos = i.transform * vec4(v.pos, 1.);
54:
55: vec3 norm = i.normalMat * v.normal;
56:
57: FLWFinalizeWorldPos(worldPos);
58: FLWFinalizeNormal(norm);
59:
60: norm = normalize(norm);
61:
62: BlockFrag b;
63: b.diffuse = diffuse(norm);
64: b.texCoords = v.texCoords;
65: b.light = i.light;
66: #if defined(DEBUG_NORMAL)
67: b.color = vec4(norm, 1.);
68: #else
69: b.color = i.color;
70: #endif
71: return b;
72: }
73: attribute vec3 a_v_pos;
74: attribute vec3 a_v_normal;
75: attribute vec2 a_v_texCoords;
76:
77: attribute vec2 a_i_light;
78: attribute vec4 a_i_color;
79: attribute mat4 a_i_transform;
80: attribute mat3 a_i_normalMat;
81:
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: void main() {
90: Vertex v;
91: v.pos = a_v_pos;
92: v.normal = a_v_normal;
93: v.texCoords = a_v_texCoords;
94:
95:
96: Instance i;
97: i.light = a_i_light;
98: i.color = a_i_color;
99: i.transform = a_i_transform;
100: i.normalMat = a_i_normalMat;
101:
102:
103: BlockFrag o = FLWMain(v, i);
104:
105: v2f_texCoords = o.texCoords;
106: v2f_color = o.color;
107: v2f_diffuse = o.diffuse;
108: v2f_light = o.light;
109:
110: }
[12:42:49] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:49] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:42:49] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:42:49] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: float diffuse(vec3 normal) {
27: vec3 n2 = normal * normal * vec3(.6, .25, .8);
28: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
29: }
30:
31:
32: struct Vertex {
33: vec3 pos;
34: vec3 normal;
35: vec2 texCoords;
36: };
37:
38: struct BlockFrag {
39: vec2 texCoords;
40: vec4 color;
41: float diffuse;
42: vec2 light;
43: };
44:
45:
46: struct Instance {
47: vec2 light;
48: vec4 color;
49: mat4 transform;
50: mat3 normalMat;
51: };
52:
53: BlockFrag FLWMain(Vertex v, Instance i) {
54: vec4 worldPos = i.transform * vec4(v.pos, 1.);
55:
56: vec3 norm = i.normalMat * v.normal;
57:
58: FLWFinalizeWorldPos(worldPos);
59: FLWFinalizeNormal(norm);
60:
61: norm = normalize(norm);
62:
63: BlockFrag b;
64: b.diffuse = diffuse(norm);
65: b.texCoords = v.texCoords;
66: b.light = i.light;
67: #if defined(DEBUG_NORMAL)
68: b.color = vec4(norm, 1.);
69: #else
70: b.color = i.color;
71: #endif
72: return b;
73: }
74: attribute vec3 a_v_pos;
75: attribute vec3 a_v_normal;
76: attribute vec2 a_v_texCoords;
77:
78: attribute vec2 a_i_light;
79: attribute vec4 a_i_color;
80: attribute mat4 a_i_transform;
81: attribute mat3 a_i_normalMat;
82:
83:
84: varying vec2 v2f_texCoords;
85: varying vec4 v2f_color;
86: varying float v2f_diffuse;
87: varying vec2 v2f_light;
88:
89:
90: void main() {
91: Vertex v;
92: v.pos = a_v_pos;
93: v.normal = a_v_normal;
94: v.texCoords = a_v_texCoords;
95:
96:
97: Instance i;
98: i.light = a_i_light;
99: i.color = a_i_color;
100: i.transform = a_i_transform;
101: i.normalMat = a_i_normalMat;
102:
103:
104: BlockFrag o = FLWMain(v, i);
105:
106: v2f_texCoords = o.texCoords;
107: v2f_color = o.color;
108: v2f_diffuse = o.diffuse;
109: v2f_light = o.light;
110:
111: }
[12:42:52] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:52] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:52] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:42:52] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: float diffuse(vec3 normal) {
27: vec3 n2 = normal * normal * vec3(.6, .25, .8);
28: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
29: }
30:
31:
32: struct Vertex {
33: vec3 pos;
34: vec3 normal;
35: vec2 texCoords;
36: };
37:
38: struct BlockFrag {
39: vec2 texCoords;
40: vec4 color;
41: float diffuse;
42: vec2 light;
43: };
44:
45:
46: struct Instance {
47: vec2 light;
48: vec4 color;
49: mat4 transform;
50: mat3 normalMat;
51: };
52:
53: BlockFrag FLWMain(Vertex v, Instance i) {
54: vec4 worldPos = i.transform * vec4(v.pos, 1.);
55:
56: vec3 norm = i.normalMat * v.normal;
57:
58: FLWFinalizeWorldPos(worldPos);
59: FLWFinalizeNormal(norm);
60:
61: norm = normalize(norm);
62:
63: BlockFrag b;
64: b.diffuse = diffuse(norm);
65: b.texCoords = v.texCoords;
66: b.light = i.light;
67: #if defined(DEBUG_NORMAL)
68: b.color = vec4(norm, 1.);
69: #else
70: b.color = i.color;
71: #endif
72: return b;
73: }
74: attribute vec3 a_v_pos;
75: attribute vec3 a_v_normal;
76: attribute vec2 a_v_texCoords;
77:
78: attribute vec2 a_i_light;
79: attribute vec4 a_i_color;
80: attribute mat4 a_i_transform;
81: attribute mat3 a_i_normalMat;
82:
83:
84: varying vec2 v2f_texCoords;
85: varying vec4 v2f_color;
86: varying float v2f_diffuse;
87: varying vec2 v2f_light;
88:
89:
90: void main() {
91: Vertex v;
92: v.pos = a_v_pos;
93: v.normal = a_v_normal;
94: v.texCoords = a_v_texCoords;
95:
96:
97: Instance i;
98: i.light = a_i_light;
99: i.color = a_i_color;
100: i.transform = a_i_transform;
101: i.normalMat = a_i_normalMat;
102:
103:
104: BlockFrag o = FLWMain(v, i);
105:
106: v2f_texCoords = o.texCoords;
107: v2f_color = o.color;
108: v2f_diffuse = o.diffuse;
109: v2f_light = o.light;
110:
111: }
[12:42:55] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:55] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:42:55] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:42:55] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2:
3: uniform float uTime;
4: uniform mat4 uViewProjection;
5: uniform vec3 uCameraPos;
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: void FLWFinalizeWorldPos(inout vec4 worldPos) {
12: #if defined(USE_FOG)
13: FragDistance = length(worldPos.xyz - uCameraPos);
14: #endif
15:
16: gl_Position = uViewProjection * worldPos;
17: }
18:
19: void FLWFinalizeNormal(inout vec3 normal) {
20: // noop
21: }
22:
23:
24: float diffuse(vec3 normal) {
25: vec3 n2 = normal * normal * vec3(.6, .25, .8);
26: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
27: }
28:
29:
30: struct Vertex {
31: vec3 pos;
32: vec3 normal;
33: vec2 texCoords;
34: };
35:
36: struct BlockFrag {
37: vec2 texCoords;
38: vec4 color;
39: float diffuse;
40: vec2 light;
41: };
42:
43:
44: struct Instance {
45: vec2 light;
46: vec4 color;
47: mat4 transform;
48: mat3 normalMat;
49: };
50:
51: BlockFrag FLWMain(Vertex v, Instance i) {
52: vec4 worldPos = i.transform * vec4(v.pos, 1.);
53:
54: vec3 norm = i.normalMat * v.normal;
55:
56: FLWFinalizeWorldPos(worldPos);
57: FLWFinalizeNormal(norm);
58:
59: norm = normalize(norm);
60:
61: BlockFrag b;
62: b.diffuse = diffuse(norm);
63: b.texCoords = v.texCoords;
64: b.light = i.light;
65: #if defined(DEBUG_NORMAL)
66: b.color = vec4(norm, 1.);
67: #else
68: b.color = i.color;
69: #endif
70: return b;
71: }
72: attribute vec3 a_v_pos;
73: attribute vec3 a_v_normal;
74: attribute vec2 a_v_texCoords;
75:
76: attribute vec2 a_i_light;
77: attribute vec4 a_i_color;
78: attribute mat4 a_i_transform;
79: attribute mat3 a_i_normalMat;
80:
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: void main() {
89: Vertex v;
90: v.pos = a_v_pos;
91: v.normal = a_v_normal;
92: v.texCoords = a_v_texCoords;
93:
94:
95: Instance i;
96: i.light = a_i_light;
97: i.color = a_i_color;
98: i.transform = a_i_transform;
99: i.normalMat = a_i_normalMat;
100:
101:
102: BlockFrag o = FLWMain(v, i);
103:
104: v2f_texCoords = o.texCoords;
105: v2f_color = o.color;
106: v2f_diffuse = o.diffuse;
107: v2f_light = o.light;
108:
109: }
[12:42:58] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:42:58] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:42:58] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:42:58] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: #define PIOVER2 1.5707963268
28:
29: vec4 quat(vec3 axis, float angle) {
30: float halfAngle = angle * PIOVER2 / 180.0;
31: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
32: return vec4(axis.xyz * cs.y, cs.x);
33: }
34:
35: vec4 quatMult(vec4 q1, vec4 q2) {
36: // disgustingly vectorized quaternion multiplication
37: vec4 a = q1.w * q2.xyzw;
38: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
39: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
40: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
41:
42: return a + b + c + d;
43: }
44:
45: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
46: vec3 i = q.xyz;
47: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
48: }
49:
50: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
51: return rotateVertexByQuat(v, quat(axis, angle));
52: }
53:
54: mat4 rotate(vec3 axis, float angle) {
55: float s = sin(angle);
56: float c = cos(angle);
57: float oc = 1. - c;
58:
59: vec3 sa = axis * s;
60:
61: mat4 mr = mat4(1.);
62: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
63: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
64: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
65:
66: return mr;
67: }
68:
69: mat4 rotation(vec3 rot) {
70: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
71: }
72:
73: mat3 modelToNormal(mat4 mat) {
74: // Discard the edges. This won't be accurate for scaled or skewed matrices,
75: // but we don't have to work with those often.
76: mat3 m;
77: m[0] = mat[0].xyz;
78: m[1] = mat[1].xyz;
79: m[2] = mat[2].xyz;
80: return m;
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Belt {
90: vec2 light;
91: vec4 color;
92: vec3 pos;
93: float speed;
94: float offset;
95: vec4 rotation;
96: vec2 sourceTexture;
97: vec4 scrollTexture;
98: float scrollMult;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115: BlockFrag FLWMain(Vertex v, Belt instance) {
116: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
117:
118: vec4 worldPos = vec4(rotated, 1.);
119:
120: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
126: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
127:
128: BlockFrag b;
129: b.diffuse = diffuse(norm);
130: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
131: b.light = instance.light;
132:
133: #if defined(DEBUG_RAINBOW)
134: b.color = instance.color;
135: #elif defined(DEBUG_NORMAL)
136: b.color = vec4(norm, 1.);
137: #else
138: b.color = vec4(1.);
139: #endif
140:
141: return b;
142: }
143: attribute vec3 a_v_pos;
144: attribute vec3 a_v_normal;
145: attribute vec2 a_v_texCoords;
146:
147: attribute vec2 a_i_light;
148: attribute vec4 a_i_color;
149: attribute vec3 a_i_pos;
150: attribute float a_i_speed;
151: attribute float a_i_offset;
152: attribute vec4 a_i_rotation;
153: attribute vec2 a_i_sourceTexture;
154: attribute vec4 a_i_scrollTexture;
155: attribute float a_i_scrollMult;
156:
157:
158: varying vec2 v2f_texCoords;
159: varying vec4 v2f_color;
160: varying float v2f_diffuse;
161: varying vec2 v2f_light;
162:
163:
164: void main() {
165: Vertex v;
166: v.pos = a_v_pos;
167: v.normal = a_v_normal;
168: v.texCoords = a_v_texCoords;
169:
170:
171: Belt i;
172: i.light = a_i_light;
173: i.color = a_i_color;
174: i.pos = a_i_pos;
175: i.speed = a_i_speed;
176: i.offset = a_i_offset;
177: i.rotation = a_i_rotation;
178: i.sourceTexture = a_i_sourceTexture;
179: i.scrollTexture = a_i_scrollTexture;
180: i.scrollMult = a_i_scrollMult;
181:
182:
183: BlockFrag o = FLWMain(v, i);
184:
185: v2f_texCoords = o.texCoords;
186: v2f_color = o.color;
187: v2f_diffuse = o.diffuse;
188: v2f_light = o.light;
189:
190: }
[12:43:02] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:02] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:02] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:43:02] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: #define PIOVER2 1.5707963268
28:
29: vec4 quat(vec3 axis, float angle) {
30: float halfAngle = angle * PIOVER2 / 180.0;
31: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
32: return vec4(axis.xyz * cs.y, cs.x);
33: }
34:
35: vec4 quatMult(vec4 q1, vec4 q2) {
36: // disgustingly vectorized quaternion multiplication
37: vec4 a = q1.w * q2.xyzw;
38: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
39: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
40: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
41:
42: return a + b + c + d;
43: }
44:
45: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
46: vec3 i = q.xyz;
47: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
48: }
49:
50: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
51: return rotateVertexByQuat(v, quat(axis, angle));
52: }
53:
54: mat4 rotate(vec3 axis, float angle) {
55: float s = sin(angle);
56: float c = cos(angle);
57: float oc = 1. - c;
58:
59: vec3 sa = axis * s;
60:
61: mat4 mr = mat4(1.);
62: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
63: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
64: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
65:
66: return mr;
67: }
68:
69: mat4 rotation(vec3 rot) {
70: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
71: }
72:
73: mat3 modelToNormal(mat4 mat) {
74: // Discard the edges. This won't be accurate for scaled or skewed matrices,
75: // but we don't have to work with those often.
76: mat3 m;
77: m[0] = mat[0].xyz;
78: m[1] = mat[1].xyz;
79: m[2] = mat[2].xyz;
80: return m;
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Belt {
90: vec2 light;
91: vec4 color;
92: vec3 pos;
93: float speed;
94: float offset;
95: vec4 rotation;
96: vec2 sourceTexture;
97: vec4 scrollTexture;
98: float scrollMult;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115: BlockFrag FLWMain(Vertex v, Belt instance) {
116: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
117:
118: vec4 worldPos = vec4(rotated, 1.);
119:
120: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
126: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
127:
128: BlockFrag b;
129: b.diffuse = diffuse(norm);
130: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
131: b.light = instance.light;
132:
133: #if defined(DEBUG_RAINBOW)
134: b.color = instance.color;
135: #elif defined(DEBUG_NORMAL)
136: b.color = vec4(norm, 1.);
137: #else
138: b.color = vec4(1.);
139: #endif
140:
141: return b;
142: }
143: attribute vec3 a_v_pos;
144: attribute vec3 a_v_normal;
145: attribute vec2 a_v_texCoords;
146:
147: attribute vec2 a_i_light;
148: attribute vec4 a_i_color;
149: attribute vec3 a_i_pos;
150: attribute float a_i_speed;
151: attribute float a_i_offset;
152: attribute vec4 a_i_rotation;
153: attribute vec2 a_i_sourceTexture;
154: attribute vec4 a_i_scrollTexture;
155: attribute float a_i_scrollMult;
156:
157:
158: varying vec2 v2f_texCoords;
159: varying vec4 v2f_color;
160: varying float v2f_diffuse;
161: varying vec2 v2f_light;
162:
163:
164: void main() {
165: Vertex v;
166: v.pos = a_v_pos;
167: v.normal = a_v_normal;
168: v.texCoords = a_v_texCoords;
169:
170:
171: Belt i;
172: i.light = a_i_light;
173: i.color = a_i_color;
174: i.pos = a_i_pos;
175: i.speed = a_i_speed;
176: i.offset = a_i_offset;
177: i.rotation = a_i_rotation;
178: i.sourceTexture = a_i_sourceTexture;
179: i.scrollTexture = a_i_scrollTexture;
180: i.scrollMult = a_i_scrollMult;
181:
182:
183: BlockFrag o = FLWMain(v, i);
184:
185: v2f_texCoords = o.texCoords;
186: v2f_color = o.color;
187: v2f_diffuse = o.diffuse;
188: v2f_light = o.light;
189:
190: }
[12:43:04] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:04] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25:
26: uniform vec2 uTextureScale;
27: uniform sampler2D uBlockAtlas;
28: uniform sampler2D uLightMap;
29: uniform sampler2D uCrumbling;
30:
31: vec4 FLWBlockTexture(vec2 texCoords) {
32: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
33: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
34: cr.a = cr.a * diffuseAlpha;
35: return cr;
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return vec4(1.);
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:08] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:43:08] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: #define PIOVER2 1.5707963268
29:
30: vec4 quat(vec3 axis, float angle) {
31: float halfAngle = angle * PIOVER2 / 180.0;
32: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
33: return vec4(axis.xyz * cs.y, cs.x);
34: }
35:
36: vec4 quatMult(vec4 q1, vec4 q2) {
37: // disgustingly vectorized quaternion multiplication
38: vec4 a = q1.w * q2.xyzw;
39: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
40: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
41: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
42:
43: return a + b + c + d;
44: }
45:
46: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
47: vec3 i = q.xyz;
48: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
49: }
50:
51: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
52: return rotateVertexByQuat(v, quat(axis, angle));
53: }
54:
55: mat4 rotate(vec3 axis, float angle) {
56: float s = sin(angle);
57: float c = cos(angle);
58: float oc = 1. - c;
59:
60: vec3 sa = axis * s;
61:
62: mat4 mr = mat4(1.);
63: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
64: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
65: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
66:
67: return mr;
68: }
69:
70: mat4 rotation(vec3 rot) {
71: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
72: }
73:
74: mat3 modelToNormal(mat4 mat) {
75: // Discard the edges. This won't be accurate for scaled or skewed matrices,
76: // but we don't have to work with those often.
77: mat3 m;
78: m[0] = mat[0].xyz;
79: m[1] = mat[1].xyz;
80: m[2] = mat[2].xyz;
81: return m;
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Belt {
91: vec2 light;
92: vec4 color;
93: vec3 pos;
94: float speed;
95: float offset;
96: vec4 rotation;
97: vec2 sourceTexture;
98: vec4 scrollTexture;
99: float scrollMult;
100: };
101:
102:
103: struct Vertex {
104: vec3 pos;
105: vec3 normal;
106: vec2 texCoords;
107: };
108:
109: struct BlockFrag {
110: vec2 texCoords;
111: vec4 color;
112: float diffuse;
113: vec2 light;
114: };
115:
116: BlockFrag FLWMain(Vertex v, Belt instance) {
117: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
118:
119: vec4 worldPos = vec4(rotated, 1.);
120:
121: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
127: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
128:
129: BlockFrag b;
130: b.diffuse = diffuse(norm);
131: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
132: b.light = instance.light;
133:
134: #if defined(DEBUG_RAINBOW)
135: b.color = instance.color;
136: #elif defined(DEBUG_NORMAL)
137: b.color = vec4(norm, 1.);
138: #else
139: b.color = vec4(1.);
140: #endif
141:
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute float a_i_speed;
152: attribute float a_i_offset;
153: attribute vec4 a_i_rotation;
154: attribute vec2 a_i_sourceTexture;
155: attribute vec4 a_i_scrollTexture;
156: attribute float a_i_scrollMult;
157:
158:
159: varying vec2 v2f_texCoords;
160: varying vec4 v2f_color;
161: varying float v2f_diffuse;
162: varying vec2 v2f_light;
163:
164:
165: void main() {
166: Vertex v;
167: v.pos = a_v_pos;
168: v.normal = a_v_normal;
169: v.texCoords = a_v_texCoords;
170:
171:
172: Belt i;
173: i.light = a_i_light;
174: i.color = a_i_color;
175: i.pos = a_i_pos;
176: i.speed = a_i_speed;
177: i.offset = a_i_offset;
178: i.rotation = a_i_rotation;
179: i.sourceTexture = a_i_sourceTexture;
180: i.scrollTexture = a_i_scrollTexture;
181: i.scrollMult = a_i_scrollMult;
182:
183:
184: BlockFrag o = FLWMain(v, i);
185:
186: v2f_texCoords = o.texCoords;
187: v2f_color = o.color;
188: v2f_diffuse = o.diffuse;
189: v2f_light = o.light;
190:
191: }
[12:43:12] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:12] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:43:12] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:43:12] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: #define PIOVER2 1.5707963268
29:
30: vec4 quat(vec3 axis, float angle) {
31: float halfAngle = angle * PIOVER2 / 180.0;
32: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
33: return vec4(axis.xyz * cs.y, cs.x);
34: }
35:
36: vec4 quatMult(vec4 q1, vec4 q2) {
37: // disgustingly vectorized quaternion multiplication
38: vec4 a = q1.w * q2.xyzw;
39: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
40: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
41: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
42:
43: return a + b + c + d;
44: }
45:
46: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
47: vec3 i = q.xyz;
48: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
49: }
50:
51: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
52: return rotateVertexByQuat(v, quat(axis, angle));
53: }
54:
55: mat4 rotate(vec3 axis, float angle) {
56: float s = sin(angle);
57: float c = cos(angle);
58: float oc = 1. - c;
59:
60: vec3 sa = axis * s;
61:
62: mat4 mr = mat4(1.);
63: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
64: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
65: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
66:
67: return mr;
68: }
69:
70: mat4 rotation(vec3 rot) {
71: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
72: }
73:
74: mat3 modelToNormal(mat4 mat) {
75: // Discard the edges. This won't be accurate for scaled or skewed matrices,
76: // but we don't have to work with those often.
77: mat3 m;
78: m[0] = mat[0].xyz;
79: m[1] = mat[1].xyz;
80: m[2] = mat[2].xyz;
81: return m;
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Belt {
91: vec2 light;
92: vec4 color;
93: vec3 pos;
94: float speed;
95: float offset;
96: vec4 rotation;
97: vec2 sourceTexture;
98: vec4 scrollTexture;
99: float scrollMult;
100: };
101:
102:
103: struct Vertex {
104: vec3 pos;
105: vec3 normal;
106: vec2 texCoords;
107: };
108:
109: struct BlockFrag {
110: vec2 texCoords;
111: vec4 color;
112: float diffuse;
113: vec2 light;
114: };
115:
116: BlockFrag FLWMain(Vertex v, Belt instance) {
117: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
118:
119: vec4 worldPos = vec4(rotated, 1.);
120:
121: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
127: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
128:
129: BlockFrag b;
130: b.diffuse = diffuse(norm);
131: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
132: b.light = instance.light;
133:
134: #if defined(DEBUG_RAINBOW)
135: b.color = instance.color;
136: #elif defined(DEBUG_NORMAL)
137: b.color = vec4(norm, 1.);
138: #else
139: b.color = vec4(1.);
140: #endif
141:
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute float a_i_speed;
152: attribute float a_i_offset;
153: attribute vec4 a_i_rotation;
154: attribute vec2 a_i_sourceTexture;
155: attribute vec4 a_i_scrollTexture;
156: attribute float a_i_scrollMult;
157:
158:
159: varying vec2 v2f_texCoords;
160: varying vec4 v2f_color;
161: varying float v2f_diffuse;
162: varying vec2 v2f_light;
163:
164:
165: void main() {
166: Vertex v;
167: v.pos = a_v_pos;
168: v.normal = a_v_normal;
169: v.texCoords = a_v_texCoords;
170:
171:
172: Belt i;
173: i.light = a_i_light;
174: i.color = a_i_color;
175: i.pos = a_i_pos;
176: i.speed = a_i_speed;
177: i.offset = a_i_offset;
178: i.rotation = a_i_rotation;
179: i.sourceTexture = a_i_sourceTexture;
180: i.scrollTexture = a_i_scrollTexture;
181: i.scrollMult = a_i_scrollMult;
182:
183:
184: BlockFrag o = FLWMain(v, i);
185:
186: v2f_texCoords = o.texCoords;
187: v2f_color = o.color;
188: v2f_diffuse = o.diffuse;
189: v2f_light = o.light;
190:
191: }
[12:43:13] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:13] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26:
27: uniform vec2 uTextureScale;
28: uniform sampler2D uBlockAtlas;
29: uniform sampler2D uLightMap;
30: uniform sampler2D uCrumbling;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
34: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
35: cr.a = cr.a * diffuseAlpha;
36: return cr;
37: }
38:
39: void FLWFinalizeColor(vec4 color) {
40: #if defined(USE_FOG)
41: float a = color.a;
42: float fog = clamp(FLWFogFactor(), 0., 1.);
43:
44: color = mix(uFogColor, color, fog);
45: color.a = a;
46: #endif
47:
48: gl_FragColor = color;
49: }
50:
51: vec4 FLWLight(vec2 lightCoords) {
52: return vec4(1.);
53: }
54:
55:
56:
57: struct BlockFrag {
58: vec2 texCoords;
59: vec4 color;
60: float diffuse;
61: vec2 light;
62: };
63:
64: void FLWMain(BlockFrag r) {
65: vec4 tex = FLWBlockTexture(r.texCoords);
66:
67: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
68:
69: // flw_WorldPos = ;
70: // flw_Normal = ;
71: // flw_Albedo = tex.rgb;
72: // flw_Alpha = tex.a;
73: // flw_LightMap = r.light;
74: // flw_Tint = r.color;
75: FLWFinalizeColor(color);
76: }
77:
78: varying vec2 v2f_texCoords;
79: varying vec4 v2f_color;
80: varying float v2f_diffuse;
81: varying vec2 v2f_light;
82:
83:
84: //vec3 flw_WorldPos;
85: //vec3 flw_Normal;
86: //vec3 flw_Albedo;
87: //float flw_Alpha;
88: //vec2 flw_LightMap;
89: //vec4 flw_Tint;
90:
91: void main() {
92: BlockFrag f;
93: f.texCoords = v2f_texCoords;
94: f.color = v2f_color;
95: f.diffuse = v2f_diffuse;
96: f.light = v2f_light;
97:
98:
99: FLWMain(f);
100: }
[12:43:13] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:43:13] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: #define PIOVER2 1.5707963268
27:
28: vec4 quat(vec3 axis, float angle) {
29: float halfAngle = angle * PIOVER2 / 180.0;
30: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
31: return vec4(axis.xyz * cs.y, cs.x);
32: }
33:
34: vec4 quatMult(vec4 q1, vec4 q2) {
35: // disgustingly vectorized quaternion multiplication
36: vec4 a = q1.w * q2.xyzw;
37: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
38: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
39: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
40:
41: return a + b + c + d;
42: }
43:
44: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
45: vec3 i = q.xyz;
46: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
47: }
48:
49: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
50: return rotateVertexByQuat(v, quat(axis, angle));
51: }
52:
53: mat4 rotate(vec3 axis, float angle) {
54: float s = sin(angle);
55: float c = cos(angle);
56: float oc = 1. - c;
57:
58: vec3 sa = axis * s;
59:
60: mat4 mr = mat4(1.);
61: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
62: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
63: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
64:
65: return mr;
66: }
67:
68: mat4 rotation(vec3 rot) {
69: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
70: }
71:
72: mat3 modelToNormal(mat4 mat) {
73: // Discard the edges. This won't be accurate for scaled or skewed matrices,
74: // but we don't have to work with those often.
75: mat3 m;
76: m[0] = mat[0].xyz;
77: m[1] = mat[1].xyz;
78: m[2] = mat[2].xyz;
79: return m;
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Belt {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: float speed;
93: float offset;
94: vec4 rotation;
95: vec2 sourceTexture;
96: vec4 scrollTexture;
97: float scrollMult;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Belt instance) {
115: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
116:
117: vec4 worldPos = vec4(rotated, 1.);
118:
119: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
120:
121: FLWFinalizeWorldPos(worldPos);
122: FLWFinalizeNormal(norm);
123:
124: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
125: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
130: b.light = instance.light;
131:
132: #if defined(DEBUG_RAINBOW)
133: b.color = instance.color;
134: #elif defined(DEBUG_NORMAL)
135: b.color = vec4(norm, 1.);
136: #else
137: b.color = vec4(1.);
138: #endif
139:
140: return b;
141: }
142: attribute vec3 a_v_pos;
143: attribute vec3 a_v_normal;
144: attribute vec2 a_v_texCoords;
145:
146: attribute vec2 a_i_light;
147: attribute vec4 a_i_color;
148: attribute vec3 a_i_pos;
149: attribute float a_i_speed;
150: attribute float a_i_offset;
151: attribute vec4 a_i_rotation;
152: attribute vec2 a_i_sourceTexture;
153: attribute vec4 a_i_scrollTexture;
154: attribute float a_i_scrollMult;
155:
156:
157: varying vec2 v2f_texCoords;
158: varying vec4 v2f_color;
159: varying float v2f_diffuse;
160: varying vec2 v2f_light;
161:
162:
163: void main() {
164: Vertex v;
165: v.pos = a_v_pos;
166: v.normal = a_v_normal;
167: v.texCoords = a_v_texCoords;
168:
169:
170: Belt i;
171: i.light = a_i_light;
172: i.color = a_i_color;
173: i.pos = a_i_pos;
174: i.speed = a_i_speed;
175: i.offset = a_i_offset;
176: i.rotation = a_i_rotation;
177: i.sourceTexture = a_i_sourceTexture;
178: i.scrollTexture = a_i_scrollTexture;
179: i.scrollMult = a_i_scrollMult;
180:
181:
182: BlockFrag o = FLWMain(v, i);
183:
184: v2f_texCoords = o.texCoords;
185: v2f_color = o.color;
186: v2f_diffuse = o.diffuse;
187: v2f_light = o.light;
188:
189: }
[12:43:14] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:14] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24:
25: uniform vec2 uTextureScale;
26: uniform sampler2D uBlockAtlas;
27: uniform sampler2D uLightMap;
28: uniform sampler2D uCrumbling;
29:
30: vec4 FLWBlockTexture(vec2 texCoords) {
31: vec4 cr = texture2D(uCrumbling, texCoords * uTextureScale);
32: float diffuseAlpha = texture2D(uBlockAtlas, texCoords).a;
33: cr.a = cr.a * diffuseAlpha;
34: return cr;
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return vec4(1.);
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:43:18] [main/INFO]: Loading context 'flywheel:context/world'
[12:43:18] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:43:18] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: float diffuse(vec3 normal) {
57: vec3 n2 = normal * normal * vec3(.6, .25, .8);
58: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
59: }
60:
61:
62: struct Rotating {
63: vec2 light;
64: vec4 color;
65: vec3 pos;
66: float speed;
67: float offset;
68: vec3 axis;
69: };
70:
71:
72: struct Vertex {
73: vec3 pos;
74: vec3 normal;
75: vec2 texCoords;
76: };
77:
78: struct BlockFrag {
79: vec2 texCoords;
80: vec4 color;
81: float diffuse;
82: vec2 light;
83: };
84:
85: mat4 kineticRotation(float offset, float speed, vec3 axis) {
86: float degrees = offset + uTime * speed * 3./10.;
87: float angle = fract(degrees / 360.) * PI * 2.;
88:
89: return rotate(axis, angle);
90: }
91:
92: BlockFrag FLWMain(Vertex v, Rotating instance) {
93: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
94:
95: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
96: worldPos += vec4(instance.pos + .5, 0.);
97:
98: vec3 norm = modelToNormal(spin) * v.normal;
99:
100: FLWFinalizeWorldPos(worldPos);
101: FLWFinalizeNormal(norm);
102:
103: BlockFrag b;
104: b.diffuse = diffuse(norm);
105: b.texCoords = v.texCoords;
106: b.light = instance.light;
107:
108: #if defined(DEBUG_RAINBOW)
109: b.color = instance.color;
110: #elif defined(DEBUG_NORMAL)
111: b.color = vec4(norm, 1.);
112: #else
113: b.color = vec4(1.);
114: #endif
115:
116: return b;
117: }
118: attribute vec3 a_v_pos;
119: attribute vec3 a_v_normal;
120: attribute vec2 a_v_texCoords;
121:
122: attribute vec2 a_i_light;
123: attribute vec4 a_i_color;
124: attribute vec3 a_i_pos;
125: attribute float a_i_speed;
126: attribute float a_i_offset;
127: attribute vec3 a_i_axis;
128:
129:
130: varying vec2 v2f_texCoords;
131: varying vec4 v2f_color;
132: varying float v2f_diffuse;
133: varying vec2 v2f_light;
134:
135:
136: void main() {
137: Vertex v;
138: v.pos = a_v_pos;
139: v.normal = a_v_normal;
140: v.texCoords = a_v_texCoords;
141:
142:
143: Rotating i;
144: i.light = a_i_light;
145: i.color = a_i_color;
146: i.pos = a_i_pos;
147: i.speed = a_i_speed;
148: i.offset = a_i_offset;
149: i.axis = a_i_axis;
150:
151:
152: BlockFrag o = FLWMain(v, i);
153:
154: v2f_texCoords = o.texCoords;
155: v2f_color = o.color;
156: v2f_diffuse = o.diffuse;
157: v2f_light = o.light;
158:
159: }
[12:43:22] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:22] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:43:22] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:43:22] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: float diffuse(vec3 normal) {
57: vec3 n2 = normal * normal * vec3(.6, .25, .8);
58: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
59: }
60:
61:
62: struct Rotating {
63: vec2 light;
64: vec4 color;
65: vec3 pos;
66: float speed;
67: float offset;
68: vec3 axis;
69: };
70:
71:
72: struct Vertex {
73: vec3 pos;
74: vec3 normal;
75: vec2 texCoords;
76: };
77:
78: struct BlockFrag {
79: vec2 texCoords;
80: vec4 color;
81: float diffuse;
82: vec2 light;
83: };
84:
85: mat4 kineticRotation(float offset, float speed, vec3 axis) {
86: float degrees = offset + uTime * speed * 3./10.;
87: float angle = fract(degrees / 360.) * PI * 2.;
88:
89: return rotate(axis, angle);
90: }
91:
92: BlockFrag FLWMain(Vertex v, Rotating instance) {
93: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
94:
95: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
96: worldPos += vec4(instance.pos + .5, 0.);
97:
98: vec3 norm = modelToNormal(spin) * v.normal;
99:
100: FLWFinalizeWorldPos(worldPos);
101: FLWFinalizeNormal(norm);
102:
103: BlockFrag b;
104: b.diffuse = diffuse(norm);
105: b.texCoords = v.texCoords;
106: b.light = instance.light;
107:
108: #if defined(DEBUG_RAINBOW)
109: b.color = instance.color;
110: #elif defined(DEBUG_NORMAL)
111: b.color = vec4(norm, 1.);
112: #else
113: b.color = vec4(1.);
114: #endif
115:
116: return b;
117: }
118: attribute vec3 a_v_pos;
119: attribute vec3 a_v_normal;
120: attribute vec2 a_v_texCoords;
121:
122: attribute vec2 a_i_light;
123: attribute vec4 a_i_color;
124: attribute vec3 a_i_pos;
125: attribute float a_i_speed;
126: attribute float a_i_offset;
127: attribute vec3 a_i_axis;
128:
129:
130: varying vec2 v2f_texCoords;
131: varying vec4 v2f_color;
132: varying float v2f_diffuse;
133: varying vec2 v2f_light;
134:
135:
136: void main() {
137: Vertex v;
138: v.pos = a_v_pos;
139: v.normal = a_v_normal;
140: v.texCoords = a_v_texCoords;
141:
142:
143: Rotating i;
144: i.light = a_i_light;
145: i.color = a_i_color;
146: i.pos = a_i_pos;
147: i.speed = a_i_speed;
148: i.offset = a_i_offset;
149: i.axis = a_i_axis;
150:
151:
152: BlockFrag o = FLWMain(v, i);
153:
154: v2f_texCoords = o.texCoords;
155: v2f_color = o.color;
156: v2f_diffuse = o.diffuse;
157: v2f_light = o.light;
158:
159: }
[12:43:25] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:25] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:43:25] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:43:25] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: float diffuse(vec3 normal) {
58: vec3 n2 = normal * normal * vec3(.6, .25, .8);
59: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
60: }
61:
62:
63: struct Rotating {
64: vec2 light;
65: vec4 color;
66: vec3 pos;
67: float speed;
68: float offset;
69: vec3 axis;
70: };
71:
72:
73: struct Vertex {
74: vec3 pos;
75: vec3 normal;
76: vec2 texCoords;
77: };
78:
79: struct BlockFrag {
80: vec2 texCoords;
81: vec4 color;
82: float diffuse;
83: vec2 light;
84: };
85:
86: mat4 kineticRotation(float offset, float speed, vec3 axis) {
87: float degrees = offset + uTime * speed * 3./10.;
88: float angle = fract(degrees / 360.) * PI * 2.;
89:
90: return rotate(axis, angle);
91: }
92:
93: BlockFrag FLWMain(Vertex v, Rotating instance) {
94: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
95:
96: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
97: worldPos += vec4(instance.pos + .5, 0.);
98:
99: vec3 norm = modelToNormal(spin) * v.normal;
100:
101: FLWFinalizeWorldPos(worldPos);
102: FLWFinalizeNormal(norm);
103:
104: BlockFrag b;
105: b.diffuse = diffuse(norm);
106: b.texCoords = v.texCoords;
107: b.light = instance.light;
108:
109: #if defined(DEBUG_RAINBOW)
110: b.color = instance.color;
111: #elif defined(DEBUG_NORMAL)
112: b.color = vec4(norm, 1.);
113: #else
114: b.color = vec4(1.);
115: #endif
116:
117: return b;
118: }
119: attribute vec3 a_v_pos;
120: attribute vec3 a_v_normal;
121: attribute vec2 a_v_texCoords;
122:
123: attribute vec2 a_i_light;
124: attribute vec4 a_i_color;
125: attribute vec3 a_i_pos;
126: attribute float a_i_speed;
127: attribute float a_i_offset;
128: attribute vec3 a_i_axis;
129:
130:
131: varying vec2 v2f_texCoords;
132: varying vec4 v2f_color;
133: varying float v2f_diffuse;
134: varying vec2 v2f_light;
135:
136:
137: void main() {
138: Vertex v;
139: v.pos = a_v_pos;
140: v.normal = a_v_normal;
141: v.texCoords = a_v_texCoords;
142:
143:
144: Rotating i;
145: i.light = a_i_light;
146: i.color = a_i_color;
147: i.pos = a_i_pos;
148: i.speed = a_i_speed;
149: i.offset = a_i_offset;
150: i.axis = a_i_axis;
151:
152:
153: BlockFrag o = FLWMain(v, i);
154:
155: v2f_texCoords = o.texCoords;
156: v2f_color = o.color;
157: v2f_diffuse = o.diffuse;
158: v2f_light = o.light;
159:
160: }
[12:43:28] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:28] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:28] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:43:28] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: float diffuse(vec3 normal) {
58: vec3 n2 = normal * normal * vec3(.6, .25, .8);
59: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
60: }
61:
62:
63: struct Rotating {
64: vec2 light;
65: vec4 color;
66: vec3 pos;
67: float speed;
68: float offset;
69: vec3 axis;
70: };
71:
72:
73: struct Vertex {
74: vec3 pos;
75: vec3 normal;
76: vec2 texCoords;
77: };
78:
79: struct BlockFrag {
80: vec2 texCoords;
81: vec4 color;
82: float diffuse;
83: vec2 light;
84: };
85:
86: mat4 kineticRotation(float offset, float speed, vec3 axis) {
87: float degrees = offset + uTime * speed * 3./10.;
88: float angle = fract(degrees / 360.) * PI * 2.;
89:
90: return rotate(axis, angle);
91: }
92:
93: BlockFrag FLWMain(Vertex v, Rotating instance) {
94: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
95:
96: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
97: worldPos += vec4(instance.pos + .5, 0.);
98:
99: vec3 norm = modelToNormal(spin) * v.normal;
100:
101: FLWFinalizeWorldPos(worldPos);
102: FLWFinalizeNormal(norm);
103:
104: BlockFrag b;
105: b.diffuse = diffuse(norm);
106: b.texCoords = v.texCoords;
107: b.light = instance.light;
108:
109: #if defined(DEBUG_RAINBOW)
110: b.color = instance.color;
111: #elif defined(DEBUG_NORMAL)
112: b.color = vec4(norm, 1.);
113: #else
114: b.color = vec4(1.);
115: #endif
116:
117: return b;
118: }
119: attribute vec3 a_v_pos;
120: attribute vec3 a_v_normal;
121: attribute vec2 a_v_texCoords;
122:
123: attribute vec2 a_i_light;
124: attribute vec4 a_i_color;
125: attribute vec3 a_i_pos;
126: attribute float a_i_speed;
127: attribute float a_i_offset;
128: attribute vec3 a_i_axis;
129:
130:
131: varying vec2 v2f_texCoords;
132: varying vec4 v2f_color;
133: varying float v2f_diffuse;
134: varying vec2 v2f_light;
135:
136:
137: void main() {
138: Vertex v;
139: v.pos = a_v_pos;
140: v.normal = a_v_normal;
141: v.texCoords = a_v_texCoords;
142:
143:
144: Rotating i;
145: i.light = a_i_light;
146: i.color = a_i_color;
147: i.pos = a_i_pos;
148: i.speed = a_i_speed;
149: i.offset = a_i_offset;
150: i.axis = a_i_axis;
151:
152:
153: BlockFrag o = FLWMain(v, i);
154:
155: v2f_texCoords = o.texCoords;
156: v2f_color = o.color;
157: v2f_diffuse = o.diffuse;
158: v2f_light = o.light;
159:
160: }
[12:43:31] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:31] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:31] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:43:31] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: float diffuse(vec3 normal) {
56: vec3 n2 = normal * normal * vec3(.6, .25, .8);
57: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
58: }
59:
60:
61: struct Rotating {
62: vec2 light;
63: vec4 color;
64: vec3 pos;
65: float speed;
66: float offset;
67: vec3 axis;
68: };
69:
70:
71: struct Vertex {
72: vec3 pos;
73: vec3 normal;
74: vec2 texCoords;
75: };
76:
77: struct BlockFrag {
78: vec2 texCoords;
79: vec4 color;
80: float diffuse;
81: vec2 light;
82: };
83:
84: mat4 kineticRotation(float offset, float speed, vec3 axis) {
85: float degrees = offset + uTime * speed * 3./10.;
86: float angle = fract(degrees / 360.) * PI * 2.;
87:
88: return rotate(axis, angle);
89: }
90:
91: BlockFrag FLWMain(Vertex v, Rotating instance) {
92: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
93:
94: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
95: worldPos += vec4(instance.pos + .5, 0.);
96:
97: vec3 norm = modelToNormal(spin) * v.normal;
98:
99: FLWFinalizeWorldPos(worldPos);
100: FLWFinalizeNormal(norm);
101:
102: BlockFrag b;
103: b.diffuse = diffuse(norm);
104: b.texCoords = v.texCoords;
105: b.light = instance.light;
106:
107: #if defined(DEBUG_RAINBOW)
108: b.color = instance.color;
109: #elif defined(DEBUG_NORMAL)
110: b.color = vec4(norm, 1.);
111: #else
112: b.color = vec4(1.);
113: #endif
114:
115: return b;
116: }
117: attribute vec3 a_v_pos;
118: attribute vec3 a_v_normal;
119: attribute vec2 a_v_texCoords;
120:
121: attribute vec2 a_i_light;
122: attribute vec4 a_i_color;
123: attribute vec3 a_i_pos;
124: attribute float a_i_speed;
125: attribute float a_i_offset;
126: attribute vec3 a_i_axis;
127:
128:
129: varying vec2 v2f_texCoords;
130: varying vec4 v2f_color;
131: varying float v2f_diffuse;
132: varying vec2 v2f_light;
133:
134:
135: void main() {
136: Vertex v;
137: v.pos = a_v_pos;
138: v.normal = a_v_normal;
139: v.texCoords = a_v_texCoords;
140:
141:
142: Rotating i;
143: i.light = a_i_light;
144: i.color = a_i_color;
145: i.pos = a_i_pos;
146: i.speed = a_i_speed;
147: i.offset = a_i_offset;
148: i.axis = a_i_axis;
149:
150:
151: BlockFrag o = FLWMain(v, i);
152:
153: v2f_texCoords = o.texCoords;
154: v2f_color = o.color;
155: v2f_diffuse = o.diffuse;
156: v2f_light = o.light;
157:
158: }
[12:43:35] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:35] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:43:35] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:43:35] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: #define PIOVER2 1.5707963268
57:
58: vec4 quat(vec3 axis, float angle) {
59: float halfAngle = angle * PIOVER2 / 180.0;
60: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
61: return vec4(axis.xyz * cs.y, cs.x);
62: }
63:
64: vec4 quatMult(vec4 q1, vec4 q2) {
65: // disgustingly vectorized quaternion multiplication
66: vec4 a = q1.w * q2.xyzw;
67: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
68: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
69: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
70:
71: return a + b + c + d;
72: }
73:
74: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
75: vec3 i = q.xyz;
76: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
77: }
78:
79: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
80: return rotateVertexByQuat(v, quat(axis, angle));
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Actor {
90: vec3 pos;
91: vec2 light;
92: float offset;
93: vec3 axis;
94: vec4 rotation;
95: vec3 rotationCenter;
96: float speed;
97: };
98:
99:
100: struct Vertex {
101: vec3 pos;
102: vec3 normal;
103: vec2 texCoords;
104: };
105:
106: struct BlockFrag {
107: vec2 texCoords;
108: vec4 color;
109: float diffuse;
110: vec2 light;
111: };
112:
113: BlockFrag FLWMain(Vertex v, Actor instance) {
114: float degrees = instance.offset + uTime * instance.speed / 20.;
115: //float angle = fract(degrees / 360.) * PI * 2.;
116:
117: vec4 kineticRot = quat(instance.axis, degrees);
118: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
119:
120: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
121: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: BlockFrag b;
127: b.diffuse = diffuse(norm);
128: b.texCoords = v.texCoords;
129: b.light = instance.light;
130:
131: #if defined(DEBUG_NORMAL)
132: b.color = vec4(norm, 1.);
133: #else
134: b.color = vec4(1.);
135: #endif
136:
137: return b;
138: }
139: attribute vec3 a_v_pos;
140: attribute vec3 a_v_normal;
141: attribute vec2 a_v_texCoords;
142:
143: attribute vec3 a_i_pos;
144: attribute vec2 a_i_light;
145: attribute float a_i_offset;
146: attribute vec3 a_i_axis;
147: attribute vec4 a_i_rotation;
148: attribute vec3 a_i_rotationCenter;
149: attribute float a_i_speed;
150:
151:
152: varying vec2 v2f_texCoords;
153: varying vec4 v2f_color;
154: varying float v2f_diffuse;
155: varying vec2 v2f_light;
156:
157:
158: void main() {
159: Vertex v;
160: v.pos = a_v_pos;
161: v.normal = a_v_normal;
162: v.texCoords = a_v_texCoords;
163:
164:
165: Actor i;
166: i.pos = a_i_pos;
167: i.light = a_i_light;
168: i.offset = a_i_offset;
169: i.axis = a_i_axis;
170: i.rotation = a_i_rotation;
171: i.rotationCenter = a_i_rotationCenter;
172: i.speed = a_i_speed;
173:
174:
175: BlockFrag o = FLWMain(v, i);
176:
177: v2f_texCoords = o.texCoords;
178: v2f_color = o.color;
179: v2f_diffuse = o.diffuse;
180: v2f_light = o.light;
181:
182: }
[12:43:38] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:38] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:43:39] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:43:39] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Actor {
91: vec3 pos;
92: vec2 light;
93: float offset;
94: vec3 axis;
95: vec4 rotation;
96: vec3 rotationCenter;
97: float speed;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Actor instance) {
115: float degrees = instance.offset + uTime * instance.speed / 20.;
116: //float angle = fract(degrees / 360.) * PI * 2.;
117:
118: vec4 kineticRot = quat(instance.axis, degrees);
119: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
120:
121: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
122: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
123:
124: FLWFinalizeWorldPos(worldPos);
125: FLWFinalizeNormal(norm);
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords;
130: b.light = instance.light;
131:
132: #if defined(DEBUG_NORMAL)
133: b.color = vec4(norm, 1.);
134: #else
135: b.color = vec4(1.);
136: #endif
137:
138: return b;
139: }
140: attribute vec3 a_v_pos;
141: attribute vec3 a_v_normal;
142: attribute vec2 a_v_texCoords;
143:
144: attribute vec3 a_i_pos;
145: attribute vec2 a_i_light;
146: attribute float a_i_offset;
147: attribute vec3 a_i_axis;
148: attribute vec4 a_i_rotation;
149: attribute vec3 a_i_rotationCenter;
150: attribute float a_i_speed;
151:
152:
153: varying vec2 v2f_texCoords;
154: varying vec4 v2f_color;
155: varying float v2f_diffuse;
156: varying vec2 v2f_light;
157:
158:
159: void main() {
160: Vertex v;
161: v.pos = a_v_pos;
162: v.normal = a_v_normal;
163: v.texCoords = a_v_texCoords;
164:
165:
166: Actor i;
167: i.pos = a_i_pos;
168: i.light = a_i_light;
169: i.offset = a_i_offset;
170: i.axis = a_i_axis;
171: i.rotation = a_i_rotation;
172: i.rotationCenter = a_i_rotationCenter;
173: i.speed = a_i_speed;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:43:40] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:40] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:40] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:43:43] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Actor {
91: vec3 pos;
92: vec2 light;
93: float offset;
94: vec3 axis;
95: vec4 rotation;
96: vec3 rotationCenter;
97: float speed;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Actor instance) {
115: float degrees = instance.offset + uTime * instance.speed / 20.;
116: //float angle = fract(degrees / 360.) * PI * 2.;
117:
118: vec4 kineticRot = quat(instance.axis, degrees);
119: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
120:
121: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
122: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
123:
124: FLWFinalizeWorldPos(worldPos);
125: FLWFinalizeNormal(norm);
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords;
130: b.light = instance.light;
131:
132: #if defined(DEBUG_NORMAL)
133: b.color = vec4(norm, 1.);
134: #else
135: b.color = vec4(1.);
136: #endif
137:
138: return b;
139: }
140: attribute vec3 a_v_pos;
141: attribute vec3 a_v_normal;
142: attribute vec2 a_v_texCoords;
143:
144: attribute vec3 a_i_pos;
145: attribute vec2 a_i_light;
146: attribute float a_i_offset;
147: attribute vec3 a_i_axis;
148: attribute vec4 a_i_rotation;
149: attribute vec3 a_i_rotationCenter;
150: attribute float a_i_speed;
151:
152:
153: varying vec2 v2f_texCoords;
154: varying vec4 v2f_color;
155: varying float v2f_diffuse;
156: varying vec2 v2f_light;
157:
158:
159: void main() {
160: Vertex v;
161: v.pos = a_v_pos;
162: v.normal = a_v_normal;
163: v.texCoords = a_v_texCoords;
164:
165:
166: Actor i;
167: i.pos = a_i_pos;
168: i.light = a_i_light;
169: i.offset = a_i_offset;
170: i.axis = a_i_axis;
171: i.rotation = a_i_rotation;
172: i.rotationCenter = a_i_rotationCenter;
173: i.speed = a_i_speed;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:43:46] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:46] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:46] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:43:46] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Actor {
89: vec3 pos;
90: vec2 light;
91: float offset;
92: vec3 axis;
93: vec4 rotation;
94: vec3 rotationCenter;
95: float speed;
96: };
97:
98:
99: struct Vertex {
100: vec3 pos;
101: vec3 normal;
102: vec2 texCoords;
103: };
104:
105: struct BlockFrag {
106: vec2 texCoords;
107: vec4 color;
108: float diffuse;
109: vec2 light;
110: };
111:
112: BlockFrag FLWMain(Vertex v, Actor instance) {
113: float degrees = instance.offset + uTime * instance.speed / 20.;
114: //float angle = fract(degrees / 360.) * PI * 2.;
115:
116: vec4 kineticRot = quat(instance.axis, degrees);
117: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
118:
119: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
120: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: BlockFrag b;
126: b.diffuse = diffuse(norm);
127: b.texCoords = v.texCoords;
128: b.light = instance.light;
129:
130: #if defined(DEBUG_NORMAL)
131: b.color = vec4(norm, 1.);
132: #else
133: b.color = vec4(1.);
134: #endif
135:
136: return b;
137: }
138: attribute vec3 a_v_pos;
139: attribute vec3 a_v_normal;
140: attribute vec2 a_v_texCoords;
141:
142: attribute vec3 a_i_pos;
143: attribute vec2 a_i_light;
144: attribute float a_i_offset;
145: attribute vec3 a_i_axis;
146: attribute vec4 a_i_rotation;
147: attribute vec3 a_i_rotationCenter;
148: attribute float a_i_speed;
149:
150:
151: varying vec2 v2f_texCoords;
152: varying vec4 v2f_color;
153: varying float v2f_diffuse;
154: varying vec2 v2f_light;
155:
156:
157: void main() {
158: Vertex v;
159: v.pos = a_v_pos;
160: v.normal = a_v_normal;
161: v.texCoords = a_v_texCoords;
162:
163:
164: Actor i;
165: i.pos = a_i_pos;
166: i.light = a_i_light;
167: i.offset = a_i_offset;
168: i.axis = a_i_axis;
169: i.rotation = a_i_rotation;
170: i.rotationCenter = a_i_rotationCenter;
171: i.speed = a_i_speed;
172:
173:
174: BlockFrag o = FLWMain(v, i);
175:
176: v2f_texCoords = o.texCoords;
177: v2f_color = o.color;
178: v2f_diffuse = o.diffuse;
179: v2f_light = o.light;
180:
181: }
[12:43:48] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:48] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:43:48] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:43:48] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: mat4 rotate(vec3 axis, float angle) {
28: float s = sin(angle);
29: float c = cos(angle);
30: float oc = 1. - c;
31:
32: vec3 sa = axis * s;
33:
34: mat4 mr = mat4(1.);
35: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
36: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
37: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
38:
39: return mr;
40: }
41:
42: mat4 rotation(vec3 rot) {
43: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
44: }
45:
46: mat3 modelToNormal(mat4 mat) {
47: // Discard the edges. This won't be accurate for scaled or skewed matrices,
48: // but we don't have to work with those often.
49: mat3 m;
50: m[0] = mat[0].xyz;
51: m[1] = mat[1].xyz;
52: m[2] = mat[2].xyz;
53: return m;
54: }
55:
56: #define PIOVER2 1.5707963268
57:
58: vec4 quat(vec3 axis, float angle) {
59: float halfAngle = angle * PIOVER2 / 180.0;
60: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
61: return vec4(axis.xyz * cs.y, cs.x);
62: }
63:
64: vec4 quatMult(vec4 q1, vec4 q2) {
65: // disgustingly vectorized quaternion multiplication
66: vec4 a = q1.w * q2.xyzw;
67: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
68: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
69: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
70:
71: return a + b + c + d;
72: }
73:
74: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
75: vec3 i = q.xyz;
76: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
77: }
78:
79: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
80: return rotateVertexByQuat(v, quat(axis, angle));
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Flap {
90: vec3 instancePos;
91: vec2 light;
92: vec3 segmentOffset;
93: vec3 pivot;
94: float horizontalAngle;
95: float intensity;
96: float flapScale;
97: float flapness;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114:
115: float toRad(float degrees) {
116: return fract(degrees / 360.) * PI * 2.;
117: }
118:
119: float getFlapAngle(float flapness, float intensity, float scale) {
120: float absFlap = abs(flapness);
121:
122: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
123:
124: float halfAngle = angle * 0.5;
125:
126: float which = step(0., flapness);// 0 if negative, 1 if positive
127: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
128:
129: return degrees;
130: }
131:
132: BlockFrag FLWMain(Vertex v, Flap flap) {
133: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
134:
135: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
136: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
137:
138: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
139: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
140:
141: vec4 worldPos = vec4(rotated, 1.);
142: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
143:
144: FLWFinalizeWorldPos(worldPos);
145: FLWFinalizeNormal(norm);
146:
147: BlockFrag b;
148: b.diffuse = diffuse(norm);
149: b.texCoords = v.texCoords;
150: b.light = flap.light;
151: #if defined(DEBUG_NORMAL)
152: b.color = vec4(norm, 1.);
153: #else
154: b.color = vec4(1.);
155: #endif
156: return b;
157: }
158: attribute vec3 a_v_pos;
159: attribute vec3 a_v_normal;
160: attribute vec2 a_v_texCoords;
161:
162: attribute vec3 a_i_instancePos;
163: attribute vec2 a_i_light;
164: attribute vec3 a_i_segmentOffset;
165: attribute vec3 a_i_pivot;
166: attribute float a_i_horizontalAngle;
167: attribute float a_i_intensity;
168: attribute float a_i_flapScale;
169: attribute float a_i_flapness;
170:
171:
172: varying vec2 v2f_texCoords;
173: varying vec4 v2f_color;
174: varying float v2f_diffuse;
175: varying vec2 v2f_light;
176:
177:
178: void main() {
179: Vertex v;
180: v.pos = a_v_pos;
181: v.normal = a_v_normal;
182: v.texCoords = a_v_texCoords;
183:
184:
185: Flap i;
186: i.instancePos = a_i_instancePos;
187: i.light = a_i_light;
188: i.segmentOffset = a_i_segmentOffset;
189: i.pivot = a_i_pivot;
190: i.horizontalAngle = a_i_horizontalAngle;
191: i.intensity = a_i_intensity;
192: i.flapScale = a_i_flapScale;
193: i.flapness = a_i_flapness;
194:
195:
196: BlockFrag o = FLWMain(v, i);
197:
198: v2f_texCoords = o.texCoords;
199: v2f_color = o.color;
200: v2f_diffuse = o.diffuse;
201: v2f_light = o.light;
202:
203: }
[12:43:49] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:49] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:43:52] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:43:52] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Flap {
91: vec3 instancePos;
92: vec2 light;
93: vec3 segmentOffset;
94: vec3 pivot;
95: float horizontalAngle;
96: float intensity;
97: float flapScale;
98: float flapness;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115:
116: float toRad(float degrees) {
117: return fract(degrees / 360.) * PI * 2.;
118: }
119:
120: float getFlapAngle(float flapness, float intensity, float scale) {
121: float absFlap = abs(flapness);
122:
123: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
124:
125: float halfAngle = angle * 0.5;
126:
127: float which = step(0., flapness);// 0 if negative, 1 if positive
128: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
129:
130: return degrees;
131: }
132:
133: BlockFrag FLWMain(Vertex v, Flap flap) {
134: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
135:
136: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
137: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
138:
139: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
140: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
141:
142: vec4 worldPos = vec4(rotated, 1.);
143: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
144:
145: FLWFinalizeWorldPos(worldPos);
146: FLWFinalizeNormal(norm);
147:
148: BlockFrag b;
149: b.diffuse = diffuse(norm);
150: b.texCoords = v.texCoords;
151: b.light = flap.light;
152: #if defined(DEBUG_NORMAL)
153: b.color = vec4(norm, 1.);
154: #else
155: b.color = vec4(1.);
156: #endif
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec3 a_i_instancePos;
164: attribute vec2 a_i_light;
165: attribute vec3 a_i_segmentOffset;
166: attribute vec3 a_i_pivot;
167: attribute float a_i_horizontalAngle;
168: attribute float a_i_intensity;
169: attribute float a_i_flapScale;
170: attribute float a_i_flapness;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Flap i;
187: i.instancePos = a_i_instancePos;
188: i.light = a_i_light;
189: i.segmentOffset = a_i_segmentOffset;
190: i.pivot = a_i_pivot;
191: i.horizontalAngle = a_i_horizontalAngle;
192: i.intensity = a_i_intensity;
193: i.flapScale = a_i_flapScale;
194: i.flapness = a_i_flapness;
195:
196:
197: BlockFrag o = FLWMain(v, i);
198:
199: v2f_texCoords = o.texCoords;
200: v2f_color = o.color;
201: v2f_diffuse = o.diffuse;
202: v2f_light = o.light;
203:
204: }
[12:43:57] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:43:57] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:43:57] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:43:57] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: mat4 rotate(vec3 axis, float angle) {
29: float s = sin(angle);
30: float c = cos(angle);
31: float oc = 1. - c;
32:
33: vec3 sa = axis * s;
34:
35: mat4 mr = mat4(1.);
36: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
37: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
38: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
39:
40: return mr;
41: }
42:
43: mat4 rotation(vec3 rot) {
44: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
45: }
46:
47: mat3 modelToNormal(mat4 mat) {
48: // Discard the edges. This won't be accurate for scaled or skewed matrices,
49: // but we don't have to work with those often.
50: mat3 m;
51: m[0] = mat[0].xyz;
52: m[1] = mat[1].xyz;
53: m[2] = mat[2].xyz;
54: return m;
55: }
56:
57: #define PIOVER2 1.5707963268
58:
59: vec4 quat(vec3 axis, float angle) {
60: float halfAngle = angle * PIOVER2 / 180.0;
61: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
62: return vec4(axis.xyz * cs.y, cs.x);
63: }
64:
65: vec4 quatMult(vec4 q1, vec4 q2) {
66: // disgustingly vectorized quaternion multiplication
67: vec4 a = q1.w * q2.xyzw;
68: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
69: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
70: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
71:
72: return a + b + c + d;
73: }
74:
75: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
76: vec3 i = q.xyz;
77: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
78: }
79:
80: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
81: return rotateVertexByQuat(v, quat(axis, angle));
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Flap {
91: vec3 instancePos;
92: vec2 light;
93: vec3 segmentOffset;
94: vec3 pivot;
95: float horizontalAngle;
96: float intensity;
97: float flapScale;
98: float flapness;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115:
116: float toRad(float degrees) {
117: return fract(degrees / 360.) * PI * 2.;
118: }
119:
120: float getFlapAngle(float flapness, float intensity, float scale) {
121: float absFlap = abs(flapness);
122:
123: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
124:
125: float halfAngle = angle * 0.5;
126:
127: float which = step(0., flapness);// 0 if negative, 1 if positive
128: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
129:
130: return degrees;
131: }
132:
133: BlockFrag FLWMain(Vertex v, Flap flap) {
134: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
135:
136: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
137: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
138:
139: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
140: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
141:
142: vec4 worldPos = vec4(rotated, 1.);
143: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
144:
145: FLWFinalizeWorldPos(worldPos);
146: FLWFinalizeNormal(norm);
147:
148: BlockFrag b;
149: b.diffuse = diffuse(norm);
150: b.texCoords = v.texCoords;
151: b.light = flap.light;
152: #if defined(DEBUG_NORMAL)
153: b.color = vec4(norm, 1.);
154: #else
155: b.color = vec4(1.);
156: #endif
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec3 a_i_instancePos;
164: attribute vec2 a_i_light;
165: attribute vec3 a_i_segmentOffset;
166: attribute vec3 a_i_pivot;
167: attribute float a_i_horizontalAngle;
168: attribute float a_i_intensity;
169: attribute float a_i_flapScale;
170: attribute float a_i_flapness;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Flap i;
187: i.instancePos = a_i_instancePos;
188: i.light = a_i_light;
189: i.segmentOffset = a_i_segmentOffset;
190: i.pivot = a_i_pivot;
191: i.horizontalAngle = a_i_horizontalAngle;
192: i.intensity = a_i_intensity;
193: i.flapScale = a_i_flapScale;
194: i.flapness = a_i_flapness;
195:
196:
197: BlockFrag o = FLWMain(v, i);
198:
199: v2f_texCoords = o.texCoords;
200: v2f_color = o.color;
201: v2f_diffuse = o.diffuse;
202: v2f_light = o.light;
203:
204: }
[12:44:00] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:00] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:02] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:44:02] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Flap {
89: vec3 instancePos;
90: vec2 light;
91: vec3 segmentOffset;
92: vec3 pivot;
93: float horizontalAngle;
94: float intensity;
95: float flapScale;
96: float flapness;
97: };
98:
99:
100: struct Vertex {
101: vec3 pos;
102: vec3 normal;
103: vec2 texCoords;
104: };
105:
106: struct BlockFrag {
107: vec2 texCoords;
108: vec4 color;
109: float diffuse;
110: vec2 light;
111: };
112:
113:
114: float toRad(float degrees) {
115: return fract(degrees / 360.) * PI * 2.;
116: }
117:
118: float getFlapAngle(float flapness, float intensity, float scale) {
119: float absFlap = abs(flapness);
120:
121: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
122:
123: float halfAngle = angle * 0.5;
124:
125: float which = step(0., flapness);// 0 if negative, 1 if positive
126: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
127:
128: return degrees;
129: }
130:
131: BlockFrag FLWMain(Vertex v, Flap flap) {
132: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
133:
134: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
135: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
136:
137: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
138: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
139:
140: vec4 worldPos = vec4(rotated, 1.);
141: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
142:
143: FLWFinalizeWorldPos(worldPos);
144: FLWFinalizeNormal(norm);
145:
146: BlockFrag b;
147: b.diffuse = diffuse(norm);
148: b.texCoords = v.texCoords;
149: b.light = flap.light;
150: #if defined(DEBUG_NORMAL)
151: b.color = vec4(norm, 1.);
152: #else
153: b.color = vec4(1.);
154: #endif
155: return b;
156: }
157: attribute vec3 a_v_pos;
158: attribute vec3 a_v_normal;
159: attribute vec2 a_v_texCoords;
160:
161: attribute vec3 a_i_instancePos;
162: attribute vec2 a_i_light;
163: attribute vec3 a_i_segmentOffset;
164: attribute vec3 a_i_pivot;
165: attribute float a_i_horizontalAngle;
166: attribute float a_i_intensity;
167: attribute float a_i_flapScale;
168: attribute float a_i_flapness;
169:
170:
171: varying vec2 v2f_texCoords;
172: varying vec4 v2f_color;
173: varying float v2f_diffuse;
174: varying vec2 v2f_light;
175:
176:
177: void main() {
178: Vertex v;
179: v.pos = a_v_pos;
180: v.normal = a_v_normal;
181: v.texCoords = a_v_texCoords;
182:
183:
184: Flap i;
185: i.instancePos = a_i_instancePos;
186: i.light = a_i_light;
187: i.segmentOffset = a_i_segmentOffset;
188: i.pivot = a_i_pivot;
189: i.horizontalAngle = a_i_horizontalAngle;
190: i.intensity = a_i_intensity;
191: i.flapScale = a_i_flapScale;
192: i.flapness = a_i_flapness;
193:
194:
195: BlockFrag o = FLWMain(v, i);
196:
197: v2f_texCoords = o.texCoords;
198: v2f_color = o.color;
199: v2f_diffuse = o.diffuse;
200: v2f_light = o.light;
201:
202: }
[12:44:05] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:05] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:44:05] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:05] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: uniform float uTime;
5: uniform mat4 uViewProjection;
6: uniform vec3 uCameraPos;
7:
8: #if defined(USE_FOG)
9: varying float FragDistance;
10: #endif
11:
12: void FLWFinalizeWorldPos(inout vec4 worldPos) {
13: #if defined(USE_FOG)
14: FragDistance = length(worldPos.xyz - uCameraPos);
15: #endif
16:
17: gl_Position = uViewProjection * worldPos;
18: }
19:
20: void FLWFinalizeNormal(inout vec3 normal) {
21: // noop
22: }
23:
24:
25: mat4 rotate(vec3 axis, float angle) {
26: float s = sin(angle);
27: float c = cos(angle);
28: float oc = 1. - c;
29:
30: vec3 sa = axis * s;
31:
32: mat4 mr = mat4(1.);
33: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
34: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
35: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
36:
37: return mr;
38: }
39:
40: mat4 rotation(vec3 rot) {
41: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
42: }
43:
44: mat3 modelToNormal(mat4 mat) {
45: // Discard the edges. This won't be accurate for scaled or skewed matrices,
46: // but we don't have to work with those often.
47: mat3 m;
48: m[0] = mat[0].xyz;
49: m[1] = mat[1].xyz;
50: m[2] = mat[2].xyz;
51: return m;
52: }
53:
54: #define PIOVER2 1.5707963268
55:
56: vec4 quat(vec3 axis, float angle) {
57: float halfAngle = angle * PIOVER2 / 180.0;
58: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
59: return vec4(axis.xyz * cs.y, cs.x);
60: }
61:
62: vec4 quatMult(vec4 q1, vec4 q2) {
63: // disgustingly vectorized quaternion multiplication
64: vec4 a = q1.w * q2.xyzw;
65: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
66: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
67: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
68:
69: return a + b + c + d;
70: }
71:
72: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
73: vec3 i = q.xyz;
74: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
75: }
76:
77: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
78: return rotateVertexByQuat(v, quat(axis, angle));
79: }
80:
81: float diffuse(vec3 normal) {
82: vec3 n2 = normal * normal * vec3(.6, .25, .8);
83: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
84: }
85:
86:
87: struct Oriented {
88: vec2 light;
89: vec4 color;
90: vec3 pos;
91: vec3 pivot;
92: vec4 rotation;
93: };
94:
95:
96: struct Vertex {
97: vec3 pos;
98: vec3 normal;
99: vec2 texCoords;
100: };
101:
102: struct BlockFrag {
103: vec2 texCoords;
104: vec4 color;
105: float diffuse;
106: vec2 light;
107: };
108:
109: BlockFrag FLWMain(Vertex v, Oriented o) {
110: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
111:
112: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
113:
114: FLWFinalizeWorldPos(worldPos);
115: FLWFinalizeNormal(norm);
116:
117: BlockFrag b;
118: b.diffuse = diffuse(norm);
119: b.texCoords = v.texCoords;
120: b.light = o.light;
121: #if defined(DEBUG_NORMAL)
122: b.color = vec4(norm, 1.);
123: #else
124: b.color = o.color;
125: #endif
126: return b;
127: }
128: attribute vec3 a_v_pos;
129: attribute vec3 a_v_normal;
130: attribute vec2 a_v_texCoords;
131:
132: attribute vec2 a_i_light;
133: attribute vec4 a_i_color;
134: attribute vec3 a_i_pos;
135: attribute vec3 a_i_pivot;
136: attribute vec4 a_i_rotation;
137:
138:
139: varying vec2 v2f_texCoords;
140: varying vec4 v2f_color;
141: varying float v2f_diffuse;
142: varying vec2 v2f_light;
143:
144:
145: void main() {
146: Vertex v;
147: v.pos = a_v_pos;
148: v.normal = a_v_normal;
149: v.texCoords = a_v_texCoords;
150:
151:
152: Oriented i;
153: i.light = a_i_light;
154: i.color = a_i_color;
155: i.pos = a_i_pos;
156: i.pivot = a_i_pivot;
157: i.rotation = a_i_rotation;
158:
159:
160: BlockFrag o = FLWMain(v, i);
161:
162: v2f_texCoords = o.texCoords;
163: v2f_color = o.color;
164: v2f_diffuse = o.diffuse;
165: v2f_light = o.light;
166:
167: }
[12:44:07] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:07] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:44:07] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:07] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Oriented {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: vec3 pivot;
93: vec4 rotation;
94: };
95:
96:
97: struct Vertex {
98: vec3 pos;
99: vec3 normal;
100: vec2 texCoords;
101: };
102:
103: struct BlockFrag {
104: vec2 texCoords;
105: vec4 color;
106: float diffuse;
107: vec2 light;
108: };
109:
110: BlockFrag FLWMain(Vertex v, Oriented o) {
111: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
112:
113: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = o.light;
122: #if defined(DEBUG_NORMAL)
123: b.color = vec4(norm, 1.);
124: #else
125: b.color = o.color;
126: #endif
127: return b;
128: }
129: attribute vec3 a_v_pos;
130: attribute vec3 a_v_normal;
131: attribute vec2 a_v_texCoords;
132:
133: attribute vec2 a_i_light;
134: attribute vec4 a_i_color;
135: attribute vec3 a_i_pos;
136: attribute vec3 a_i_pivot;
137: attribute vec4 a_i_rotation;
138:
139:
140: varying vec2 v2f_texCoords;
141: varying vec4 v2f_color;
142: varying float v2f_diffuse;
143: varying vec2 v2f_light;
144:
145:
146: void main() {
147: Vertex v;
148: v.pos = a_v_pos;
149: v.normal = a_v_normal;
150: v.texCoords = a_v_texCoords;
151:
152:
153: Oriented i;
154: i.light = a_i_light;
155: i.color = a_i_color;
156: i.pos = a_i_pos;
157: i.pivot = a_i_pivot;
158: i.rotation = a_i_rotation;
159:
160:
161: BlockFrag o = FLWMain(v, i);
162:
163: v2f_texCoords = o.texCoords;
164: v2f_color = o.color;
165: v2f_diffuse = o.diffuse;
166: v2f_light = o.light;
167:
168: }
[12:44:11] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:11] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:11] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:11] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: mat4 rotate(vec3 axis, float angle) {
27: float s = sin(angle);
28: float c = cos(angle);
29: float oc = 1. - c;
30:
31: vec3 sa = axis * s;
32:
33: mat4 mr = mat4(1.);
34: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
35: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
36: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
37:
38: return mr;
39: }
40:
41: mat4 rotation(vec3 rot) {
42: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
43: }
44:
45: mat3 modelToNormal(mat4 mat) {
46: // Discard the edges. This won't be accurate for scaled or skewed matrices,
47: // but we don't have to work with those often.
48: mat3 m;
49: m[0] = mat[0].xyz;
50: m[1] = mat[1].xyz;
51: m[2] = mat[2].xyz;
52: return m;
53: }
54:
55: #define PIOVER2 1.5707963268
56:
57: vec4 quat(vec3 axis, float angle) {
58: float halfAngle = angle * PIOVER2 / 180.0;
59: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
60: return vec4(axis.xyz * cs.y, cs.x);
61: }
62:
63: vec4 quatMult(vec4 q1, vec4 q2) {
64: // disgustingly vectorized quaternion multiplication
65: vec4 a = q1.w * q2.xyzw;
66: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
67: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
68: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
69:
70: return a + b + c + d;
71: }
72:
73: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
74: vec3 i = q.xyz;
75: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
76: }
77:
78: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
79: return rotateVertexByQuat(v, quat(axis, angle));
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Oriented {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: vec3 pivot;
93: vec4 rotation;
94: };
95:
96:
97: struct Vertex {
98: vec3 pos;
99: vec3 normal;
100: vec2 texCoords;
101: };
102:
103: struct BlockFrag {
104: vec2 texCoords;
105: vec4 color;
106: float diffuse;
107: vec2 light;
108: };
109:
110: BlockFrag FLWMain(Vertex v, Oriented o) {
111: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
112:
113: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = o.light;
122: #if defined(DEBUG_NORMAL)
123: b.color = vec4(norm, 1.);
124: #else
125: b.color = o.color;
126: #endif
127: return b;
128: }
129: attribute vec3 a_v_pos;
130: attribute vec3 a_v_normal;
131: attribute vec2 a_v_texCoords;
132:
133: attribute vec2 a_i_light;
134: attribute vec4 a_i_color;
135: attribute vec3 a_i_pos;
136: attribute vec3 a_i_pivot;
137: attribute vec4 a_i_rotation;
138:
139:
140: varying vec2 v2f_texCoords;
141: varying vec4 v2f_color;
142: varying float v2f_diffuse;
143: varying vec2 v2f_light;
144:
145:
146: void main() {
147: Vertex v;
148: v.pos = a_v_pos;
149: v.normal = a_v_normal;
150: v.texCoords = a_v_texCoords;
151:
152:
153: Oriented i;
154: i.light = a_i_light;
155: i.color = a_i_color;
156: i.pos = a_i_pos;
157: i.pivot = a_i_pivot;
158: i.rotation = a_i_rotation;
159:
160:
161: BlockFrag o = FLWMain(v, i);
162:
163: v2f_texCoords = o.texCoords;
164: v2f_color = o.color;
165: v2f_diffuse = o.diffuse;
166: v2f_light = o.light;
167:
168: }
[12:44:15] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:15] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:15] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:15] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2:
3: uniform float uTime;
4: uniform mat4 uViewProjection;
5: uniform vec3 uCameraPos;
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: void FLWFinalizeWorldPos(inout vec4 worldPos) {
12: #if defined(USE_FOG)
13: FragDistance = length(worldPos.xyz - uCameraPos);
14: #endif
15:
16: gl_Position = uViewProjection * worldPos;
17: }
18:
19: void FLWFinalizeNormal(inout vec3 normal) {
20: // noop
21: }
22:
23:
24: mat4 rotate(vec3 axis, float angle) {
25: float s = sin(angle);
26: float c = cos(angle);
27: float oc = 1. - c;
28:
29: vec3 sa = axis * s;
30:
31: mat4 mr = mat4(1.);
32: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
33: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
34: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
35:
36: return mr;
37: }
38:
39: mat4 rotation(vec3 rot) {
40: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
41: }
42:
43: mat3 modelToNormal(mat4 mat) {
44: // Discard the edges. This won't be accurate for scaled or skewed matrices,
45: // but we don't have to work with those often.
46: mat3 m;
47: m[0] = mat[0].xyz;
48: m[1] = mat[1].xyz;
49: m[2] = mat[2].xyz;
50: return m;
51: }
52:
53: #define PIOVER2 1.5707963268
54:
55: vec4 quat(vec3 axis, float angle) {
56: float halfAngle = angle * PIOVER2 / 180.0;
57: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
58: return vec4(axis.xyz * cs.y, cs.x);
59: }
60:
61: vec4 quatMult(vec4 q1, vec4 q2) {
62: // disgustingly vectorized quaternion multiplication
63: vec4 a = q1.w * q2.xyzw;
64: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
65: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
66: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
67:
68: return a + b + c + d;
69: }
70:
71: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
72: vec3 i = q.xyz;
73: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
74: }
75:
76: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
77: return rotateVertexByQuat(v, quat(axis, angle));
78: }
79:
80: float diffuse(vec3 normal) {
81: vec3 n2 = normal * normal * vec3(.6, .25, .8);
82: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
83: }
84:
85:
86: struct Oriented {
87: vec2 light;
88: vec4 color;
89: vec3 pos;
90: vec3 pivot;
91: vec4 rotation;
92: };
93:
94:
95: struct Vertex {
96: vec3 pos;
97: vec3 normal;
98: vec2 texCoords;
99: };
100:
101: struct BlockFrag {
102: vec2 texCoords;
103: vec4 color;
104: float diffuse;
105: vec2 light;
106: };
107:
108: BlockFrag FLWMain(Vertex v, Oriented o) {
109: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
110:
111: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
112:
113: FLWFinalizeWorldPos(worldPos);
114: FLWFinalizeNormal(norm);
115:
116: BlockFrag b;
117: b.diffuse = diffuse(norm);
118: b.texCoords = v.texCoords;
119: b.light = o.light;
120: #if defined(DEBUG_NORMAL)
121: b.color = vec4(norm, 1.);
122: #else
123: b.color = o.color;
124: #endif
125: return b;
126: }
127: attribute vec3 a_v_pos;
128: attribute vec3 a_v_normal;
129: attribute vec2 a_v_texCoords;
130:
131: attribute vec2 a_i_light;
132: attribute vec4 a_i_color;
133: attribute vec3 a_i_pos;
134: attribute vec3 a_i_pivot;
135: attribute vec4 a_i_rotation;
136:
137:
138: varying vec2 v2f_texCoords;
139: varying vec4 v2f_color;
140: varying float v2f_diffuse;
141: varying vec2 v2f_light;
142:
143:
144: void main() {
145: Vertex v;
146: v.pos = a_v_pos;
147: v.normal = a_v_normal;
148: v.texCoords = a_v_texCoords;
149:
150:
151: Oriented i;
152: i.light = a_i_light;
153: i.color = a_i_color;
154: i.pos = a_i_pos;
155: i.pivot = a_i_pivot;
156: i.rotation = a_i_rotation;
157:
158:
159: BlockFrag o = FLWMain(v, i);
160:
161: v2f_texCoords = o.texCoords;
162: v2f_color = o.color;
163: v2f_diffuse = o.diffuse;
164: v2f_light = o.light;
165:
166: }
[12:44:15] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:15] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:44:15] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:15] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: uniform float uTime;
5: uniform mat4 uViewProjection;
6: uniform vec3 uCameraPos;
7:
8: #if defined(USE_FOG)
9: varying float FragDistance;
10: #endif
11:
12: void FLWFinalizeWorldPos(inout vec4 worldPos) {
13: #if defined(USE_FOG)
14: FragDistance = length(worldPos.xyz - uCameraPos);
15: #endif
16:
17: gl_Position = uViewProjection * worldPos;
18: }
19:
20: void FLWFinalizeNormal(inout vec3 normal) {
21: // noop
22: }
23:
24:
25: float diffuse(vec3 normal) {
26: vec3 n2 = normal * normal * vec3(.6, .25, .8);
27: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
28: }
29:
30:
31: struct Vertex {
32: vec3 pos;
33: vec3 normal;
34: vec2 texCoords;
35: };
36:
37: struct BlockFrag {
38: vec2 texCoords;
39: vec4 color;
40: float diffuse;
41: vec2 light;
42: };
43:
44:
45: struct Instance {
46: vec2 light;
47: vec4 color;
48: mat4 transform;
49: mat3 normalMat;
50: };
51:
52: BlockFrag FLWMain(Vertex v, Instance i) {
53: vec4 worldPos = i.transform * vec4(v.pos, 1.);
54:
55: vec3 norm = i.normalMat * v.normal;
56:
57: FLWFinalizeWorldPos(worldPos);
58: FLWFinalizeNormal(norm);
59:
60: norm = normalize(norm);
61:
62: BlockFrag b;
63: b.diffuse = diffuse(norm);
64: b.texCoords = v.texCoords;
65: b.light = i.light;
66: #if defined(DEBUG_NORMAL)
67: b.color = vec4(norm, 1.);
68: #else
69: b.color = i.color;
70: #endif
71: return b;
72: }
73: attribute vec3 a_v_pos;
74: attribute vec3 a_v_normal;
75: attribute vec2 a_v_texCoords;
76:
77: attribute vec2 a_i_light;
78: attribute vec4 a_i_color;
79: attribute mat4 a_i_transform;
80: attribute mat3 a_i_normalMat;
81:
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: void main() {
90: Vertex v;
91: v.pos = a_v_pos;
92: v.normal = a_v_normal;
93: v.texCoords = a_v_texCoords;
94:
95:
96: Instance i;
97: i.light = a_i_light;
98: i.color = a_i_color;
99: i.transform = a_i_transform;
100: i.normalMat = a_i_normalMat;
101:
102:
103: BlockFrag o = FLWMain(v, i);
104:
105: v2f_texCoords = o.texCoords;
106: v2f_color = o.color;
107: v2f_diffuse = o.diffuse;
108: v2f_light = o.light;
109:
110: }
[12:44:16] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:16] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:44:16] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:16] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: float diffuse(vec3 normal) {
27: vec3 n2 = normal * normal * vec3(.6, .25, .8);
28: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
29: }
30:
31:
32: struct Vertex {
33: vec3 pos;
34: vec3 normal;
35: vec2 texCoords;
36: };
37:
38: struct BlockFrag {
39: vec2 texCoords;
40: vec4 color;
41: float diffuse;
42: vec2 light;
43: };
44:
45:
46: struct Instance {
47: vec2 light;
48: vec4 color;
49: mat4 transform;
50: mat3 normalMat;
51: };
52:
53: BlockFrag FLWMain(Vertex v, Instance i) {
54: vec4 worldPos = i.transform * vec4(v.pos, 1.);
55:
56: vec3 norm = i.normalMat * v.normal;
57:
58: FLWFinalizeWorldPos(worldPos);
59: FLWFinalizeNormal(norm);
60:
61: norm = normalize(norm);
62:
63: BlockFrag b;
64: b.diffuse = diffuse(norm);
65: b.texCoords = v.texCoords;
66: b.light = i.light;
67: #if defined(DEBUG_NORMAL)
68: b.color = vec4(norm, 1.);
69: #else
70: b.color = i.color;
71: #endif
72: return b;
73: }
74: attribute vec3 a_v_pos;
75: attribute vec3 a_v_normal;
76: attribute vec2 a_v_texCoords;
77:
78: attribute vec2 a_i_light;
79: attribute vec4 a_i_color;
80: attribute mat4 a_i_transform;
81: attribute mat3 a_i_normalMat;
82:
83:
84: varying vec2 v2f_texCoords;
85: varying vec4 v2f_color;
86: varying float v2f_diffuse;
87: varying vec2 v2f_light;
88:
89:
90: void main() {
91: Vertex v;
92: v.pos = a_v_pos;
93: v.normal = a_v_normal;
94: v.texCoords = a_v_texCoords;
95:
96:
97: Instance i;
98: i.light = a_i_light;
99: i.color = a_i_color;
100: i.transform = a_i_transform;
101: i.normalMat = a_i_normalMat;
102:
103:
104: BlockFrag o = FLWMain(v, i);
105:
106: v2f_texCoords = o.texCoords;
107: v2f_color = o.color;
108: v2f_diffuse = o.diffuse;
109: v2f_light = o.light;
110:
111: }
[12:44:16] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:16] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:16] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:16] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: float diffuse(vec3 normal) {
27: vec3 n2 = normal * normal * vec3(.6, .25, .8);
28: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
29: }
30:
31:
32: struct Vertex {
33: vec3 pos;
34: vec3 normal;
35: vec2 texCoords;
36: };
37:
38: struct BlockFrag {
39: vec2 texCoords;
40: vec4 color;
41: float diffuse;
42: vec2 light;
43: };
44:
45:
46: struct Instance {
47: vec2 light;
48: vec4 color;
49: mat4 transform;
50: mat3 normalMat;
51: };
52:
53: BlockFrag FLWMain(Vertex v, Instance i) {
54: vec4 worldPos = i.transform * vec4(v.pos, 1.);
55:
56: vec3 norm = i.normalMat * v.normal;
57:
58: FLWFinalizeWorldPos(worldPos);
59: FLWFinalizeNormal(norm);
60:
61: norm = normalize(norm);
62:
63: BlockFrag b;
64: b.diffuse = diffuse(norm);
65: b.texCoords = v.texCoords;
66: b.light = i.light;
67: #if defined(DEBUG_NORMAL)
68: b.color = vec4(norm, 1.);
69: #else
70: b.color = i.color;
71: #endif
72: return b;
73: }
74: attribute vec3 a_v_pos;
75: attribute vec3 a_v_normal;
76: attribute vec2 a_v_texCoords;
77:
78: attribute vec2 a_i_light;
79: attribute vec4 a_i_color;
80: attribute mat4 a_i_transform;
81: attribute mat3 a_i_normalMat;
82:
83:
84: varying vec2 v2f_texCoords;
85: varying vec4 v2f_color;
86: varying float v2f_diffuse;
87: varying vec2 v2f_light;
88:
89:
90: void main() {
91: Vertex v;
92: v.pos = a_v_pos;
93: v.normal = a_v_normal;
94: v.texCoords = a_v_texCoords;
95:
96:
97: Instance i;
98: i.light = a_i_light;
99: i.color = a_i_color;
100: i.transform = a_i_transform;
101: i.normalMat = a_i_normalMat;
102:
103:
104: BlockFrag o = FLWMain(v, i);
105:
106: v2f_texCoords = o.texCoords;
107: v2f_color = o.color;
108: v2f_diffuse = o.diffuse;
109: v2f_light = o.light;
110:
111: }
[12:44:16] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:16] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:19] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:19] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2:
3: uniform float uTime;
4: uniform mat4 uViewProjection;
5: uniform vec3 uCameraPos;
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: void FLWFinalizeWorldPos(inout vec4 worldPos) {
12: #if defined(USE_FOG)
13: FragDistance = length(worldPos.xyz - uCameraPos);
14: #endif
15:
16: gl_Position = uViewProjection * worldPos;
17: }
18:
19: void FLWFinalizeNormal(inout vec3 normal) {
20: // noop
21: }
22:
23:
24: float diffuse(vec3 normal) {
25: vec3 n2 = normal * normal * vec3(.6, .25, .8);
26: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
27: }
28:
29:
30: struct Vertex {
31: vec3 pos;
32: vec3 normal;
33: vec2 texCoords;
34: };
35:
36: struct BlockFrag {
37: vec2 texCoords;
38: vec4 color;
39: float diffuse;
40: vec2 light;
41: };
42:
43:
44: struct Instance {
45: vec2 light;
46: vec4 color;
47: mat4 transform;
48: mat3 normalMat;
49: };
50:
51: BlockFrag FLWMain(Vertex v, Instance i) {
52: vec4 worldPos = i.transform * vec4(v.pos, 1.);
53:
54: vec3 norm = i.normalMat * v.normal;
55:
56: FLWFinalizeWorldPos(worldPos);
57: FLWFinalizeNormal(norm);
58:
59: norm = normalize(norm);
60:
61: BlockFrag b;
62: b.diffuse = diffuse(norm);
63: b.texCoords = v.texCoords;
64: b.light = i.light;
65: #if defined(DEBUG_NORMAL)
66: b.color = vec4(norm, 1.);
67: #else
68: b.color = i.color;
69: #endif
70: return b;
71: }
72: attribute vec3 a_v_pos;
73: attribute vec3 a_v_normal;
74: attribute vec2 a_v_texCoords;
75:
76: attribute vec2 a_i_light;
77: attribute vec4 a_i_color;
78: attribute mat4 a_i_transform;
79: attribute mat3 a_i_normalMat;
80:
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: void main() {
89: Vertex v;
90: v.pos = a_v_pos;
91: v.normal = a_v_normal;
92: v.texCoords = a_v_texCoords;
93:
94:
95: Instance i;
96: i.light = a_i_light;
97: i.color = a_i_color;
98: i.transform = a_i_transform;
99: i.normalMat = a_i_normalMat;
100:
101:
102: BlockFrag o = FLWMain(v, i);
103:
104: v2f_texCoords = o.texCoords;
105: v2f_color = o.color;
106: v2f_diffuse = o.diffuse;
107: v2f_light = o.light;
108:
109: }
[12:44:19] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:19] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:44:22] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:44:22] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: #define PIOVER2 1.5707963268
28:
29: vec4 quat(vec3 axis, float angle) {
30: float halfAngle = angle * PIOVER2 / 180.0;
31: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
32: return vec4(axis.xyz * cs.y, cs.x);
33: }
34:
35: vec4 quatMult(vec4 q1, vec4 q2) {
36: // disgustingly vectorized quaternion multiplication
37: vec4 a = q1.w * q2.xyzw;
38: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
39: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
40: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
41:
42: return a + b + c + d;
43: }
44:
45: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
46: vec3 i = q.xyz;
47: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
48: }
49:
50: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
51: return rotateVertexByQuat(v, quat(axis, angle));
52: }
53:
54: mat4 rotate(vec3 axis, float angle) {
55: float s = sin(angle);
56: float c = cos(angle);
57: float oc = 1. - c;
58:
59: vec3 sa = axis * s;
60:
61: mat4 mr = mat4(1.);
62: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
63: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
64: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
65:
66: return mr;
67: }
68:
69: mat4 rotation(vec3 rot) {
70: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
71: }
72:
73: mat3 modelToNormal(mat4 mat) {
74: // Discard the edges. This won't be accurate for scaled or skewed matrices,
75: // but we don't have to work with those often.
76: mat3 m;
77: m[0] = mat[0].xyz;
78: m[1] = mat[1].xyz;
79: m[2] = mat[2].xyz;
80: return m;
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Belt {
90: vec2 light;
91: vec4 color;
92: vec3 pos;
93: float speed;
94: float offset;
95: vec4 rotation;
96: vec2 sourceTexture;
97: vec4 scrollTexture;
98: float scrollMult;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115: BlockFrag FLWMain(Vertex v, Belt instance) {
116: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
117:
118: vec4 worldPos = vec4(rotated, 1.);
119:
120: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
126: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
127:
128: BlockFrag b;
129: b.diffuse = diffuse(norm);
130: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
131: b.light = instance.light;
132:
133: #if defined(DEBUG_RAINBOW)
134: b.color = instance.color;
135: #elif defined(DEBUG_NORMAL)
136: b.color = vec4(norm, 1.);
137: #else
138: b.color = vec4(1.);
139: #endif
140:
141: return b;
142: }
143: attribute vec3 a_v_pos;
144: attribute vec3 a_v_normal;
145: attribute vec2 a_v_texCoords;
146:
147: attribute vec2 a_i_light;
148: attribute vec4 a_i_color;
149: attribute vec3 a_i_pos;
150: attribute float a_i_speed;
151: attribute float a_i_offset;
152: attribute vec4 a_i_rotation;
153: attribute vec2 a_i_sourceTexture;
154: attribute vec4 a_i_scrollTexture;
155: attribute float a_i_scrollMult;
156:
157:
158: varying vec2 v2f_texCoords;
159: varying vec4 v2f_color;
160: varying float v2f_diffuse;
161: varying vec2 v2f_light;
162:
163:
164: void main() {
165: Vertex v;
166: v.pos = a_v_pos;
167: v.normal = a_v_normal;
168: v.texCoords = a_v_texCoords;
169:
170:
171: Belt i;
172: i.light = a_i_light;
173: i.color = a_i_color;
174: i.pos = a_i_pos;
175: i.speed = a_i_speed;
176: i.offset = a_i_offset;
177: i.rotation = a_i_rotation;
178: i.sourceTexture = a_i_sourceTexture;
179: i.scrollTexture = a_i_scrollTexture;
180: i.scrollMult = a_i_scrollMult;
181:
182:
183: BlockFrag o = FLWMain(v, i);
184:
185: v2f_texCoords = o.texCoords;
186: v2f_color = o.color;
187: v2f_diffuse = o.diffuse;
188: v2f_light = o.light;
189:
190: }
[12:44:26] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:26] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:44:26] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:44:26] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: uniform float uTime;
7: uniform mat4 uViewProjection;
8: uniform vec3 uCameraPos;
9:
10: #if defined(USE_FOG)
11: varying float FragDistance;
12: #endif
13:
14: void FLWFinalizeWorldPos(inout vec4 worldPos) {
15: #if defined(USE_FOG)
16: FragDistance = length(worldPos.xyz - uCameraPos);
17: #endif
18:
19: gl_Position = uViewProjection * worldPos;
20: }
21:
22: void FLWFinalizeNormal(inout vec3 normal) {
23: // noop
24: }
25:
26:
27: #define PIOVER2 1.5707963268
28:
29: vec4 quat(vec3 axis, float angle) {
30: float halfAngle = angle * PIOVER2 / 180.0;
31: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
32: return vec4(axis.xyz * cs.y, cs.x);
33: }
34:
35: vec4 quatMult(vec4 q1, vec4 q2) {
36: // disgustingly vectorized quaternion multiplication
37: vec4 a = q1.w * q2.xyzw;
38: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
39: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
40: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
41:
42: return a + b + c + d;
43: }
44:
45: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
46: vec3 i = q.xyz;
47: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
48: }
49:
50: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
51: return rotateVertexByQuat(v, quat(axis, angle));
52: }
53:
54: mat4 rotate(vec3 axis, float angle) {
55: float s = sin(angle);
56: float c = cos(angle);
57: float oc = 1. - c;
58:
59: vec3 sa = axis * s;
60:
61: mat4 mr = mat4(1.);
62: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
63: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
64: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
65:
66: return mr;
67: }
68:
69: mat4 rotation(vec3 rot) {
70: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
71: }
72:
73: mat3 modelToNormal(mat4 mat) {
74: // Discard the edges. This won't be accurate for scaled or skewed matrices,
75: // but we don't have to work with those often.
76: mat3 m;
77: m[0] = mat[0].xyz;
78: m[1] = mat[1].xyz;
79: m[2] = mat[2].xyz;
80: return m;
81: }
82:
83: float diffuse(vec3 normal) {
84: vec3 n2 = normal * normal * vec3(.6, .25, .8);
85: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
86: }
87:
88:
89: struct Belt {
90: vec2 light;
91: vec4 color;
92: vec3 pos;
93: float speed;
94: float offset;
95: vec4 rotation;
96: vec2 sourceTexture;
97: vec4 scrollTexture;
98: float scrollMult;
99: };
100:
101:
102: struct Vertex {
103: vec3 pos;
104: vec3 normal;
105: vec2 texCoords;
106: };
107:
108: struct BlockFrag {
109: vec2 texCoords;
110: vec4 color;
111: float diffuse;
112: vec2 light;
113: };
114:
115: BlockFrag FLWMain(Vertex v, Belt instance) {
116: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
117:
118: vec4 worldPos = vec4(rotated, 1.);
119:
120: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
121:
122: FLWFinalizeWorldPos(worldPos);
123: FLWFinalizeNormal(norm);
124:
125: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
126: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
127:
128: BlockFrag b;
129: b.diffuse = diffuse(norm);
130: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
131: b.light = instance.light;
132:
133: #if defined(DEBUG_RAINBOW)
134: b.color = instance.color;
135: #elif defined(DEBUG_NORMAL)
136: b.color = vec4(norm, 1.);
137: #else
138: b.color = vec4(1.);
139: #endif
140:
141: return b;
142: }
143: attribute vec3 a_v_pos;
144: attribute vec3 a_v_normal;
145: attribute vec2 a_v_texCoords;
146:
147: attribute vec2 a_i_light;
148: attribute vec4 a_i_color;
149: attribute vec3 a_i_pos;
150: attribute float a_i_speed;
151: attribute float a_i_offset;
152: attribute vec4 a_i_rotation;
153: attribute vec2 a_i_sourceTexture;
154: attribute vec4 a_i_scrollTexture;
155: attribute float a_i_scrollMult;
156:
157:
158: varying vec2 v2f_texCoords;
159: varying vec4 v2f_color;
160: varying float v2f_diffuse;
161: varying vec2 v2f_light;
162:
163:
164: void main() {
165: Vertex v;
166: v.pos = a_v_pos;
167: v.normal = a_v_normal;
168: v.texCoords = a_v_texCoords;
169:
170:
171: Belt i;
172: i.light = a_i_light;
173: i.color = a_i_color;
174: i.pos = a_i_pos;
175: i.speed = a_i_speed;
176: i.offset = a_i_offset;
177: i.rotation = a_i_rotation;
178: i.sourceTexture = a_i_sourceTexture;
179: i.scrollTexture = a_i_scrollTexture;
180: i.scrollMult = a_i_scrollMult;
181:
182:
183: BlockFrag o = FLWMain(v, i);
184:
185: v2f_texCoords = o.texCoords;
186: v2f_color = o.color;
187: v2f_diffuse = o.diffuse;
188: v2f_light = o.light;
189:
190: }
[12:44:29] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:29] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: uniform sampler2D uBlockAtlas;
31: uniform sampler2D uLightMap;
32:
33: vec4 FLWBlockTexture(vec2 texCoords) {
34: return texture2D(uBlockAtlas, texCoords);
35: }
36:
37: void FLWFinalizeColor(vec4 color) {
38: #if defined(USE_FOG)
39: float a = color.a;
40: float fog = clamp(FLWFogFactor(), 0., 1.);
41:
42: color = mix(uFogColor, color, fog);
43: color.a = a;
44: #endif
45:
46: gl_FragColor = color;
47: }
48:
49: vec4 FLWLight(vec2 lightCoords) {
50: return texture2D(uLightMap, shiftLight(lightCoords));
51: }
52:
53:
54:
55: struct BlockFrag {
56: vec2 texCoords;
57: vec4 color;
58: float diffuse;
59: vec2 light;
60: };
61:
62: void FLWMain(BlockFrag r) {
63: vec4 tex = FLWBlockTexture(r.texCoords);
64:
65: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
66:
67: // flw_WorldPos = ;
68: // flw_Normal = ;
69: // flw_Albedo = tex.rgb;
70: // flw_Alpha = tex.a;
71: // flw_LightMap = r.light;
72: // flw_Tint = r.color;
73: FLWFinalizeColor(color);
74: }
75:
76: varying vec2 v2f_texCoords;
77: varying vec4 v2f_color;
78: varying float v2f_diffuse;
79: varying vec2 v2f_light;
80:
81:
82: //vec3 flw_WorldPos;
83: //vec3 flw_Normal;
84: //vec3 flw_Albedo;
85: //float flw_Alpha;
86: //vec2 flw_LightMap;
87: //vec4 flw_Tint;
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:44:29] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:44:29] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: #define PIOVER2 1.5707963268
29:
30: vec4 quat(vec3 axis, float angle) {
31: float halfAngle = angle * PIOVER2 / 180.0;
32: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
33: return vec4(axis.xyz * cs.y, cs.x);
34: }
35:
36: vec4 quatMult(vec4 q1, vec4 q2) {
37: // disgustingly vectorized quaternion multiplication
38: vec4 a = q1.w * q2.xyzw;
39: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
40: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
41: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
42:
43: return a + b + c + d;
44: }
45:
46: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
47: vec3 i = q.xyz;
48: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
49: }
50:
51: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
52: return rotateVertexByQuat(v, quat(axis, angle));
53: }
54:
55: mat4 rotate(vec3 axis, float angle) {
56: float s = sin(angle);
57: float c = cos(angle);
58: float oc = 1. - c;
59:
60: vec3 sa = axis * s;
61:
62: mat4 mr = mat4(1.);
63: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
64: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
65: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
66:
67: return mr;
68: }
69:
70: mat4 rotation(vec3 rot) {
71: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
72: }
73:
74: mat3 modelToNormal(mat4 mat) {
75: // Discard the edges. This won't be accurate for scaled or skewed matrices,
76: // but we don't have to work with those often.
77: mat3 m;
78: m[0] = mat[0].xyz;
79: m[1] = mat[1].xyz;
80: m[2] = mat[2].xyz;
81: return m;
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Belt {
91: vec2 light;
92: vec4 color;
93: vec3 pos;
94: float speed;
95: float offset;
96: vec4 rotation;
97: vec2 sourceTexture;
98: vec4 scrollTexture;
99: float scrollMult;
100: };
101:
102:
103: struct Vertex {
104: vec3 pos;
105: vec3 normal;
106: vec2 texCoords;
107: };
108:
109: struct BlockFrag {
110: vec2 texCoords;
111: vec4 color;
112: float diffuse;
113: vec2 light;
114: };
115:
116: BlockFrag FLWMain(Vertex v, Belt instance) {
117: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
118:
119: vec4 worldPos = vec4(rotated, 1.);
120:
121: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
127: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
128:
129: BlockFrag b;
130: b.diffuse = diffuse(norm);
131: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
132: b.light = instance.light;
133:
134: #if defined(DEBUG_RAINBOW)
135: b.color = instance.color;
136: #elif defined(DEBUG_NORMAL)
137: b.color = vec4(norm, 1.);
138: #else
139: b.color = vec4(1.);
140: #endif
141:
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute float a_i_speed;
152: attribute float a_i_offset;
153: attribute vec4 a_i_rotation;
154: attribute vec2 a_i_sourceTexture;
155: attribute vec4 a_i_scrollTexture;
156: attribute float a_i_scrollMult;
157:
158:
159: varying vec2 v2f_texCoords;
160: varying vec4 v2f_color;
161: varying float v2f_diffuse;
162: varying vec2 v2f_light;
163:
164:
165: void main() {
166: Vertex v;
167: v.pos = a_v_pos;
168: v.normal = a_v_normal;
169: v.texCoords = a_v_texCoords;
170:
171:
172: Belt i;
173: i.light = a_i_light;
174: i.color = a_i_color;
175: i.pos = a_i_pos;
176: i.speed = a_i_speed;
177: i.offset = a_i_offset;
178: i.rotation = a_i_rotation;
179: i.sourceTexture = a_i_sourceTexture;
180: i.scrollTexture = a_i_scrollTexture;
181: i.scrollMult = a_i_scrollMult;
182:
183:
184: BlockFrag o = FLWMain(v, i);
185:
186: v2f_texCoords = o.texCoords;
187: v2f_color = o.color;
188: v2f_diffuse = o.diffuse;
189: v2f_light = o.light;
190:
191: }
[12:44:30] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:30] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:35] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:44:35] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: uniform float uTime;
8: uniform mat4 uViewProjection;
9: uniform vec3 uCameraPos;
10:
11: #if defined(USE_FOG)
12: varying float FragDistance;
13: #endif
14:
15: void FLWFinalizeWorldPos(inout vec4 worldPos) {
16: #if defined(USE_FOG)
17: FragDistance = length(worldPos.xyz - uCameraPos);
18: #endif
19:
20: gl_Position = uViewProjection * worldPos;
21: }
22:
23: void FLWFinalizeNormal(inout vec3 normal) {
24: // noop
25: }
26:
27:
28: #define PIOVER2 1.5707963268
29:
30: vec4 quat(vec3 axis, float angle) {
31: float halfAngle = angle * PIOVER2 / 180.0;
32: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
33: return vec4(axis.xyz * cs.y, cs.x);
34: }
35:
36: vec4 quatMult(vec4 q1, vec4 q2) {
37: // disgustingly vectorized quaternion multiplication
38: vec4 a = q1.w * q2.xyzw;
39: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
40: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
41: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
42:
43: return a + b + c + d;
44: }
45:
46: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
47: vec3 i = q.xyz;
48: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
49: }
50:
51: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
52: return rotateVertexByQuat(v, quat(axis, angle));
53: }
54:
55: mat4 rotate(vec3 axis, float angle) {
56: float s = sin(angle);
57: float c = cos(angle);
58: float oc = 1. - c;
59:
60: vec3 sa = axis * s;
61:
62: mat4 mr = mat4(1.);
63: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
64: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
65: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
66:
67: return mr;
68: }
69:
70: mat4 rotation(vec3 rot) {
71: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
72: }
73:
74: mat3 modelToNormal(mat4 mat) {
75: // Discard the edges. This won't be accurate for scaled or skewed matrices,
76: // but we don't have to work with those often.
77: mat3 m;
78: m[0] = mat[0].xyz;
79: m[1] = mat[1].xyz;
80: m[2] = mat[2].xyz;
81: return m;
82: }
83:
84: float diffuse(vec3 normal) {
85: vec3 n2 = normal * normal * vec3(.6, .25, .8);
86: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
87: }
88:
89:
90: struct Belt {
91: vec2 light;
92: vec4 color;
93: vec3 pos;
94: float speed;
95: float offset;
96: vec4 rotation;
97: vec2 sourceTexture;
98: vec4 scrollTexture;
99: float scrollMult;
100: };
101:
102:
103: struct Vertex {
104: vec3 pos;
105: vec3 normal;
106: vec2 texCoords;
107: };
108:
109: struct BlockFrag {
110: vec2 texCoords;
111: vec4 color;
112: float diffuse;
113: vec2 light;
114: };
115:
116: BlockFrag FLWMain(Vertex v, Belt instance) {
117: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
118:
119: vec4 worldPos = vec4(rotated, 1.);
120:
121: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
122:
123: FLWFinalizeWorldPos(worldPos);
124: FLWFinalizeNormal(norm);
125:
126: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
127: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
128:
129: BlockFrag b;
130: b.diffuse = diffuse(norm);
131: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
132: b.light = instance.light;
133:
134: #if defined(DEBUG_RAINBOW)
135: b.color = instance.color;
136: #elif defined(DEBUG_NORMAL)
137: b.color = vec4(norm, 1.);
138: #else
139: b.color = vec4(1.);
140: #endif
141:
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute float a_i_speed;
152: attribute float a_i_offset;
153: attribute vec4 a_i_rotation;
154: attribute vec2 a_i_sourceTexture;
155: attribute vec4 a_i_scrollTexture;
156: attribute float a_i_scrollMult;
157:
158:
159: varying vec2 v2f_texCoords;
160: varying vec4 v2f_color;
161: varying float v2f_diffuse;
162: varying vec2 v2f_light;
163:
164:
165: void main() {
166: Vertex v;
167: v.pos = a_v_pos;
168: v.normal = a_v_normal;
169: v.texCoords = a_v_texCoords;
170:
171:
172: Belt i;
173: i.light = a_i_light;
174: i.color = a_i_color;
175: i.pos = a_i_pos;
176: i.speed = a_i_speed;
177: i.offset = a_i_offset;
178: i.rotation = a_i_rotation;
179: i.sourceTexture = a_i_sourceTexture;
180: i.scrollTexture = a_i_scrollTexture;
181: i.scrollMult = a_i_scrollMult;
182:
183:
184: BlockFrag o = FLWMain(v, i);
185:
186: v2f_texCoords = o.texCoords;
187: v2f_color = o.color;
188: v2f_diffuse = o.diffuse;
189: v2f_light = o.light;
190:
191: }
[12:44:36] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:36] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: uniform sampler2D uBlockAtlas;
32: uniform sampler2D uLightMap;
33:
34: vec4 FLWBlockTexture(vec2 texCoords) {
35: return texture2D(uBlockAtlas, texCoords);
36: }
37:
38: void FLWFinalizeColor(vec4 color) {
39: #if defined(USE_FOG)
40: float a = color.a;
41: float fog = clamp(FLWFogFactor(), 0., 1.);
42:
43: color = mix(uFogColor, color, fog);
44: color.a = a;
45: #endif
46:
47: gl_FragColor = color;
48: }
49:
50: vec4 FLWLight(vec2 lightCoords) {
51: return texture2D(uLightMap, shiftLight(lightCoords));
52: }
53:
54:
55:
56: struct BlockFrag {
57: vec2 texCoords;
58: vec4 color;
59: float diffuse;
60: vec2 light;
61: };
62:
63: void FLWMain(BlockFrag r) {
64: vec4 tex = FLWBlockTexture(r.texCoords);
65:
66: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
67:
68: // flw_WorldPos = ;
69: // flw_Normal = ;
70: // flw_Albedo = tex.rgb;
71: // flw_Alpha = tex.a;
72: // flw_LightMap = r.light;
73: // flw_Tint = r.color;
74: FLWFinalizeColor(color);
75: }
76:
77: varying vec2 v2f_texCoords;
78: varying vec4 v2f_color;
79: varying float v2f_diffuse;
80: varying vec2 v2f_light;
81:
82:
83: //vec3 flw_WorldPos;
84: //vec3 flw_Normal;
85: //vec3 flw_Albedo;
86: //float flw_Alpha;
87: //vec2 flw_LightMap;
88: //vec4 flw_Tint;
89:
90: void main() {
91: BlockFrag f;
92: f.texCoords = v2f_texCoords;
93: f.color = v2f_color;
94: f.diffuse = v2f_diffuse;
95: f.light = v2f_light;
96:
97:
98: FLWMain(f);
99: }
[12:44:36] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:44:36] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: uniform float uTime;
6: uniform mat4 uViewProjection;
7: uniform vec3 uCameraPos;
8:
9: #if defined(USE_FOG)
10: varying float FragDistance;
11: #endif
12:
13: void FLWFinalizeWorldPos(inout vec4 worldPos) {
14: #if defined(USE_FOG)
15: FragDistance = length(worldPos.xyz - uCameraPos);
16: #endif
17:
18: gl_Position = uViewProjection * worldPos;
19: }
20:
21: void FLWFinalizeNormal(inout vec3 normal) {
22: // noop
23: }
24:
25:
26: #define PIOVER2 1.5707963268
27:
28: vec4 quat(vec3 axis, float angle) {
29: float halfAngle = angle * PIOVER2 / 180.0;
30: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
31: return vec4(axis.xyz * cs.y, cs.x);
32: }
33:
34: vec4 quatMult(vec4 q1, vec4 q2) {
35: // disgustingly vectorized quaternion multiplication
36: vec4 a = q1.w * q2.xyzw;
37: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
38: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
39: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
40:
41: return a + b + c + d;
42: }
43:
44: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
45: vec3 i = q.xyz;
46: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
47: }
48:
49: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
50: return rotateVertexByQuat(v, quat(axis, angle));
51: }
52:
53: mat4 rotate(vec3 axis, float angle) {
54: float s = sin(angle);
55: float c = cos(angle);
56: float oc = 1. - c;
57:
58: vec3 sa = axis * s;
59:
60: mat4 mr = mat4(1.);
61: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
62: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
63: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
64:
65: return mr;
66: }
67:
68: mat4 rotation(vec3 rot) {
69: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
70: }
71:
72: mat3 modelToNormal(mat4 mat) {
73: // Discard the edges. This won't be accurate for scaled or skewed matrices,
74: // but we don't have to work with those often.
75: mat3 m;
76: m[0] = mat[0].xyz;
77: m[1] = mat[1].xyz;
78: m[2] = mat[2].xyz;
79: return m;
80: }
81:
82: float diffuse(vec3 normal) {
83: vec3 n2 = normal * normal * vec3(.6, .25, .8);
84: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
85: }
86:
87:
88: struct Belt {
89: vec2 light;
90: vec4 color;
91: vec3 pos;
92: float speed;
93: float offset;
94: vec4 rotation;
95: vec2 sourceTexture;
96: vec4 scrollTexture;
97: float scrollMult;
98: };
99:
100:
101: struct Vertex {
102: vec3 pos;
103: vec3 normal;
104: vec2 texCoords;
105: };
106:
107: struct BlockFrag {
108: vec2 texCoords;
109: vec4 color;
110: float diffuse;
111: vec2 light;
112: };
113:
114: BlockFrag FLWMain(Vertex v, Belt instance) {
115: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
116:
117: vec4 worldPos = vec4(rotated, 1.);
118:
119: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
120:
121: FLWFinalizeWorldPos(worldPos);
122: FLWFinalizeNormal(norm);
123:
124: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
125: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
126:
127: BlockFrag b;
128: b.diffuse = diffuse(norm);
129: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
130: b.light = instance.light;
131:
132: #if defined(DEBUG_RAINBOW)
133: b.color = instance.color;
134: #elif defined(DEBUG_NORMAL)
135: b.color = vec4(norm, 1.);
136: #else
137: b.color = vec4(1.);
138: #endif
139:
140: return b;
141: }
142: attribute vec3 a_v_pos;
143: attribute vec3 a_v_normal;
144: attribute vec2 a_v_texCoords;
145:
146: attribute vec2 a_i_light;
147: attribute vec4 a_i_color;
148: attribute vec3 a_i_pos;
149: attribute float a_i_speed;
150: attribute float a_i_offset;
151: attribute vec4 a_i_rotation;
152: attribute vec2 a_i_sourceTexture;
153: attribute vec4 a_i_scrollTexture;
154: attribute float a_i_scrollMult;
155:
156:
157: varying vec2 v2f_texCoords;
158: varying vec4 v2f_color;
159: varying float v2f_diffuse;
160: varying vec2 v2f_light;
161:
162:
163: void main() {
164: Vertex v;
165: v.pos = a_v_pos;
166: v.normal = a_v_normal;
167: v.texCoords = a_v_texCoords;
168:
169:
170: Belt i;
171: i.light = a_i_light;
172: i.color = a_i_color;
173: i.pos = a_i_pos;
174: i.speed = a_i_speed;
175: i.offset = a_i_offset;
176: i.rotation = a_i_rotation;
177: i.sourceTexture = a_i_sourceTexture;
178: i.scrollTexture = a_i_scrollTexture;
179: i.scrollMult = a_i_scrollMult;
180:
181:
182: BlockFrag o = FLWMain(v, i);
183:
184: v2f_texCoords = o.texCoords;
185: v2f_color = o.color;
186: v2f_diffuse = o.diffuse;
187: v2f_light = o.light;
188:
189: }
[12:44:36] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:36] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: uniform sampler2D uBlockAtlas;
30: uniform sampler2D uLightMap;
31:
32: vec4 FLWBlockTexture(vec2 texCoords) {
33: return texture2D(uBlockAtlas, texCoords);
34: }
35:
36: void FLWFinalizeColor(vec4 color) {
37: #if defined(USE_FOG)
38: float a = color.a;
39: float fog = clamp(FLWFogFactor(), 0., 1.);
40:
41: color = mix(uFogColor, color, fog);
42: color.a = a;
43: #endif
44:
45: gl_FragColor = color;
46: }
47:
48: vec4 FLWLight(vec2 lightCoords) {
49: return texture2D(uLightMap, shiftLight(lightCoords));
50: }
51:
52:
53:
54: struct BlockFrag {
55: vec2 texCoords;
56: vec4 color;
57: float diffuse;
58: vec2 light;
59: };
60:
61: void FLWMain(BlockFrag r) {
62: vec4 tex = FLWBlockTexture(r.texCoords);
63:
64: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
65:
66: // flw_WorldPos = ;
67: // flw_Normal = ;
68: // flw_Albedo = tex.rgb;
69: // flw_Alpha = tex.a;
70: // flw_LightMap = r.light;
71: // flw_Tint = r.color;
72: FLWFinalizeColor(color);
73: }
74:
75: varying vec2 v2f_texCoords;
76: varying vec4 v2f_color;
77: varying float v2f_diffuse;
78: varying vec2 v2f_light;
79:
80:
81: //vec3 flw_WorldPos;
82: //vec3 flw_Normal;
83: //vec3 flw_Albedo;
84: //float flw_Alpha;
85: //vec2 flw_LightMap;
86: //vec4 flw_Tint;
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:44:37] [main/INFO]: Loading context 'create:context/contraption'
[12:44:37] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:44:37] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: mat4 rotate(vec3 axis, float angle) {
43: float s = sin(angle);
44: float c = cos(angle);
45: float oc = 1. - c;
46:
47: vec3 sa = axis * s;
48:
49: mat4 mr = mat4(1.);
50: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
51: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
52: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
53:
54: return mr;
55: }
56:
57: mat4 rotation(vec3 rot) {
58: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
59: }
60:
61: mat3 modelToNormal(mat4 mat) {
62: // Discard the edges. This won't be accurate for scaled or skewed matrices,
63: // but we don't have to work with those often.
64: mat3 m;
65: m[0] = mat[0].xyz;
66: m[1] = mat[1].xyz;
67: m[2] = mat[2].xyz;
68: return m;
69: }
70:
71: float diffuse(vec3 normal) {
72: vec3 n2 = normal * normal * vec3(.6, .25, .8);
73: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
74: }
75:
76:
77: struct Rotating {
78: vec2 light;
79: vec4 color;
80: vec3 pos;
81: float speed;
82: float offset;
83: vec3 axis;
84: };
85:
86:
87: struct Vertex {
88: vec3 pos;
89: vec3 normal;
90: vec2 texCoords;
91: };
92:
93: struct BlockFrag {
94: vec2 texCoords;
95: vec4 color;
96: float diffuse;
97: vec2 light;
98: };
99:
100: mat4 kineticRotation(float offset, float speed, vec3 axis) {
101: float degrees = offset + uTime * speed * 3./10.;
102: float angle = fract(degrees / 360.) * PI * 2.;
103:
104: return rotate(axis, angle);
105: }
106:
107: BlockFrag FLWMain(Vertex v, Rotating instance) {
108: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
109:
110: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
111: worldPos += vec4(instance.pos + .5, 0.);
112:
113: vec3 norm = modelToNormal(spin) * v.normal;
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = instance.light;
122:
123: #if defined(DEBUG_RAINBOW)
124: b.color = instance.color;
125: #elif defined(DEBUG_NORMAL)
126: b.color = vec4(norm, 1.);
127: #else
128: b.color = vec4(1.);
129: #endif
130:
131: return b;
132: }
133: attribute vec3 a_v_pos;
134: attribute vec3 a_v_normal;
135: attribute vec2 a_v_texCoords;
136:
137: attribute vec2 a_i_light;
138: attribute vec4 a_i_color;
139: attribute vec3 a_i_pos;
140: attribute float a_i_speed;
141: attribute float a_i_offset;
142: attribute vec3 a_i_axis;
143:
144:
145: varying vec2 v2f_texCoords;
146: varying vec4 v2f_color;
147: varying float v2f_diffuse;
148: varying vec2 v2f_light;
149:
150:
151: void main() {
152: Vertex v;
153: v.pos = a_v_pos;
154: v.normal = a_v_normal;
155: v.texCoords = a_v_texCoords;
156:
157:
158: Rotating i;
159: i.light = a_i_light;
160: i.color = a_i_color;
161: i.pos = a_i_pos;
162: i.speed = a_i_speed;
163: i.offset = a_i_offset;
164: i.axis = a_i_axis;
165:
166:
167: BlockFrag o = FLWMain(v, i);
168:
169: v2f_texCoords = o.texCoords;
170: v2f_color = o.color;
171: v2f_diffuse = o.diffuse;
172: v2f_light = o.light;
173:
174: }
[12:44:37] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:37] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:37] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:44:37] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: mat4 rotate(vec3 axis, float angle) {
43: float s = sin(angle);
44: float c = cos(angle);
45: float oc = 1. - c;
46:
47: vec3 sa = axis * s;
48:
49: mat4 mr = mat4(1.);
50: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
51: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
52: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
53:
54: return mr;
55: }
56:
57: mat4 rotation(vec3 rot) {
58: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
59: }
60:
61: mat3 modelToNormal(mat4 mat) {
62: // Discard the edges. This won't be accurate for scaled or skewed matrices,
63: // but we don't have to work with those often.
64: mat3 m;
65: m[0] = mat[0].xyz;
66: m[1] = mat[1].xyz;
67: m[2] = mat[2].xyz;
68: return m;
69: }
70:
71: float diffuse(vec3 normal) {
72: vec3 n2 = normal * normal * vec3(.6, .25, .8);
73: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
74: }
75:
76:
77: struct Rotating {
78: vec2 light;
79: vec4 color;
80: vec3 pos;
81: float speed;
82: float offset;
83: vec3 axis;
84: };
85:
86:
87: struct Vertex {
88: vec3 pos;
89: vec3 normal;
90: vec2 texCoords;
91: };
92:
93: struct BlockFrag {
94: vec2 texCoords;
95: vec4 color;
96: float diffuse;
97: vec2 light;
98: };
99:
100: mat4 kineticRotation(float offset, float speed, vec3 axis) {
101: float degrees = offset + uTime * speed * 3./10.;
102: float angle = fract(degrees / 360.) * PI * 2.;
103:
104: return rotate(axis, angle);
105: }
106:
107: BlockFrag FLWMain(Vertex v, Rotating instance) {
108: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
109:
110: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
111: worldPos += vec4(instance.pos + .5, 0.);
112:
113: vec3 norm = modelToNormal(spin) * v.normal;
114:
115: FLWFinalizeWorldPos(worldPos);
116: FLWFinalizeNormal(norm);
117:
118: BlockFrag b;
119: b.diffuse = diffuse(norm);
120: b.texCoords = v.texCoords;
121: b.light = instance.light;
122:
123: #if defined(DEBUG_RAINBOW)
124: b.color = instance.color;
125: #elif defined(DEBUG_NORMAL)
126: b.color = vec4(norm, 1.);
127: #else
128: b.color = vec4(1.);
129: #endif
130:
131: return b;
132: }
133: attribute vec3 a_v_pos;
134: attribute vec3 a_v_normal;
135: attribute vec2 a_v_texCoords;
136:
137: attribute vec2 a_i_light;
138: attribute vec4 a_i_color;
139: attribute vec3 a_i_pos;
140: attribute float a_i_speed;
141: attribute float a_i_offset;
142: attribute vec3 a_i_axis;
143:
144:
145: varying vec2 v2f_texCoords;
146: varying vec4 v2f_color;
147: varying float v2f_diffuse;
148: varying vec2 v2f_light;
149:
150:
151: void main() {
152: Vertex v;
153: v.pos = a_v_pos;
154: v.normal = a_v_normal;
155: v.texCoords = a_v_texCoords;
156:
157:
158: Rotating i;
159: i.light = a_i_light;
160: i.color = a_i_color;
161: i.pos = a_i_pos;
162: i.speed = a_i_speed;
163: i.offset = a_i_offset;
164: i.axis = a_i_axis;
165:
166:
167: BlockFrag o = FLWMain(v, i);
168:
169: v2f_texCoords = o.texCoords;
170: v2f_color = o.color;
171: v2f_diffuse = o.diffuse;
172: v2f_light = o.light;
173:
174: }
[12:44:37] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:37] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:37] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:44:37] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: float diffuse(vec3 normal) {
73: vec3 n2 = normal * normal * vec3(.6, .25, .8);
74: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
75: }
76:
77:
78: struct Rotating {
79: vec2 light;
80: vec4 color;
81: vec3 pos;
82: float speed;
83: float offset;
84: vec3 axis;
85: };
86:
87:
88: struct Vertex {
89: vec3 pos;
90: vec3 normal;
91: vec2 texCoords;
92: };
93:
94: struct BlockFrag {
95: vec2 texCoords;
96: vec4 color;
97: float diffuse;
98: vec2 light;
99: };
100:
101: mat4 kineticRotation(float offset, float speed, vec3 axis) {
102: float degrees = offset + uTime * speed * 3./10.;
103: float angle = fract(degrees / 360.) * PI * 2.;
104:
105: return rotate(axis, angle);
106: }
107:
108: BlockFrag FLWMain(Vertex v, Rotating instance) {
109: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
110:
111: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
112: worldPos += vec4(instance.pos + .5, 0.);
113:
114: vec3 norm = modelToNormal(spin) * v.normal;
115:
116: FLWFinalizeWorldPos(worldPos);
117: FLWFinalizeNormal(norm);
118:
119: BlockFrag b;
120: b.diffuse = diffuse(norm);
121: b.texCoords = v.texCoords;
122: b.light = instance.light;
123:
124: #if defined(DEBUG_RAINBOW)
125: b.color = instance.color;
126: #elif defined(DEBUG_NORMAL)
127: b.color = vec4(norm, 1.);
128: #else
129: b.color = vec4(1.);
130: #endif
131:
132: return b;
133: }
134: attribute vec3 a_v_pos;
135: attribute vec3 a_v_normal;
136: attribute vec2 a_v_texCoords;
137:
138: attribute vec2 a_i_light;
139: attribute vec4 a_i_color;
140: attribute vec3 a_i_pos;
141: attribute float a_i_speed;
142: attribute float a_i_offset;
143: attribute vec3 a_i_axis;
144:
145:
146: varying vec2 v2f_texCoords;
147: varying vec4 v2f_color;
148: varying float v2f_diffuse;
149: varying vec2 v2f_light;
150:
151:
152: void main() {
153: Vertex v;
154: v.pos = a_v_pos;
155: v.normal = a_v_normal;
156: v.texCoords = a_v_texCoords;
157:
158:
159: Rotating i;
160: i.light = a_i_light;
161: i.color = a_i_color;
162: i.pos = a_i_pos;
163: i.speed = a_i_speed;
164: i.offset = a_i_offset;
165: i.axis = a_i_axis;
166:
167:
168: BlockFrag o = FLWMain(v, i);
169:
170: v2f_texCoords = o.texCoords;
171: v2f_color = o.color;
172: v2f_diffuse = o.diffuse;
173: v2f_light = o.light;
174:
175: }
[12:44:37] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:37] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:37] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:44:37] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: float diffuse(vec3 normal) {
73: vec3 n2 = normal * normal * vec3(.6, .25, .8);
74: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
75: }
76:
77:
78: struct Rotating {
79: vec2 light;
80: vec4 color;
81: vec3 pos;
82: float speed;
83: float offset;
84: vec3 axis;
85: };
86:
87:
88: struct Vertex {
89: vec3 pos;
90: vec3 normal;
91: vec2 texCoords;
92: };
93:
94: struct BlockFrag {
95: vec2 texCoords;
96: vec4 color;
97: float diffuse;
98: vec2 light;
99: };
100:
101: mat4 kineticRotation(float offset, float speed, vec3 axis) {
102: float degrees = offset + uTime * speed * 3./10.;
103: float angle = fract(degrees / 360.) * PI * 2.;
104:
105: return rotate(axis, angle);
106: }
107:
108: BlockFrag FLWMain(Vertex v, Rotating instance) {
109: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
110:
111: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
112: worldPos += vec4(instance.pos + .5, 0.);
113:
114: vec3 norm = modelToNormal(spin) * v.normal;
115:
116: FLWFinalizeWorldPos(worldPos);
117: FLWFinalizeNormal(norm);
118:
119: BlockFrag b;
120: b.diffuse = diffuse(norm);
121: b.texCoords = v.texCoords;
122: b.light = instance.light;
123:
124: #if defined(DEBUG_RAINBOW)
125: b.color = instance.color;
126: #elif defined(DEBUG_NORMAL)
127: b.color = vec4(norm, 1.);
128: #else
129: b.color = vec4(1.);
130: #endif
131:
132: return b;
133: }
134: attribute vec3 a_v_pos;
135: attribute vec3 a_v_normal;
136: attribute vec2 a_v_texCoords;
137:
138: attribute vec2 a_i_light;
139: attribute vec4 a_i_color;
140: attribute vec3 a_i_pos;
141: attribute float a_i_speed;
142: attribute float a_i_offset;
143: attribute vec3 a_i_axis;
144:
145:
146: varying vec2 v2f_texCoords;
147: varying vec4 v2f_color;
148: varying float v2f_diffuse;
149: varying vec2 v2f_light;
150:
151:
152: void main() {
153: Vertex v;
154: v.pos = a_v_pos;
155: v.normal = a_v_normal;
156: v.texCoords = a_v_texCoords;
157:
158:
159: Rotating i;
160: i.light = a_i_light;
161: i.color = a_i_color;
162: i.pos = a_i_pos;
163: i.speed = a_i_speed;
164: i.offset = a_i_offset;
165: i.axis = a_i_axis;
166:
167:
168: BlockFrag o = FLWMain(v, i);
169:
170: v2f_texCoords = o.texCoords;
171: v2f_color = o.color;
172: v2f_diffuse = o.diffuse;
173: v2f_light = o.light;
174:
175: }
[12:44:37] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:37] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:38] [main/ERROR]: Shader compilation log for create:rotating.vert: No errors.
[12:44:38] [main/ERROR]: Source for shader 'create:rotating.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: float diffuse(vec3 normal) {
71: vec3 n2 = normal * normal * vec3(.6, .25, .8);
72: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
73: }
74:
75:
76: struct Rotating {
77: vec2 light;
78: vec4 color;
79: vec3 pos;
80: float speed;
81: float offset;
82: vec3 axis;
83: };
84:
85:
86: struct Vertex {
87: vec3 pos;
88: vec3 normal;
89: vec2 texCoords;
90: };
91:
92: struct BlockFrag {
93: vec2 texCoords;
94: vec4 color;
95: float diffuse;
96: vec2 light;
97: };
98:
99: mat4 kineticRotation(float offset, float speed, vec3 axis) {
100: float degrees = offset + uTime * speed * 3./10.;
101: float angle = fract(degrees / 360.) * PI * 2.;
102:
103: return rotate(axis, angle);
104: }
105:
106: BlockFrag FLWMain(Vertex v, Rotating instance) {
107: mat4 spin = kineticRotation(instance.offset, instance.speed, instance.axis);
108:
109: vec4 worldPos = spin * vec4(v.pos - .5, 1.);
110: worldPos += vec4(instance.pos + .5, 0.);
111:
112: vec3 norm = modelToNormal(spin) * v.normal;
113:
114: FLWFinalizeWorldPos(worldPos);
115: FLWFinalizeNormal(norm);
116:
117: BlockFrag b;
118: b.diffuse = diffuse(norm);
119: b.texCoords = v.texCoords;
120: b.light = instance.light;
121:
122: #if defined(DEBUG_RAINBOW)
123: b.color = instance.color;
124: #elif defined(DEBUG_NORMAL)
125: b.color = vec4(norm, 1.);
126: #else
127: b.color = vec4(1.);
128: #endif
129:
130: return b;
131: }
132: attribute vec3 a_v_pos;
133: attribute vec3 a_v_normal;
134: attribute vec2 a_v_texCoords;
135:
136: attribute vec2 a_i_light;
137: attribute vec4 a_i_color;
138: attribute vec3 a_i_pos;
139: attribute float a_i_speed;
140: attribute float a_i_offset;
141: attribute vec3 a_i_axis;
142:
143:
144: varying vec2 v2f_texCoords;
145: varying vec4 v2f_color;
146: varying float v2f_diffuse;
147: varying vec2 v2f_light;
148:
149:
150: void main() {
151: Vertex v;
152: v.pos = a_v_pos;
153: v.normal = a_v_normal;
154: v.texCoords = a_v_texCoords;
155:
156:
157: Rotating i;
158: i.light = a_i_light;
159: i.color = a_i_color;
160: i.pos = a_i_pos;
161: i.speed = a_i_speed;
162: i.offset = a_i_offset;
163: i.axis = a_i_axis;
164:
165:
166: BlockFrag o = FLWMain(v, i);
167:
168: v2f_texCoords = o.texCoords;
169: v2f_color = o.color;
170: v2f_diffuse = o.diffuse;
171: v2f_light = o.light;
172:
173: }
[12:44:38] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:38] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:44:38] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:44:38] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: mat4 rotate(vec3 axis, float angle) {
43: float s = sin(angle);
44: float c = cos(angle);
45: float oc = 1. - c;
46:
47: vec3 sa = axis * s;
48:
49: mat4 mr = mat4(1.);
50: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
51: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
52: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
53:
54: return mr;
55: }
56:
57: mat4 rotation(vec3 rot) {
58: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
59: }
60:
61: mat3 modelToNormal(mat4 mat) {
62: // Discard the edges. This won't be accurate for scaled or skewed matrices,
63: // but we don't have to work with those often.
64: mat3 m;
65: m[0] = mat[0].xyz;
66: m[1] = mat[1].xyz;
67: m[2] = mat[2].xyz;
68: return m;
69: }
70:
71: #define PIOVER2 1.5707963268
72:
73: vec4 quat(vec3 axis, float angle) {
74: float halfAngle = angle * PIOVER2 / 180.0;
75: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
76: return vec4(axis.xyz * cs.y, cs.x);
77: }
78:
79: vec4 quatMult(vec4 q1, vec4 q2) {
80: // disgustingly vectorized quaternion multiplication
81: vec4 a = q1.w * q2.xyzw;
82: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
83: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
84: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
85:
86: return a + b + c + d;
87: }
88:
89: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
90: vec3 i = q.xyz;
91: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
92: }
93:
94: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
95: return rotateVertexByQuat(v, quat(axis, angle));
96: }
97:
98: float diffuse(vec3 normal) {
99: vec3 n2 = normal * normal * vec3(.6, .25, .8);
100: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
101: }
102:
103:
104: struct Actor {
105: vec3 pos;
106: vec2 light;
107: float offset;
108: vec3 axis;
109: vec4 rotation;
110: vec3 rotationCenter;
111: float speed;
112: };
113:
114:
115: struct Vertex {
116: vec3 pos;
117: vec3 normal;
118: vec2 texCoords;
119: };
120:
121: struct BlockFrag {
122: vec2 texCoords;
123: vec4 color;
124: float diffuse;
125: vec2 light;
126: };
127:
128: BlockFrag FLWMain(Vertex v, Actor instance) {
129: float degrees = instance.offset + uTime * instance.speed / 20.;
130: //float angle = fract(degrees / 360.) * PI * 2.;
131:
132: vec4 kineticRot = quat(instance.axis, degrees);
133: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
134:
135: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
136: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
137:
138: FLWFinalizeWorldPos(worldPos);
139: FLWFinalizeNormal(norm);
140:
141: BlockFrag b;
142: b.diffuse = diffuse(norm);
143: b.texCoords = v.texCoords;
144: b.light = instance.light;
145:
146: #if defined(DEBUG_NORMAL)
147: b.color = vec4(norm, 1.);
148: #else
149: b.color = vec4(1.);
150: #endif
151:
152: return b;
153: }
154: attribute vec3 a_v_pos;
155: attribute vec3 a_v_normal;
156: attribute vec2 a_v_texCoords;
157:
158: attribute vec3 a_i_pos;
159: attribute vec2 a_i_light;
160: attribute float a_i_offset;
161: attribute vec3 a_i_axis;
162: attribute vec4 a_i_rotation;
163: attribute vec3 a_i_rotationCenter;
164: attribute float a_i_speed;
165:
166:
167: varying vec2 v2f_texCoords;
168: varying vec4 v2f_color;
169: varying float v2f_diffuse;
170: varying vec2 v2f_light;
171:
172:
173: void main() {
174: Vertex v;
175: v.pos = a_v_pos;
176: v.normal = a_v_normal;
177: v.texCoords = a_v_texCoords;
178:
179:
180: Actor i;
181: i.pos = a_i_pos;
182: i.light = a_i_light;
183: i.offset = a_i_offset;
184: i.axis = a_i_axis;
185: i.rotation = a_i_rotation;
186: i.rotationCenter = a_i_rotationCenter;
187: i.speed = a_i_speed;
188:
189:
190: BlockFrag o = FLWMain(v, i);
191:
192: v2f_texCoords = o.texCoords;
193: v2f_color = o.color;
194: v2f_diffuse = o.diffuse;
195: v2f_light = o.light;
196:
197: }
[12:44:38] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:38] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:38] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:44:38] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: #define PIOVER2 1.5707963268
73:
74: vec4 quat(vec3 axis, float angle) {
75: float halfAngle = angle * PIOVER2 / 180.0;
76: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
77: return vec4(axis.xyz * cs.y, cs.x);
78: }
79:
80: vec4 quatMult(vec4 q1, vec4 q2) {
81: // disgustingly vectorized quaternion multiplication
82: vec4 a = q1.w * q2.xyzw;
83: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
84: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
85: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
86:
87: return a + b + c + d;
88: }
89:
90: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
91: vec3 i = q.xyz;
92: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
93: }
94:
95: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
96: return rotateVertexByQuat(v, quat(axis, angle));
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Actor {
106: vec3 pos;
107: vec2 light;
108: float offset;
109: vec3 axis;
110: vec4 rotation;
111: vec3 rotationCenter;
112: float speed;
113: };
114:
115:
116: struct Vertex {
117: vec3 pos;
118: vec3 normal;
119: vec2 texCoords;
120: };
121:
122: struct BlockFrag {
123: vec2 texCoords;
124: vec4 color;
125: float diffuse;
126: vec2 light;
127: };
128:
129: BlockFrag FLWMain(Vertex v, Actor instance) {
130: float degrees = instance.offset + uTime * instance.speed / 20.;
131: //float angle = fract(degrees / 360.) * PI * 2.;
132:
133: vec4 kineticRot = quat(instance.axis, degrees);
134: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
135:
136: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
137: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
138:
139: FLWFinalizeWorldPos(worldPos);
140: FLWFinalizeNormal(norm);
141:
142: BlockFrag b;
143: b.diffuse = diffuse(norm);
144: b.texCoords = v.texCoords;
145: b.light = instance.light;
146:
147: #if defined(DEBUG_NORMAL)
148: b.color = vec4(norm, 1.);
149: #else
150: b.color = vec4(1.);
151: #endif
152:
153: return b;
154: }
155: attribute vec3 a_v_pos;
156: attribute vec3 a_v_normal;
157: attribute vec2 a_v_texCoords;
158:
159: attribute vec3 a_i_pos;
160: attribute vec2 a_i_light;
161: attribute float a_i_offset;
162: attribute vec3 a_i_axis;
163: attribute vec4 a_i_rotation;
164: attribute vec3 a_i_rotationCenter;
165: attribute float a_i_speed;
166:
167:
168: varying vec2 v2f_texCoords;
169: varying vec4 v2f_color;
170: varying float v2f_diffuse;
171: varying vec2 v2f_light;
172:
173:
174: void main() {
175: Vertex v;
176: v.pos = a_v_pos;
177: v.normal = a_v_normal;
178: v.texCoords = a_v_texCoords;
179:
180:
181: Actor i;
182: i.pos = a_i_pos;
183: i.light = a_i_light;
184: i.offset = a_i_offset;
185: i.axis = a_i_axis;
186: i.rotation = a_i_rotation;
187: i.rotationCenter = a_i_rotationCenter;
188: i.speed = a_i_speed;
189:
190:
191: BlockFrag o = FLWMain(v, i);
192:
193: v2f_texCoords = o.texCoords;
194: v2f_color = o.color;
195: v2f_diffuse = o.diffuse;
196: v2f_light = o.light;
197:
198: }
[12:44:39] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:39] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:39] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:44:39] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: #define PIOVER2 1.5707963268
73:
74: vec4 quat(vec3 axis, float angle) {
75: float halfAngle = angle * PIOVER2 / 180.0;
76: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
77: return vec4(axis.xyz * cs.y, cs.x);
78: }
79:
80: vec4 quatMult(vec4 q1, vec4 q2) {
81: // disgustingly vectorized quaternion multiplication
82: vec4 a = q1.w * q2.xyzw;
83: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
84: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
85: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
86:
87: return a + b + c + d;
88: }
89:
90: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
91: vec3 i = q.xyz;
92: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
93: }
94:
95: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
96: return rotateVertexByQuat(v, quat(axis, angle));
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Actor {
106: vec3 pos;
107: vec2 light;
108: float offset;
109: vec3 axis;
110: vec4 rotation;
111: vec3 rotationCenter;
112: float speed;
113: };
114:
115:
116: struct Vertex {
117: vec3 pos;
118: vec3 normal;
119: vec2 texCoords;
120: };
121:
122: struct BlockFrag {
123: vec2 texCoords;
124: vec4 color;
125: float diffuse;
126: vec2 light;
127: };
128:
129: BlockFrag FLWMain(Vertex v, Actor instance) {
130: float degrees = instance.offset + uTime * instance.speed / 20.;
131: //float angle = fract(degrees / 360.) * PI * 2.;
132:
133: vec4 kineticRot = quat(instance.axis, degrees);
134: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
135:
136: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
137: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
138:
139: FLWFinalizeWorldPos(worldPos);
140: FLWFinalizeNormal(norm);
141:
142: BlockFrag b;
143: b.diffuse = diffuse(norm);
144: b.texCoords = v.texCoords;
145: b.light = instance.light;
146:
147: #if defined(DEBUG_NORMAL)
148: b.color = vec4(norm, 1.);
149: #else
150: b.color = vec4(1.);
151: #endif
152:
153: return b;
154: }
155: attribute vec3 a_v_pos;
156: attribute vec3 a_v_normal;
157: attribute vec2 a_v_texCoords;
158:
159: attribute vec3 a_i_pos;
160: attribute vec2 a_i_light;
161: attribute float a_i_offset;
162: attribute vec3 a_i_axis;
163: attribute vec4 a_i_rotation;
164: attribute vec3 a_i_rotationCenter;
165: attribute float a_i_speed;
166:
167:
168: varying vec2 v2f_texCoords;
169: varying vec4 v2f_color;
170: varying float v2f_diffuse;
171: varying vec2 v2f_light;
172:
173:
174: void main() {
175: Vertex v;
176: v.pos = a_v_pos;
177: v.normal = a_v_normal;
178: v.texCoords = a_v_texCoords;
179:
180:
181: Actor i;
182: i.pos = a_i_pos;
183: i.light = a_i_light;
184: i.offset = a_i_offset;
185: i.axis = a_i_axis;
186: i.rotation = a_i_rotation;
187: i.rotationCenter = a_i_rotationCenter;
188: i.speed = a_i_speed;
189:
190:
191: BlockFrag o = FLWMain(v, i);
192:
193: v2f_texCoords = o.texCoords;
194: v2f_color = o.color;
195: v2f_diffuse = o.diffuse;
196: v2f_light = o.light;
197:
198: }
[12:44:39] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:39] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:39] [main/ERROR]: Shader compilation log for create:contraption_actor.vert: No errors.
[12:44:39] [main/ERROR]: Source for shader 'create:contraption_actor.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: #define PIOVER2 1.5707963268
71:
72: vec4 quat(vec3 axis, float angle) {
73: float halfAngle = angle * PIOVER2 / 180.0;
74: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
75: return vec4(axis.xyz * cs.y, cs.x);
76: }
77:
78: vec4 quatMult(vec4 q1, vec4 q2) {
79: // disgustingly vectorized quaternion multiplication
80: vec4 a = q1.w * q2.xyzw;
81: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
82: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
83: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
84:
85: return a + b + c + d;
86: }
87:
88: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
89: vec3 i = q.xyz;
90: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
91: }
92:
93: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
94: return rotateVertexByQuat(v, quat(axis, angle));
95: }
96:
97: float diffuse(vec3 normal) {
98: vec3 n2 = normal * normal * vec3(.6, .25, .8);
99: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
100: }
101:
102:
103: struct Actor {
104: vec3 pos;
105: vec2 light;
106: float offset;
107: vec3 axis;
108: vec4 rotation;
109: vec3 rotationCenter;
110: float speed;
111: };
112:
113:
114: struct Vertex {
115: vec3 pos;
116: vec3 normal;
117: vec2 texCoords;
118: };
119:
120: struct BlockFrag {
121: vec2 texCoords;
122: vec4 color;
123: float diffuse;
124: vec2 light;
125: };
126:
127: BlockFrag FLWMain(Vertex v, Actor instance) {
128: float degrees = instance.offset + uTime * instance.speed / 20.;
129: //float angle = fract(degrees / 360.) * PI * 2.;
130:
131: vec4 kineticRot = quat(instance.axis, degrees);
132: vec3 rotated = rotateVertexByQuat(v.pos - instance.rotationCenter, kineticRot) + instance.rotationCenter;
133:
134: vec4 worldPos = vec4(rotateVertexByQuat(rotated - .5, instance.rotation) + instance.pos + .5, 1.);
135: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, kineticRot), instance.rotation);
136:
137: FLWFinalizeWorldPos(worldPos);
138: FLWFinalizeNormal(norm);
139:
140: BlockFrag b;
141: b.diffuse = diffuse(norm);
142: b.texCoords = v.texCoords;
143: b.light = instance.light;
144:
145: #if defined(DEBUG_NORMAL)
146: b.color = vec4(norm, 1.);
147: #else
148: b.color = vec4(1.);
149: #endif
150:
151: return b;
152: }
153: attribute vec3 a_v_pos;
154: attribute vec3 a_v_normal;
155: attribute vec2 a_v_texCoords;
156:
157: attribute vec3 a_i_pos;
158: attribute vec2 a_i_light;
159: attribute float a_i_offset;
160: attribute vec3 a_i_axis;
161: attribute vec4 a_i_rotation;
162: attribute vec3 a_i_rotationCenter;
163: attribute float a_i_speed;
164:
165:
166: varying vec2 v2f_texCoords;
167: varying vec4 v2f_color;
168: varying float v2f_diffuse;
169: varying vec2 v2f_light;
170:
171:
172: void main() {
173: Vertex v;
174: v.pos = a_v_pos;
175: v.normal = a_v_normal;
176: v.texCoords = a_v_texCoords;
177:
178:
179: Actor i;
180: i.pos = a_i_pos;
181: i.light = a_i_light;
182: i.offset = a_i_offset;
183: i.axis = a_i_axis;
184: i.rotation = a_i_rotation;
185: i.rotationCenter = a_i_rotationCenter;
186: i.speed = a_i_speed;
187:
188:
189: BlockFrag o = FLWMain(v, i);
190:
191: v2f_texCoords = o.texCoords;
192: v2f_color = o.color;
193: v2f_diffuse = o.diffuse;
194: v2f_light = o.light;
195:
196: }
[12:44:39] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:39] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:44:39] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:44:39] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: mat4 rotate(vec3 axis, float angle) {
43: float s = sin(angle);
44: float c = cos(angle);
45: float oc = 1. - c;
46:
47: vec3 sa = axis * s;
48:
49: mat4 mr = mat4(1.);
50: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
51: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
52: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
53:
54: return mr;
55: }
56:
57: mat4 rotation(vec3 rot) {
58: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
59: }
60:
61: mat3 modelToNormal(mat4 mat) {
62: // Discard the edges. This won't be accurate for scaled or skewed matrices,
63: // but we don't have to work with those often.
64: mat3 m;
65: m[0] = mat[0].xyz;
66: m[1] = mat[1].xyz;
67: m[2] = mat[2].xyz;
68: return m;
69: }
70:
71: #define PIOVER2 1.5707963268
72:
73: vec4 quat(vec3 axis, float angle) {
74: float halfAngle = angle * PIOVER2 / 180.0;
75: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
76: return vec4(axis.xyz * cs.y, cs.x);
77: }
78:
79: vec4 quatMult(vec4 q1, vec4 q2) {
80: // disgustingly vectorized quaternion multiplication
81: vec4 a = q1.w * q2.xyzw;
82: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
83: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
84: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
85:
86: return a + b + c + d;
87: }
88:
89: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
90: vec3 i = q.xyz;
91: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
92: }
93:
94: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
95: return rotateVertexByQuat(v, quat(axis, angle));
96: }
97:
98: float diffuse(vec3 normal) {
99: vec3 n2 = normal * normal * vec3(.6, .25, .8);
100: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
101: }
102:
103:
104: struct Flap {
105: vec3 instancePos;
106: vec2 light;
107: vec3 segmentOffset;
108: vec3 pivot;
109: float horizontalAngle;
110: float intensity;
111: float flapScale;
112: float flapness;
113: };
114:
115:
116: struct Vertex {
117: vec3 pos;
118: vec3 normal;
119: vec2 texCoords;
120: };
121:
122: struct BlockFrag {
123: vec2 texCoords;
124: vec4 color;
125: float diffuse;
126: vec2 light;
127: };
128:
129:
130: float toRad(float degrees) {
131: return fract(degrees / 360.) * PI * 2.;
132: }
133:
134: float getFlapAngle(float flapness, float intensity, float scale) {
135: float absFlap = abs(flapness);
136:
137: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
138:
139: float halfAngle = angle * 0.5;
140:
141: float which = step(0., flapness);// 0 if negative, 1 if positive
142: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
143:
144: return degrees;
145: }
146:
147: BlockFrag FLWMain(Vertex v, Flap flap) {
148: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
149:
150: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
151: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
152:
153: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
154: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
155:
156: vec4 worldPos = vec4(rotated, 1.);
157: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
158:
159: FLWFinalizeWorldPos(worldPos);
160: FLWFinalizeNormal(norm);
161:
162: BlockFrag b;
163: b.diffuse = diffuse(norm);
164: b.texCoords = v.texCoords;
165: b.light = flap.light;
166: #if defined(DEBUG_NORMAL)
167: b.color = vec4(norm, 1.);
168: #else
169: b.color = vec4(1.);
170: #endif
171: return b;
172: }
173: attribute vec3 a_v_pos;
174: attribute vec3 a_v_normal;
175: attribute vec2 a_v_texCoords;
176:
177: attribute vec3 a_i_instancePos;
178: attribute vec2 a_i_light;
179: attribute vec3 a_i_segmentOffset;
180: attribute vec3 a_i_pivot;
181: attribute float a_i_horizontalAngle;
182: attribute float a_i_intensity;
183: attribute float a_i_flapScale;
184: attribute float a_i_flapness;
185:
186:
187: varying vec2 v2f_texCoords;
188: varying vec4 v2f_color;
189: varying float v2f_diffuse;
190: varying vec2 v2f_light;
191:
192:
193: void main() {
194: Vertex v;
195: v.pos = a_v_pos;
196: v.normal = a_v_normal;
197: v.texCoords = a_v_texCoords;
198:
199:
200: Flap i;
201: i.instancePos = a_i_instancePos;
202: i.light = a_i_light;
203: i.segmentOffset = a_i_segmentOffset;
204: i.pivot = a_i_pivot;
205: i.horizontalAngle = a_i_horizontalAngle;
206: i.intensity = a_i_intensity;
207: i.flapScale = a_i_flapScale;
208: i.flapness = a_i_flapness;
209:
210:
211: BlockFrag o = FLWMain(v, i);
212:
213: v2f_texCoords = o.texCoords;
214: v2f_color = o.color;
215: v2f_diffuse = o.diffuse;
216: v2f_light = o.light;
217:
218: }
[12:44:39] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:39] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:40] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:44:40] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: #define PIOVER2 1.5707963268
73:
74: vec4 quat(vec3 axis, float angle) {
75: float halfAngle = angle * PIOVER2 / 180.0;
76: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
77: return vec4(axis.xyz * cs.y, cs.x);
78: }
79:
80: vec4 quatMult(vec4 q1, vec4 q2) {
81: // disgustingly vectorized quaternion multiplication
82: vec4 a = q1.w * q2.xyzw;
83: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
84: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
85: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
86:
87: return a + b + c + d;
88: }
89:
90: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
91: vec3 i = q.xyz;
92: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
93: }
94:
95: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
96: return rotateVertexByQuat(v, quat(axis, angle));
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Flap {
106: vec3 instancePos;
107: vec2 light;
108: vec3 segmentOffset;
109: vec3 pivot;
110: float horizontalAngle;
111: float intensity;
112: float flapScale;
113: float flapness;
114: };
115:
116:
117: struct Vertex {
118: vec3 pos;
119: vec3 normal;
120: vec2 texCoords;
121: };
122:
123: struct BlockFrag {
124: vec2 texCoords;
125: vec4 color;
126: float diffuse;
127: vec2 light;
128: };
129:
130:
131: float toRad(float degrees) {
132: return fract(degrees / 360.) * PI * 2.;
133: }
134:
135: float getFlapAngle(float flapness, float intensity, float scale) {
136: float absFlap = abs(flapness);
137:
138: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
139:
140: float halfAngle = angle * 0.5;
141:
142: float which = step(0., flapness);// 0 if negative, 1 if positive
143: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
144:
145: return degrees;
146: }
147:
148: BlockFrag FLWMain(Vertex v, Flap flap) {
149: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
150:
151: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
152: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
153:
154: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
155: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
156:
157: vec4 worldPos = vec4(rotated, 1.);
158: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
159:
160: FLWFinalizeWorldPos(worldPos);
161: FLWFinalizeNormal(norm);
162:
163: BlockFrag b;
164: b.diffuse = diffuse(norm);
165: b.texCoords = v.texCoords;
166: b.light = flap.light;
167: #if defined(DEBUG_NORMAL)
168: b.color = vec4(norm, 1.);
169: #else
170: b.color = vec4(1.);
171: #endif
172: return b;
173: }
174: attribute vec3 a_v_pos;
175: attribute vec3 a_v_normal;
176: attribute vec2 a_v_texCoords;
177:
178: attribute vec3 a_i_instancePos;
179: attribute vec2 a_i_light;
180: attribute vec3 a_i_segmentOffset;
181: attribute vec3 a_i_pivot;
182: attribute float a_i_horizontalAngle;
183: attribute float a_i_intensity;
184: attribute float a_i_flapScale;
185: attribute float a_i_flapness;
186:
187:
188: varying vec2 v2f_texCoords;
189: varying vec4 v2f_color;
190: varying float v2f_diffuse;
191: varying vec2 v2f_light;
192:
193:
194: void main() {
195: Vertex v;
196: v.pos = a_v_pos;
197: v.normal = a_v_normal;
198: v.texCoords = a_v_texCoords;
199:
200:
201: Flap i;
202: i.instancePos = a_i_instancePos;
203: i.light = a_i_light;
204: i.segmentOffset = a_i_segmentOffset;
205: i.pivot = a_i_pivot;
206: i.horizontalAngle = a_i_horizontalAngle;
207: i.intensity = a_i_intensity;
208: i.flapScale = a_i_flapScale;
209: i.flapness = a_i_flapness;
210:
211:
212: BlockFrag o = FLWMain(v, i);
213:
214: v2f_texCoords = o.texCoords;
215: v2f_color = o.color;
216: v2f_diffuse = o.diffuse;
217: v2f_light = o.light;
218:
219: }
[12:44:40] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:40] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:40] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:44:40] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: #define PIOVER2 1.5707963268
73:
74: vec4 quat(vec3 axis, float angle) {
75: float halfAngle = angle * PIOVER2 / 180.0;
76: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
77: return vec4(axis.xyz * cs.y, cs.x);
78: }
79:
80: vec4 quatMult(vec4 q1, vec4 q2) {
81: // disgustingly vectorized quaternion multiplication
82: vec4 a = q1.w * q2.xyzw;
83: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
84: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
85: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
86:
87: return a + b + c + d;
88: }
89:
90: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
91: vec3 i = q.xyz;
92: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
93: }
94:
95: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
96: return rotateVertexByQuat(v, quat(axis, angle));
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Flap {
106: vec3 instancePos;
107: vec2 light;
108: vec3 segmentOffset;
109: vec3 pivot;
110: float horizontalAngle;
111: float intensity;
112: float flapScale;
113: float flapness;
114: };
115:
116:
117: struct Vertex {
118: vec3 pos;
119: vec3 normal;
120: vec2 texCoords;
121: };
122:
123: struct BlockFrag {
124: vec2 texCoords;
125: vec4 color;
126: float diffuse;
127: vec2 light;
128: };
129:
130:
131: float toRad(float degrees) {
132: return fract(degrees / 360.) * PI * 2.;
133: }
134:
135: float getFlapAngle(float flapness, float intensity, float scale) {
136: float absFlap = abs(flapness);
137:
138: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
139:
140: float halfAngle = angle * 0.5;
141:
142: float which = step(0., flapness);// 0 if negative, 1 if positive
143: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
144:
145: return degrees;
146: }
147:
148: BlockFrag FLWMain(Vertex v, Flap flap) {
149: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
150:
151: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
152: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
153:
154: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
155: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
156:
157: vec4 worldPos = vec4(rotated, 1.);
158: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
159:
160: FLWFinalizeWorldPos(worldPos);
161: FLWFinalizeNormal(norm);
162:
163: BlockFrag b;
164: b.diffuse = diffuse(norm);
165: b.texCoords = v.texCoords;
166: b.light = flap.light;
167: #if defined(DEBUG_NORMAL)
168: b.color = vec4(norm, 1.);
169: #else
170: b.color = vec4(1.);
171: #endif
172: return b;
173: }
174: attribute vec3 a_v_pos;
175: attribute vec3 a_v_normal;
176: attribute vec2 a_v_texCoords;
177:
178: attribute vec3 a_i_instancePos;
179: attribute vec2 a_i_light;
180: attribute vec3 a_i_segmentOffset;
181: attribute vec3 a_i_pivot;
182: attribute float a_i_horizontalAngle;
183: attribute float a_i_intensity;
184: attribute float a_i_flapScale;
185: attribute float a_i_flapness;
186:
187:
188: varying vec2 v2f_texCoords;
189: varying vec4 v2f_color;
190: varying float v2f_diffuse;
191: varying vec2 v2f_light;
192:
193:
194: void main() {
195: Vertex v;
196: v.pos = a_v_pos;
197: v.normal = a_v_normal;
198: v.texCoords = a_v_texCoords;
199:
200:
201: Flap i;
202: i.instancePos = a_i_instancePos;
203: i.light = a_i_light;
204: i.segmentOffset = a_i_segmentOffset;
205: i.pivot = a_i_pivot;
206: i.horizontalAngle = a_i_horizontalAngle;
207: i.intensity = a_i_intensity;
208: i.flapScale = a_i_flapScale;
209: i.flapness = a_i_flapness;
210:
211:
212: BlockFrag o = FLWMain(v, i);
213:
214: v2f_texCoords = o.texCoords;
215: v2f_color = o.color;
216: v2f_diffuse = o.diffuse;
217: v2f_light = o.light;
218:
219: }
[12:44:40] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:40] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:40] [main/ERROR]: Shader compilation log for create:flap.vert: No errors.
[12:44:40] [main/ERROR]: Source for shader 'create:flap.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: #define PIOVER2 1.5707963268
71:
72: vec4 quat(vec3 axis, float angle) {
73: float halfAngle = angle * PIOVER2 / 180.0;
74: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
75: return vec4(axis.xyz * cs.y, cs.x);
76: }
77:
78: vec4 quatMult(vec4 q1, vec4 q2) {
79: // disgustingly vectorized quaternion multiplication
80: vec4 a = q1.w * q2.xyzw;
81: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
82: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
83: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
84:
85: return a + b + c + d;
86: }
87:
88: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
89: vec3 i = q.xyz;
90: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
91: }
92:
93: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
94: return rotateVertexByQuat(v, quat(axis, angle));
95: }
96:
97: float diffuse(vec3 normal) {
98: vec3 n2 = normal * normal * vec3(.6, .25, .8);
99: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
100: }
101:
102:
103: struct Flap {
104: vec3 instancePos;
105: vec2 light;
106: vec3 segmentOffset;
107: vec3 pivot;
108: float horizontalAngle;
109: float intensity;
110: float flapScale;
111: float flapness;
112: };
113:
114:
115: struct Vertex {
116: vec3 pos;
117: vec3 normal;
118: vec2 texCoords;
119: };
120:
121: struct BlockFrag {
122: vec2 texCoords;
123: vec4 color;
124: float diffuse;
125: vec2 light;
126: };
127:
128:
129: float toRad(float degrees) {
130: return fract(degrees / 360.) * PI * 2.;
131: }
132:
133: float getFlapAngle(float flapness, float intensity, float scale) {
134: float absFlap = abs(flapness);
135:
136: float angle = sin((1. - absFlap) * PI * intensity) * 30. * flapness * scale;
137:
138: float halfAngle = angle * 0.5;
139:
140: float which = step(0., flapness);// 0 if negative, 1 if positive
141: float degrees = which * halfAngle + (1. - which) * angle;// branchless conditional multiply
142:
143: return degrees;
144: }
145:
146: BlockFrag FLWMain(Vertex v, Flap flap) {
147: float flapAngle = getFlapAngle(flap.flapness, flap.intensity, flap.flapScale);
148:
149: vec4 orientation = quat(vec3(0., 1., 0.), -flap.horizontalAngle);
150: vec4 flapRotation = quat(vec3(1., 0., 0.), flapAngle);
151:
152: vec3 rotated = rotateVertexByQuat(v.pos - flap.pivot, flapRotation) + flap.pivot + flap.segmentOffset;
153: rotated = rotateVertexByQuat(rotated - .5, orientation) + flap.instancePos + .5;
154:
155: vec4 worldPos = vec4(rotated, 1.);
156: vec3 norm = rotateVertexByQuat(rotateVertexByQuat(v.normal, flapRotation), orientation);
157:
158: FLWFinalizeWorldPos(worldPos);
159: FLWFinalizeNormal(norm);
160:
161: BlockFrag b;
162: b.diffuse = diffuse(norm);
163: b.texCoords = v.texCoords;
164: b.light = flap.light;
165: #if defined(DEBUG_NORMAL)
166: b.color = vec4(norm, 1.);
167: #else
168: b.color = vec4(1.);
169: #endif
170: return b;
171: }
172: attribute vec3 a_v_pos;
173: attribute vec3 a_v_normal;
174: attribute vec2 a_v_texCoords;
175:
176: attribute vec3 a_i_instancePos;
177: attribute vec2 a_i_light;
178: attribute vec3 a_i_segmentOffset;
179: attribute vec3 a_i_pivot;
180: attribute float a_i_horizontalAngle;
181: attribute float a_i_intensity;
182: attribute float a_i_flapScale;
183: attribute float a_i_flapness;
184:
185:
186: varying vec2 v2f_texCoords;
187: varying vec4 v2f_color;
188: varying float v2f_diffuse;
189: varying vec2 v2f_light;
190:
191:
192: void main() {
193: Vertex v;
194: v.pos = a_v_pos;
195: v.normal = a_v_normal;
196: v.texCoords = a_v_texCoords;
197:
198:
199: Flap i;
200: i.instancePos = a_i_instancePos;
201: i.light = a_i_light;
202: i.segmentOffset = a_i_segmentOffset;
203: i.pivot = a_i_pivot;
204: i.horizontalAngle = a_i_horizontalAngle;
205: i.intensity = a_i_intensity;
206: i.flapScale = a_i_flapScale;
207: i.flapness = a_i_flapness;
208:
209:
210: BlockFrag o = FLWMain(v, i);
211:
212: v2f_texCoords = o.texCoords;
213: v2f_color = o.color;
214: v2f_diffuse = o.diffuse;
215: v2f_light = o.light;
216:
217: }
[12:44:40] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:40] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:44:40] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:40] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: #endif
7:
8: varying vec3 BoxCoord;
9:
10: uniform vec3 uLightBoxSize;
11: uniform vec3 uLightBoxMin;
12: uniform mat4 uModel;
13:
14: uniform float uTime;
15: uniform mat4 uViewProjection;
16: uniform vec3 uCameraPos;
17:
18: void FLWFinalizeWorldPos(inout vec4 worldPos) {
19: worldPos = uModel * worldPos;
20:
21: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
22:
23: #if defined(USE_FOG)
24: FragDistance = length(worldPos.xyz);
25: #endif
26:
27: gl_Position = uViewProjection * worldPos;
28: }
29:
30: void FLWFinalizeNormal(inout vec3 normal) {
31: mat3 m;
32: m[0] = uModel[0].xyz;
33: m[1] = uModel[1].xyz;
34: m[2] = uModel[2].xyz;
35: normal = m * normal;
36: }
37:
38:
39:
40: mat4 rotate(vec3 axis, float angle) {
41: float s = sin(angle);
42: float c = cos(angle);
43: float oc = 1. - c;
44:
45: vec3 sa = axis * s;
46:
47: mat4 mr = mat4(1.);
48: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
49: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
50: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
51:
52: return mr;
53: }
54:
55: mat4 rotation(vec3 rot) {
56: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
57: }
58:
59: mat3 modelToNormal(mat4 mat) {
60: // Discard the edges. This won't be accurate for scaled or skewed matrices,
61: // but we don't have to work with those often.
62: mat3 m;
63: m[0] = mat[0].xyz;
64: m[1] = mat[1].xyz;
65: m[2] = mat[2].xyz;
66: return m;
67: }
68:
69: #define PIOVER2 1.5707963268
70:
71: vec4 quat(vec3 axis, float angle) {
72: float halfAngle = angle * PIOVER2 / 180.0;
73: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
74: return vec4(axis.xyz * cs.y, cs.x);
75: }
76:
77: vec4 quatMult(vec4 q1, vec4 q2) {
78: // disgustingly vectorized quaternion multiplication
79: vec4 a = q1.w * q2.xyzw;
80: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
81: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
82: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
83:
84: return a + b + c + d;
85: }
86:
87: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
88: vec3 i = q.xyz;
89: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
90: }
91:
92: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
93: return rotateVertexByQuat(v, quat(axis, angle));
94: }
95:
96: float diffuse(vec3 normal) {
97: vec3 n2 = normal * normal * vec3(.6, .25, .8);
98: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
99: }
100:
101:
102: struct Oriented {
103: vec2 light;
104: vec4 color;
105: vec3 pos;
106: vec3 pivot;
107: vec4 rotation;
108: };
109:
110:
111: struct Vertex {
112: vec3 pos;
113: vec3 normal;
114: vec2 texCoords;
115: };
116:
117: struct BlockFrag {
118: vec2 texCoords;
119: vec4 color;
120: float diffuse;
121: vec2 light;
122: };
123:
124: BlockFrag FLWMain(Vertex v, Oriented o) {
125: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
126:
127: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
128:
129: FLWFinalizeWorldPos(worldPos);
130: FLWFinalizeNormal(norm);
131:
132: BlockFrag b;
133: b.diffuse = diffuse(norm);
134: b.texCoords = v.texCoords;
135: b.light = o.light;
136: #if defined(DEBUG_NORMAL)
137: b.color = vec4(norm, 1.);
138: #else
139: b.color = o.color;
140: #endif
141: return b;
142: }
143: attribute vec3 a_v_pos;
144: attribute vec3 a_v_normal;
145: attribute vec2 a_v_texCoords;
146:
147: attribute vec2 a_i_light;
148: attribute vec4 a_i_color;
149: attribute vec3 a_i_pos;
150: attribute vec3 a_i_pivot;
151: attribute vec4 a_i_rotation;
152:
153:
154: varying vec2 v2f_texCoords;
155: varying vec4 v2f_color;
156: varying float v2f_diffuse;
157: varying vec2 v2f_light;
158:
159:
160: void main() {
161: Vertex v;
162: v.pos = a_v_pos;
163: v.normal = a_v_normal;
164: v.texCoords = a_v_texCoords;
165:
166:
167: Oriented i;
168: i.light = a_i_light;
169: i.color = a_i_color;
170: i.pos = a_i_pos;
171: i.pivot = a_i_pivot;
172: i.rotation = a_i_rotation;
173:
174:
175: BlockFrag o = FLWMain(v, i);
176:
177: v2f_texCoords = o.texCoords;
178: v2f_color = o.color;
179: v2f_diffuse = o.diffuse;
180: v2f_light = o.light;
181:
182: }
[12:44:41] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:41] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:41] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:41] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: #define PIOVER2 1.5707963268
71:
72: vec4 quat(vec3 axis, float angle) {
73: float halfAngle = angle * PIOVER2 / 180.0;
74: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
75: return vec4(axis.xyz * cs.y, cs.x);
76: }
77:
78: vec4 quatMult(vec4 q1, vec4 q2) {
79: // disgustingly vectorized quaternion multiplication
80: vec4 a = q1.w * q2.xyzw;
81: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
82: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
83: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
84:
85: return a + b + c + d;
86: }
87:
88: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
89: vec3 i = q.xyz;
90: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
91: }
92:
93: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
94: return rotateVertexByQuat(v, quat(axis, angle));
95: }
96:
97: float diffuse(vec3 normal) {
98: vec3 n2 = normal * normal * vec3(.6, .25, .8);
99: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
100: }
101:
102:
103: struct Oriented {
104: vec2 light;
105: vec4 color;
106: vec3 pos;
107: vec3 pivot;
108: vec4 rotation;
109: };
110:
111:
112: struct Vertex {
113: vec3 pos;
114: vec3 normal;
115: vec2 texCoords;
116: };
117:
118: struct BlockFrag {
119: vec2 texCoords;
120: vec4 color;
121: float diffuse;
122: vec2 light;
123: };
124:
125: BlockFrag FLWMain(Vertex v, Oriented o) {
126: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
127:
128: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
129:
130: FLWFinalizeWorldPos(worldPos);
131: FLWFinalizeNormal(norm);
132:
133: BlockFrag b;
134: b.diffuse = diffuse(norm);
135: b.texCoords = v.texCoords;
136: b.light = o.light;
137: #if defined(DEBUG_NORMAL)
138: b.color = vec4(norm, 1.);
139: #else
140: b.color = o.color;
141: #endif
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute vec3 a_i_pivot;
152: attribute vec4 a_i_rotation;
153:
154:
155: varying vec2 v2f_texCoords;
156: varying vec4 v2f_color;
157: varying float v2f_diffuse;
158: varying vec2 v2f_light;
159:
160:
161: void main() {
162: Vertex v;
163: v.pos = a_v_pos;
164: v.normal = a_v_normal;
165: v.texCoords = a_v_texCoords;
166:
167:
168: Oriented i;
169: i.light = a_i_light;
170: i.color = a_i_color;
171: i.pos = a_i_pos;
172: i.pivot = a_i_pivot;
173: i.rotation = a_i_rotation;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:44:41] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:41] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:41] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:45] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: #define PIOVER2 1.5707963268
71:
72: vec4 quat(vec3 axis, float angle) {
73: float halfAngle = angle * PIOVER2 / 180.0;
74: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
75: return vec4(axis.xyz * cs.y, cs.x);
76: }
77:
78: vec4 quatMult(vec4 q1, vec4 q2) {
79: // disgustingly vectorized quaternion multiplication
80: vec4 a = q1.w * q2.xyzw;
81: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
82: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
83: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
84:
85: return a + b + c + d;
86: }
87:
88: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
89: vec3 i = q.xyz;
90: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
91: }
92:
93: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
94: return rotateVertexByQuat(v, quat(axis, angle));
95: }
96:
97: float diffuse(vec3 normal) {
98: vec3 n2 = normal * normal * vec3(.6, .25, .8);
99: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
100: }
101:
102:
103: struct Oriented {
104: vec2 light;
105: vec4 color;
106: vec3 pos;
107: vec3 pivot;
108: vec4 rotation;
109: };
110:
111:
112: struct Vertex {
113: vec3 pos;
114: vec3 normal;
115: vec2 texCoords;
116: };
117:
118: struct BlockFrag {
119: vec2 texCoords;
120: vec4 color;
121: float diffuse;
122: vec2 light;
123: };
124:
125: BlockFrag FLWMain(Vertex v, Oriented o) {
126: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
127:
128: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
129:
130: FLWFinalizeWorldPos(worldPos);
131: FLWFinalizeNormal(norm);
132:
133: BlockFrag b;
134: b.diffuse = diffuse(norm);
135: b.texCoords = v.texCoords;
136: b.light = o.light;
137: #if defined(DEBUG_NORMAL)
138: b.color = vec4(norm, 1.);
139: #else
140: b.color = o.color;
141: #endif
142: return b;
143: }
144: attribute vec3 a_v_pos;
145: attribute vec3 a_v_normal;
146: attribute vec2 a_v_texCoords;
147:
148: attribute vec2 a_i_light;
149: attribute vec4 a_i_color;
150: attribute vec3 a_i_pos;
151: attribute vec3 a_i_pivot;
152: attribute vec4 a_i_rotation;
153:
154:
155: varying vec2 v2f_texCoords;
156: varying vec4 v2f_color;
157: varying float v2f_diffuse;
158: varying vec2 v2f_light;
159:
160:
161: void main() {
162: Vertex v;
163: v.pos = a_v_pos;
164: v.normal = a_v_normal;
165: v.texCoords = a_v_texCoords;
166:
167:
168: Oriented i;
169: i.light = a_i_light;
170: i.color = a_i_color;
171: i.pos = a_i_pos;
172: i.pivot = a_i_pivot;
173: i.rotation = a_i_rotation;
174:
175:
176: BlockFrag o = FLWMain(v, i);
177:
178: v2f_texCoords = o.texCoords;
179: v2f_color = o.color;
180: v2f_diffuse = o.diffuse;
181: v2f_light = o.light;
182:
183: }
[12:44:48] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:48] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:48] [main/ERROR]: Shader compilation log for flywheel:oriented.vert: No errors.
[12:44:48] [main/ERROR]: Source for shader 'flywheel:oriented.vert':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: #endif
6:
7: varying vec3 BoxCoord;
8:
9: uniform vec3 uLightBoxSize;
10: uniform vec3 uLightBoxMin;
11: uniform mat4 uModel;
12:
13: uniform float uTime;
14: uniform mat4 uViewProjection;
15: uniform vec3 uCameraPos;
16:
17: void FLWFinalizeWorldPos(inout vec4 worldPos) {
18: worldPos = uModel * worldPos;
19:
20: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
21:
22: #if defined(USE_FOG)
23: FragDistance = length(worldPos.xyz);
24: #endif
25:
26: gl_Position = uViewProjection * worldPos;
27: }
28:
29: void FLWFinalizeNormal(inout vec3 normal) {
30: mat3 m;
31: m[0] = uModel[0].xyz;
32: m[1] = uModel[1].xyz;
33: m[2] = uModel[2].xyz;
34: normal = m * normal;
35: }
36:
37:
38:
39: mat4 rotate(vec3 axis, float angle) {
40: float s = sin(angle);
41: float c = cos(angle);
42: float oc = 1. - c;
43:
44: vec3 sa = axis * s;
45:
46: mat4 mr = mat4(1.);
47: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
48: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
49: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
50:
51: return mr;
52: }
53:
54: mat4 rotation(vec3 rot) {
55: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
56: }
57:
58: mat3 modelToNormal(mat4 mat) {
59: // Discard the edges. This won't be accurate for scaled or skewed matrices,
60: // but we don't have to work with those often.
61: mat3 m;
62: m[0] = mat[0].xyz;
63: m[1] = mat[1].xyz;
64: m[2] = mat[2].xyz;
65: return m;
66: }
67:
68: #define PIOVER2 1.5707963268
69:
70: vec4 quat(vec3 axis, float angle) {
71: float halfAngle = angle * PIOVER2 / 180.0;
72: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
73: return vec4(axis.xyz * cs.y, cs.x);
74: }
75:
76: vec4 quatMult(vec4 q1, vec4 q2) {
77: // disgustingly vectorized quaternion multiplication
78: vec4 a = q1.w * q2.xyzw;
79: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
80: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
81: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
82:
83: return a + b + c + d;
84: }
85:
86: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
87: vec3 i = q.xyz;
88: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
89: }
90:
91: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
92: return rotateVertexByQuat(v, quat(axis, angle));
93: }
94:
95: float diffuse(vec3 normal) {
96: vec3 n2 = normal * normal * vec3(.6, .25, .8);
97: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
98: }
99:
100:
101: struct Oriented {
102: vec2 light;
103: vec4 color;
104: vec3 pos;
105: vec3 pivot;
106: vec4 rotation;
107: };
108:
109:
110: struct Vertex {
111: vec3 pos;
112: vec3 normal;
113: vec2 texCoords;
114: };
115:
116: struct BlockFrag {
117: vec2 texCoords;
118: vec4 color;
119: float diffuse;
120: vec2 light;
121: };
122:
123: BlockFrag FLWMain(Vertex v, Oriented o) {
124: vec4 worldPos = vec4(rotateVertexByQuat(v.pos - o.pivot, o.rotation) + o.pivot + o.pos, 1.);
125:
126: vec3 norm = rotateVertexByQuat(v.normal, o.rotation);
127:
128: FLWFinalizeWorldPos(worldPos);
129: FLWFinalizeNormal(norm);
130:
131: BlockFrag b;
132: b.diffuse = diffuse(norm);
133: b.texCoords = v.texCoords;
134: b.light = o.light;
135: #if defined(DEBUG_NORMAL)
136: b.color = vec4(norm, 1.);
137: #else
138: b.color = o.color;
139: #endif
140: return b;
141: }
142: attribute vec3 a_v_pos;
143: attribute vec3 a_v_normal;
144: attribute vec2 a_v_texCoords;
145:
146: attribute vec2 a_i_light;
147: attribute vec4 a_i_color;
148: attribute vec3 a_i_pos;
149: attribute vec3 a_i_pivot;
150: attribute vec4 a_i_rotation;
151:
152:
153: varying vec2 v2f_texCoords;
154: varying vec4 v2f_color;
155: varying float v2f_diffuse;
156: varying vec2 v2f_light;
157:
158:
159: void main() {
160: Vertex v;
161: v.pos = a_v_pos;
162: v.normal = a_v_normal;
163: v.texCoords = a_v_texCoords;
164:
165:
166: Oriented i;
167: i.light = a_i_light;
168: i.color = a_i_color;
169: i.pos = a_i_pos;
170: i.pivot = a_i_pivot;
171: i.rotation = a_i_rotation;
172:
173:
174: BlockFrag o = FLWMain(v, i);
175:
176: v2f_texCoords = o.texCoords;
177: v2f_color = o.color;
178: v2f_diffuse = o.diffuse;
179: v2f_light = o.light;
180:
181: }
[12:44:51] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:51] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:44:51] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:51] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: #endif
7:
8: varying vec3 BoxCoord;
9:
10: uniform vec3 uLightBoxSize;
11: uniform vec3 uLightBoxMin;
12: uniform mat4 uModel;
13:
14: uniform float uTime;
15: uniform mat4 uViewProjection;
16: uniform vec3 uCameraPos;
17:
18: void FLWFinalizeWorldPos(inout vec4 worldPos) {
19: worldPos = uModel * worldPos;
20:
21: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
22:
23: #if defined(USE_FOG)
24: FragDistance = length(worldPos.xyz);
25: #endif
26:
27: gl_Position = uViewProjection * worldPos;
28: }
29:
30: void FLWFinalizeNormal(inout vec3 normal) {
31: mat3 m;
32: m[0] = uModel[0].xyz;
33: m[1] = uModel[1].xyz;
34: m[2] = uModel[2].xyz;
35: normal = m * normal;
36: }
37:
38:
39:
40: float diffuse(vec3 normal) {
41: vec3 n2 = normal * normal * vec3(.6, .25, .8);
42: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
43: }
44:
45:
46: struct Vertex {
47: vec3 pos;
48: vec3 normal;
49: vec2 texCoords;
50: };
51:
52: struct BlockFrag {
53: vec2 texCoords;
54: vec4 color;
55: float diffuse;
56: vec2 light;
57: };
58:
59:
60: struct Instance {
61: vec2 light;
62: vec4 color;
63: mat4 transform;
64: mat3 normalMat;
65: };
66:
67: BlockFrag FLWMain(Vertex v, Instance i) {
68: vec4 worldPos = i.transform * vec4(v.pos, 1.);
69:
70: vec3 norm = i.normalMat * v.normal;
71:
72: FLWFinalizeWorldPos(worldPos);
73: FLWFinalizeNormal(norm);
74:
75: norm = normalize(norm);
76:
77: BlockFrag b;
78: b.diffuse = diffuse(norm);
79: b.texCoords = v.texCoords;
80: b.light = i.light;
81: #if defined(DEBUG_NORMAL)
82: b.color = vec4(norm, 1.);
83: #else
84: b.color = i.color;
85: #endif
86: return b;
87: }
88: attribute vec3 a_v_pos;
89: attribute vec3 a_v_normal;
90: attribute vec2 a_v_texCoords;
91:
92: attribute vec2 a_i_light;
93: attribute vec4 a_i_color;
94: attribute mat4 a_i_transform;
95: attribute mat3 a_i_normalMat;
96:
97:
98: varying vec2 v2f_texCoords;
99: varying vec4 v2f_color;
100: varying float v2f_diffuse;
101: varying vec2 v2f_light;
102:
103:
104: void main() {
105: Vertex v;
106: v.pos = a_v_pos;
107: v.normal = a_v_normal;
108: v.texCoords = a_v_texCoords;
109:
110:
111: Instance i;
112: i.light = a_i_light;
113: i.color = a_i_color;
114: i.transform = a_i_transform;
115: i.normalMat = a_i_normalMat;
116:
117:
118: BlockFrag o = FLWMain(v, i);
119:
120: v2f_texCoords = o.texCoords;
121: v2f_color = o.color;
122: v2f_diffuse = o.diffuse;
123: v2f_light = o.light;
124:
125: }
[12:44:53] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:53] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:44:53] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:53] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: float diffuse(vec3 normal) {
42: vec3 n2 = normal * normal * vec3(.6, .25, .8);
43: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
44: }
45:
46:
47: struct Vertex {
48: vec3 pos;
49: vec3 normal;
50: vec2 texCoords;
51: };
52:
53: struct BlockFrag {
54: vec2 texCoords;
55: vec4 color;
56: float diffuse;
57: vec2 light;
58: };
59:
60:
61: struct Instance {
62: vec2 light;
63: vec4 color;
64: mat4 transform;
65: mat3 normalMat;
66: };
67:
68: BlockFrag FLWMain(Vertex v, Instance i) {
69: vec4 worldPos = i.transform * vec4(v.pos, 1.);
70:
71: vec3 norm = i.normalMat * v.normal;
72:
73: FLWFinalizeWorldPos(worldPos);
74: FLWFinalizeNormal(norm);
75:
76: norm = normalize(norm);
77:
78: BlockFrag b;
79: b.diffuse = diffuse(norm);
80: b.texCoords = v.texCoords;
81: b.light = i.light;
82: #if defined(DEBUG_NORMAL)
83: b.color = vec4(norm, 1.);
84: #else
85: b.color = i.color;
86: #endif
87: return b;
88: }
89: attribute vec3 a_v_pos;
90: attribute vec3 a_v_normal;
91: attribute vec2 a_v_texCoords;
92:
93: attribute vec2 a_i_light;
94: attribute vec4 a_i_color;
95: attribute mat4 a_i_transform;
96: attribute mat3 a_i_normalMat;
97:
98:
99: varying vec2 v2f_texCoords;
100: varying vec4 v2f_color;
101: varying float v2f_diffuse;
102: varying vec2 v2f_light;
103:
104:
105: void main() {
106: Vertex v;
107: v.pos = a_v_pos;
108: v.normal = a_v_normal;
109: v.texCoords = a_v_texCoords;
110:
111:
112: Instance i;
113: i.light = a_i_light;
114: i.color = a_i_color;
115: i.transform = a_i_transform;
116: i.normalMat = a_i_normalMat;
117:
118:
119: BlockFrag o = FLWMain(v, i);
120:
121: v2f_texCoords = o.texCoords;
122: v2f_color = o.color;
123: v2f_diffuse = o.diffuse;
124: v2f_light = o.light;
125:
126: }
[12:44:56] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:56] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:56] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:56] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: float diffuse(vec3 normal) {
42: vec3 n2 = normal * normal * vec3(.6, .25, .8);
43: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
44: }
45:
46:
47: struct Vertex {
48: vec3 pos;
49: vec3 normal;
50: vec2 texCoords;
51: };
52:
53: struct BlockFrag {
54: vec2 texCoords;
55: vec4 color;
56: float diffuse;
57: vec2 light;
58: };
59:
60:
61: struct Instance {
62: vec2 light;
63: vec4 color;
64: mat4 transform;
65: mat3 normalMat;
66: };
67:
68: BlockFrag FLWMain(Vertex v, Instance i) {
69: vec4 worldPos = i.transform * vec4(v.pos, 1.);
70:
71: vec3 norm = i.normalMat * v.normal;
72:
73: FLWFinalizeWorldPos(worldPos);
74: FLWFinalizeNormal(norm);
75:
76: norm = normalize(norm);
77:
78: BlockFrag b;
79: b.diffuse = diffuse(norm);
80: b.texCoords = v.texCoords;
81: b.light = i.light;
82: #if defined(DEBUG_NORMAL)
83: b.color = vec4(norm, 1.);
84: #else
85: b.color = i.color;
86: #endif
87: return b;
88: }
89: attribute vec3 a_v_pos;
90: attribute vec3 a_v_normal;
91: attribute vec2 a_v_texCoords;
92:
93: attribute vec2 a_i_light;
94: attribute vec4 a_i_color;
95: attribute mat4 a_i_transform;
96: attribute mat3 a_i_normalMat;
97:
98:
99: varying vec2 v2f_texCoords;
100: varying vec4 v2f_color;
101: varying float v2f_diffuse;
102: varying vec2 v2f_light;
103:
104:
105: void main() {
106: Vertex v;
107: v.pos = a_v_pos;
108: v.normal = a_v_normal;
109: v.texCoords = a_v_texCoords;
110:
111:
112: Instance i;
113: i.light = a_i_light;
114: i.color = a_i_color;
115: i.transform = a_i_transform;
116: i.normalMat = a_i_normalMat;
117:
118:
119: BlockFrag o = FLWMain(v, i);
120:
121: v2f_texCoords = o.texCoords;
122: v2f_color = o.color;
123: v2f_diffuse = o.diffuse;
124: v2f_light = o.light;
125:
126: }
[12:44:59] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:44:59] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:44:59] [main/ERROR]: Shader compilation log for flywheel:model.vert: No errors.
[12:44:59] [main/ERROR]: Source for shader 'flywheel:model.vert':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: #endif
6:
7: varying vec3 BoxCoord;
8:
9: uniform vec3 uLightBoxSize;
10: uniform vec3 uLightBoxMin;
11: uniform mat4 uModel;
12:
13: uniform float uTime;
14: uniform mat4 uViewProjection;
15: uniform vec3 uCameraPos;
16:
17: void FLWFinalizeWorldPos(inout vec4 worldPos) {
18: worldPos = uModel * worldPos;
19:
20: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
21:
22: #if defined(USE_FOG)
23: FragDistance = length(worldPos.xyz);
24: #endif
25:
26: gl_Position = uViewProjection * worldPos;
27: }
28:
29: void FLWFinalizeNormal(inout vec3 normal) {
30: mat3 m;
31: m[0] = uModel[0].xyz;
32: m[1] = uModel[1].xyz;
33: m[2] = uModel[2].xyz;
34: normal = m * normal;
35: }
36:
37:
38:
39: float diffuse(vec3 normal) {
40: vec3 n2 = normal * normal * vec3(.6, .25, .8);
41: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
42: }
43:
44:
45: struct Vertex {
46: vec3 pos;
47: vec3 normal;
48: vec2 texCoords;
49: };
50:
51: struct BlockFrag {
52: vec2 texCoords;
53: vec4 color;
54: float diffuse;
55: vec2 light;
56: };
57:
58:
59: struct Instance {
60: vec2 light;
61: vec4 color;
62: mat4 transform;
63: mat3 normalMat;
64: };
65:
66: BlockFrag FLWMain(Vertex v, Instance i) {
67: vec4 worldPos = i.transform * vec4(v.pos, 1.);
68:
69: vec3 norm = i.normalMat * v.normal;
70:
71: FLWFinalizeWorldPos(worldPos);
72: FLWFinalizeNormal(norm);
73:
74: norm = normalize(norm);
75:
76: BlockFrag b;
77: b.diffuse = diffuse(norm);
78: b.texCoords = v.texCoords;
79: b.light = i.light;
80: #if defined(DEBUG_NORMAL)
81: b.color = vec4(norm, 1.);
82: #else
83: b.color = i.color;
84: #endif
85: return b;
86: }
87: attribute vec3 a_v_pos;
88: attribute vec3 a_v_normal;
89: attribute vec2 a_v_texCoords;
90:
91: attribute vec2 a_i_light;
92: attribute vec4 a_i_color;
93: attribute mat4 a_i_transform;
94: attribute mat3 a_i_normalMat;
95:
96:
97: varying vec2 v2f_texCoords;
98: varying vec4 v2f_color;
99: varying float v2f_diffuse;
100: varying vec2 v2f_light;
101:
102:
103: void main() {
104: Vertex v;
105: v.pos = a_v_pos;
106: v.normal = a_v_normal;
107: v.texCoords = a_v_texCoords;
108:
109:
110: Instance i;
111: i.light = a_i_light;
112: i.color = a_i_color;
113: i.transform = a_i_transform;
114: i.normalMat = a_i_normalMat;
115:
116:
117: BlockFrag o = FLWMain(v, i);
118:
119: v2f_texCoords = o.texCoords;
120: v2f_color = o.color;
121: v2f_diffuse = o.diffuse;
122: v2f_light = o.light;
123:
124: }
[12:45:04] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:04] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:45:04] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:45:04] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: #define PIOVER2 1.5707963268
43:
44: vec4 quat(vec3 axis, float angle) {
45: float halfAngle = angle * PIOVER2 / 180.0;
46: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
47: return vec4(axis.xyz * cs.y, cs.x);
48: }
49:
50: vec4 quatMult(vec4 q1, vec4 q2) {
51: // disgustingly vectorized quaternion multiplication
52: vec4 a = q1.w * q2.xyzw;
53: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
54: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
55: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
56:
57: return a + b + c + d;
58: }
59:
60: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
61: vec3 i = q.xyz;
62: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
63: }
64:
65: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
66: return rotateVertexByQuat(v, quat(axis, angle));
67: }
68:
69: mat4 rotate(vec3 axis, float angle) {
70: float s = sin(angle);
71: float c = cos(angle);
72: float oc = 1. - c;
73:
74: vec3 sa = axis * s;
75:
76: mat4 mr = mat4(1.);
77: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
78: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
79: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
80:
81: return mr;
82: }
83:
84: mat4 rotation(vec3 rot) {
85: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
86: }
87:
88: mat3 modelToNormal(mat4 mat) {
89: // Discard the edges. This won't be accurate for scaled or skewed matrices,
90: // but we don't have to work with those often.
91: mat3 m;
92: m[0] = mat[0].xyz;
93: m[1] = mat[1].xyz;
94: m[2] = mat[2].xyz;
95: return m;
96: }
97:
98: float diffuse(vec3 normal) {
99: vec3 n2 = normal * normal * vec3(.6, .25, .8);
100: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
101: }
102:
103:
104: struct Belt {
105: vec2 light;
106: vec4 color;
107: vec3 pos;
108: float speed;
109: float offset;
110: vec4 rotation;
111: vec2 sourceTexture;
112: vec4 scrollTexture;
113: float scrollMult;
114: };
115:
116:
117: struct Vertex {
118: vec3 pos;
119: vec3 normal;
120: vec2 texCoords;
121: };
122:
123: struct BlockFrag {
124: vec2 texCoords;
125: vec4 color;
126: float diffuse;
127: vec2 light;
128: };
129:
130: BlockFrag FLWMain(Vertex v, Belt instance) {
131: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
132:
133: vec4 worldPos = vec4(rotated, 1.);
134:
135: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
136:
137: FLWFinalizeWorldPos(worldPos);
138: FLWFinalizeNormal(norm);
139:
140: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
141: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
142:
143: BlockFrag b;
144: b.diffuse = diffuse(norm);
145: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
146: b.light = instance.light;
147:
148: #if defined(DEBUG_RAINBOW)
149: b.color = instance.color;
150: #elif defined(DEBUG_NORMAL)
151: b.color = vec4(norm, 1.);
152: #else
153: b.color = vec4(1.);
154: #endif
155:
156: return b;
157: }
158: attribute vec3 a_v_pos;
159: attribute vec3 a_v_normal;
160: attribute vec2 a_v_texCoords;
161:
162: attribute vec2 a_i_light;
163: attribute vec4 a_i_color;
164: attribute vec3 a_i_pos;
165: attribute float a_i_speed;
166: attribute float a_i_offset;
167: attribute vec4 a_i_rotation;
168: attribute vec2 a_i_sourceTexture;
169: attribute vec4 a_i_scrollTexture;
170: attribute float a_i_scrollMult;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Belt i;
187: i.light = a_i_light;
188: i.color = a_i_color;
189: i.pos = a_i_pos;
190: i.speed = a_i_speed;
191: i.offset = a_i_offset;
192: i.rotation = a_i_rotation;
193: i.sourceTexture = a_i_sourceTexture;
194: i.scrollTexture = a_i_scrollTexture;
195: i.scrollMult = a_i_scrollMult;
196:
197:
198: BlockFrag o = FLWMain(v, i);
199:
200: v2f_texCoords = o.texCoords;
201: v2f_color = o.color;
202: v2f_diffuse = o.diffuse;
203: v2f_light = o.light;
204:
205: }
[12:45:06] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:06] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_RAINBOW
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:45:08] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:45:08] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: #define PIOVER2 1.5707963268
43:
44: vec4 quat(vec3 axis, float angle) {
45: float halfAngle = angle * PIOVER2 / 180.0;
46: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
47: return vec4(axis.xyz * cs.y, cs.x);
48: }
49:
50: vec4 quatMult(vec4 q1, vec4 q2) {
51: // disgustingly vectorized quaternion multiplication
52: vec4 a = q1.w * q2.xyzw;
53: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
54: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
55: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
56:
57: return a + b + c + d;
58: }
59:
60: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
61: vec3 i = q.xyz;
62: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
63: }
64:
65: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
66: return rotateVertexByQuat(v, quat(axis, angle));
67: }
68:
69: mat4 rotate(vec3 axis, float angle) {
70: float s = sin(angle);
71: float c = cos(angle);
72: float oc = 1. - c;
73:
74: vec3 sa = axis * s;
75:
76: mat4 mr = mat4(1.);
77: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
78: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
79: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
80:
81: return mr;
82: }
83:
84: mat4 rotation(vec3 rot) {
85: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
86: }
87:
88: mat3 modelToNormal(mat4 mat) {
89: // Discard the edges. This won't be accurate for scaled or skewed matrices,
90: // but we don't have to work with those often.
91: mat3 m;
92: m[0] = mat[0].xyz;
93: m[1] = mat[1].xyz;
94: m[2] = mat[2].xyz;
95: return m;
96: }
97:
98: float diffuse(vec3 normal) {
99: vec3 n2 = normal * normal * vec3(.6, .25, .8);
100: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
101: }
102:
103:
104: struct Belt {
105: vec2 light;
106: vec4 color;
107: vec3 pos;
108: float speed;
109: float offset;
110: vec4 rotation;
111: vec2 sourceTexture;
112: vec4 scrollTexture;
113: float scrollMult;
114: };
115:
116:
117: struct Vertex {
118: vec3 pos;
119: vec3 normal;
120: vec2 texCoords;
121: };
122:
123: struct BlockFrag {
124: vec2 texCoords;
125: vec4 color;
126: float diffuse;
127: vec2 light;
128: };
129:
130: BlockFrag FLWMain(Vertex v, Belt instance) {
131: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
132:
133: vec4 worldPos = vec4(rotated, 1.);
134:
135: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
136:
137: FLWFinalizeWorldPos(worldPos);
138: FLWFinalizeNormal(norm);
139:
140: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
141: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
142:
143: BlockFrag b;
144: b.diffuse = diffuse(norm);
145: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
146: b.light = instance.light;
147:
148: #if defined(DEBUG_RAINBOW)
149: b.color = instance.color;
150: #elif defined(DEBUG_NORMAL)
151: b.color = vec4(norm, 1.);
152: #else
153: b.color = vec4(1.);
154: #endif
155:
156: return b;
157: }
158: attribute vec3 a_v_pos;
159: attribute vec3 a_v_normal;
160: attribute vec2 a_v_texCoords;
161:
162: attribute vec2 a_i_light;
163: attribute vec4 a_i_color;
164: attribute vec3 a_i_pos;
165: attribute float a_i_speed;
166: attribute float a_i_offset;
167: attribute vec4 a_i_rotation;
168: attribute vec2 a_i_sourceTexture;
169: attribute vec4 a_i_scrollTexture;
170: attribute float a_i_scrollMult;
171:
172:
173: varying vec2 v2f_texCoords;
174: varying vec4 v2f_color;
175: varying float v2f_diffuse;
176: varying vec2 v2f_light;
177:
178:
179: void main() {
180: Vertex v;
181: v.pos = a_v_pos;
182: v.normal = a_v_normal;
183: v.texCoords = a_v_texCoords;
184:
185:
186: Belt i;
187: i.light = a_i_light;
188: i.color = a_i_color;
189: i.pos = a_i_pos;
190: i.speed = a_i_speed;
191: i.offset = a_i_offset;
192: i.rotation = a_i_rotation;
193: i.sourceTexture = a_i_sourceTexture;
194: i.scrollTexture = a_i_scrollTexture;
195: i.scrollMult = a_i_scrollMult;
196:
197:
198: BlockFrag o = FLWMain(v, i);
199:
200: v2f_texCoords = o.texCoords;
201: v2f_color = o.color;
202: v2f_diffuse = o.diffuse;
203: v2f_light = o.light;
204:
205: }
[12:45:11] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:11] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: //vec3 flw_WorldPos;
89: //vec3 flw_Normal;
90: //vec3 flw_Albedo;
91: //float flw_Alpha;
92: //vec2 flw_LightMap;
93: //vec4 flw_Tint;
94:
95: void main() {
96: BlockFrag f;
97: f.texCoords = v2f_texCoords;
98: f.color = v2f_color;
99: f.diffuse = v2f_diffuse;
100: f.light = v2f_light;
101:
102:
103: FLWMain(f);
104: }
[12:45:11] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:45:11] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: #define PIOVER2 1.5707963268
44:
45: vec4 quat(vec3 axis, float angle) {
46: float halfAngle = angle * PIOVER2 / 180.0;
47: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
48: return vec4(axis.xyz * cs.y, cs.x);
49: }
50:
51: vec4 quatMult(vec4 q1, vec4 q2) {
52: // disgustingly vectorized quaternion multiplication
53: vec4 a = q1.w * q2.xyzw;
54: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
55: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
56: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
57:
58: return a + b + c + d;
59: }
60:
61: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
62: vec3 i = q.xyz;
63: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
64: }
65:
66: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
67: return rotateVertexByQuat(v, quat(axis, angle));
68: }
69:
70: mat4 rotate(vec3 axis, float angle) {
71: float s = sin(angle);
72: float c = cos(angle);
73: float oc = 1. - c;
74:
75: vec3 sa = axis * s;
76:
77: mat4 mr = mat4(1.);
78: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
79: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
80: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
81:
82: return mr;
83: }
84:
85: mat4 rotation(vec3 rot) {
86: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
87: }
88:
89: mat3 modelToNormal(mat4 mat) {
90: // Discard the edges. This won't be accurate for scaled or skewed matrices,
91: // but we don't have to work with those often.
92: mat3 m;
93: m[0] = mat[0].xyz;
94: m[1] = mat[1].xyz;
95: m[2] = mat[2].xyz;
96: return m;
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Belt {
106: vec2 light;
107: vec4 color;
108: vec3 pos;
109: float speed;
110: float offset;
111: vec4 rotation;
112: vec2 sourceTexture;
113: vec4 scrollTexture;
114: float scrollMult;
115: };
116:
117:
118: struct Vertex {
119: vec3 pos;
120: vec3 normal;
121: vec2 texCoords;
122: };
123:
124: struct BlockFrag {
125: vec2 texCoords;
126: vec4 color;
127: float diffuse;
128: vec2 light;
129: };
130:
131: BlockFrag FLWMain(Vertex v, Belt instance) {
132: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
133:
134: vec4 worldPos = vec4(rotated, 1.);
135:
136: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
137:
138: FLWFinalizeWorldPos(worldPos);
139: FLWFinalizeNormal(norm);
140:
141: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
142: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
143:
144: BlockFrag b;
145: b.diffuse = diffuse(norm);
146: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
147: b.light = instance.light;
148:
149: #if defined(DEBUG_RAINBOW)
150: b.color = instance.color;
151: #elif defined(DEBUG_NORMAL)
152: b.color = vec4(norm, 1.);
153: #else
154: b.color = vec4(1.);
155: #endif
156:
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec2 a_i_light;
164: attribute vec4 a_i_color;
165: attribute vec3 a_i_pos;
166: attribute float a_i_speed;
167: attribute float a_i_offset;
168: attribute vec4 a_i_rotation;
169: attribute vec2 a_i_sourceTexture;
170: attribute vec4 a_i_scrollTexture;
171: attribute float a_i_scrollMult;
172:
173:
174: varying vec2 v2f_texCoords;
175: varying vec4 v2f_color;
176: varying float v2f_diffuse;
177: varying vec2 v2f_light;
178:
179:
180: void main() {
181: Vertex v;
182: v.pos = a_v_pos;
183: v.normal = a_v_normal;
184: v.texCoords = a_v_texCoords;
185:
186:
187: Belt i;
188: i.light = a_i_light;
189: i.color = a_i_color;
190: i.pos = a_i_pos;
191: i.speed = a_i_speed;
192: i.offset = a_i_offset;
193: i.rotation = a_i_rotation;
194: i.sourceTexture = a_i_sourceTexture;
195: i.scrollTexture = a_i_scrollTexture;
196: i.scrollMult = a_i_scrollMult;
197:
198:
199: BlockFrag o = FLWMain(v, i);
200:
201: v2f_texCoords = o.texCoords;
202: v2f_color = o.color;
203: v2f_diffuse = o.diffuse;
204: v2f_light = o.light;
205:
206: }
[12:45:14] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:14] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:45:15] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:45:15] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: #define PIOVER2 1.5707963268
44:
45: vec4 quat(vec3 axis, float angle) {
46: float halfAngle = angle * PIOVER2 / 180.0;
47: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
48: return vec4(axis.xyz * cs.y, cs.x);
49: }
50:
51: vec4 quatMult(vec4 q1, vec4 q2) {
52: // disgustingly vectorized quaternion multiplication
53: vec4 a = q1.w * q2.xyzw;
54: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
55: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
56: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
57:
58: return a + b + c + d;
59: }
60:
61: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
62: vec3 i = q.xyz;
63: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
64: }
65:
66: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
67: return rotateVertexByQuat(v, quat(axis, angle));
68: }
69:
70: mat4 rotate(vec3 axis, float angle) {
71: float s = sin(angle);
72: float c = cos(angle);
73: float oc = 1. - c;
74:
75: vec3 sa = axis * s;
76:
77: mat4 mr = mat4(1.);
78: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
79: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
80: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
81:
82: return mr;
83: }
84:
85: mat4 rotation(vec3 rot) {
86: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
87: }
88:
89: mat3 modelToNormal(mat4 mat) {
90: // Discard the edges. This won't be accurate for scaled or skewed matrices,
91: // but we don't have to work with those often.
92: mat3 m;
93: m[0] = mat[0].xyz;
94: m[1] = mat[1].xyz;
95: m[2] = mat[2].xyz;
96: return m;
97: }
98:
99: float diffuse(vec3 normal) {
100: vec3 n2 = normal * normal * vec3(.6, .25, .8);
101: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
102: }
103:
104:
105: struct Belt {
106: vec2 light;
107: vec4 color;
108: vec3 pos;
109: float speed;
110: float offset;
111: vec4 rotation;
112: vec2 sourceTexture;
113: vec4 scrollTexture;
114: float scrollMult;
115: };
116:
117:
118: struct Vertex {
119: vec3 pos;
120: vec3 normal;
121: vec2 texCoords;
122: };
123:
124: struct BlockFrag {
125: vec2 texCoords;
126: vec4 color;
127: float diffuse;
128: vec2 light;
129: };
130:
131: BlockFrag FLWMain(Vertex v, Belt instance) {
132: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
133:
134: vec4 worldPos = vec4(rotated, 1.);
135:
136: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
137:
138: FLWFinalizeWorldPos(worldPos);
139: FLWFinalizeNormal(norm);
140:
141: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
142: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
143:
144: BlockFrag b;
145: b.diffuse = diffuse(norm);
146: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
147: b.light = instance.light;
148:
149: #if defined(DEBUG_RAINBOW)
150: b.color = instance.color;
151: #elif defined(DEBUG_NORMAL)
152: b.color = vec4(norm, 1.);
153: #else
154: b.color = vec4(1.);
155: #endif
156:
157: return b;
158: }
159: attribute vec3 a_v_pos;
160: attribute vec3 a_v_normal;
161: attribute vec2 a_v_texCoords;
162:
163: attribute vec2 a_i_light;
164: attribute vec4 a_i_color;
165: attribute vec3 a_i_pos;
166: attribute float a_i_speed;
167: attribute float a_i_offset;
168: attribute vec4 a_i_rotation;
169: attribute vec2 a_i_sourceTexture;
170: attribute vec4 a_i_scrollTexture;
171: attribute float a_i_scrollMult;
172:
173:
174: varying vec2 v2f_texCoords;
175: varying vec4 v2f_color;
176: varying float v2f_diffuse;
177: varying vec2 v2f_light;
178:
179:
180: void main() {
181: Vertex v;
182: v.pos = a_v_pos;
183: v.normal = a_v_normal;
184: v.texCoords = a_v_texCoords;
185:
186:
187: Belt i;
188: i.light = a_i_light;
189: i.color = a_i_color;
190: i.pos = a_i_pos;
191: i.speed = a_i_speed;
192: i.offset = a_i_offset;
193: i.rotation = a_i_rotation;
194: i.sourceTexture = a_i_sourceTexture;
195: i.scrollTexture = a_i_scrollTexture;
196: i.scrollMult = a_i_scrollMult;
197:
198:
199: BlockFrag o = FLWMain(v, i);
200:
201: v2f_texCoords = o.texCoords;
202: v2f_color = o.color;
203: v2f_diffuse = o.diffuse;
204: v2f_light = o.light;
205:
206: }
[12:45:20] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:20] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: //vec3 flw_WorldPos;
90: //vec3 flw_Normal;
91: //vec3 flw_Albedo;
92: //float flw_Alpha;
93: //vec2 flw_LightMap;
94: //vec4 flw_Tint;
95:
96: void main() {
97: BlockFrag f;
98: f.texCoords = v2f_texCoords;
99: f.color = v2f_color;
100: f.diffuse = v2f_diffuse;
101: f.light = v2f_light;
102:
103:
104: FLWMain(f);
105: }
[12:45:20] [main/ERROR]: Shader compilation log for create:belt.vert: No errors.
[12:45:20] [main/ERROR]: Source for shader 'create:belt.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: #define PIOVER2 1.5707963268
42:
43: vec4 quat(vec3 axis, float angle) {
44: float halfAngle = angle * PIOVER2 / 180.0;
45: vec2 cs = sin(vec2(PIOVER2 - halfAngle, halfAngle)); // compute sin and cos in one instruction
46: return vec4(axis.xyz * cs.y, cs.x);
47: }
48:
49: vec4 quatMult(vec4 q1, vec4 q2) {
50: // disgustingly vectorized quaternion multiplication
51: vec4 a = q1.w * q2.xyzw;
52: vec4 b = q1.x * q2.wzxy * vec4(1., -1., 1., -1.);
53: vec4 c = q1.y * q2.zwxy * vec4(1., 1., -1., -1.);
54: vec4 d = q1.z * q2.yxwz * vec4(-1., 1., 1., -1.);
55:
56: return a + b + c + d;
57: }
58:
59: vec3 rotateVertexByQuat(vec3 v, vec4 q) {
60: vec3 i = q.xyz;
61: return v + 2.0 * cross(i, cross(i, v) + q.w * v);
62: }
63:
64: vec3 rotateAbout(vec3 v, vec3 axis, float angle) {
65: return rotateVertexByQuat(v, quat(axis, angle));
66: }
67:
68: mat4 rotate(vec3 axis, float angle) {
69: float s = sin(angle);
70: float c = cos(angle);
71: float oc = 1. - c;
72:
73: vec3 sa = axis * s;
74:
75: mat4 mr = mat4(1.);
76: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
77: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
78: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
79:
80: return mr;
81: }
82:
83: mat4 rotation(vec3 rot) {
84: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
85: }
86:
87: mat3 modelToNormal(mat4 mat) {
88: // Discard the edges. This won't be accurate for scaled or skewed matrices,
89: // but we don't have to work with those often.
90: mat3 m;
91: m[0] = mat[0].xyz;
92: m[1] = mat[1].xyz;
93: m[2] = mat[2].xyz;
94: return m;
95: }
96:
97: float diffuse(vec3 normal) {
98: vec3 n2 = normal * normal * vec3(.6, .25, .8);
99: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
100: }
101:
102:
103: struct Belt {
104: vec2 light;
105: vec4 color;
106: vec3 pos;
107: float speed;
108: float offset;
109: vec4 rotation;
110: vec2 sourceTexture;
111: vec4 scrollTexture;
112: float scrollMult;
113: };
114:
115:
116: struct Vertex {
117: vec3 pos;
118: vec3 normal;
119: vec2 texCoords;
120: };
121:
122: struct BlockFrag {
123: vec2 texCoords;
124: vec4 color;
125: float diffuse;
126: vec2 light;
127: };
128:
129: BlockFrag FLWMain(Vertex v, Belt instance) {
130: vec3 rotated = rotateVertexByQuat(v.pos - .5, instance.rotation) + instance.pos + .5;
131:
132: vec4 worldPos = vec4(rotated, 1.);
133:
134: vec3 norm = rotateVertexByQuat(v.normal, instance.rotation);
135:
136: FLWFinalizeWorldPos(worldPos);
137: FLWFinalizeNormal(norm);
138:
139: float scrollSize = instance.scrollTexture.w - instance.scrollTexture.y;
140: float scroll = fract(instance.speed * uTime / (31.5 * 16.) + instance.offset) * scrollSize * instance.scrollMult;
141:
142: BlockFrag b;
143: b.diffuse = diffuse(norm);
144: b.texCoords = v.texCoords - instance.sourceTexture + instance.scrollTexture.xy + vec2(0, scroll);
145: b.light = instance.light;
146:
147: #if defined(DEBUG_RAINBOW)
148: b.color = instance.color;
149: #elif defined(DEBUG_NORMAL)
150: b.color = vec4(norm, 1.);
151: #else
152: b.color = vec4(1.);
153: #endif
154:
155: return b;
156: }
157: attribute vec3 a_v_pos;
158: attribute vec3 a_v_normal;
159: attribute vec2 a_v_texCoords;
160:
161: attribute vec2 a_i_light;
162: attribute vec4 a_i_color;
163: attribute vec3 a_i_pos;
164: attribute float a_i_speed;
165: attribute float a_i_offset;
166: attribute vec4 a_i_rotation;
167: attribute vec2 a_i_sourceTexture;
168: attribute vec4 a_i_scrollTexture;
169: attribute float a_i_scrollMult;
170:
171:
172: varying vec2 v2f_texCoords;
173: varying vec4 v2f_color;
174: varying float v2f_diffuse;
175: varying vec2 v2f_light;
176:
177:
178: void main() {
179: Vertex v;
180: v.pos = a_v_pos;
181: v.normal = a_v_normal;
182: v.texCoords = a_v_texCoords;
183:
184:
185: Belt i;
186: i.light = a_i_light;
187: i.color = a_i_color;
188: i.pos = a_i_pos;
189: i.speed = a_i_speed;
190: i.offset = a_i_offset;
191: i.rotation = a_i_rotation;
192: i.sourceTexture = a_i_sourceTexture;
193: i.scrollTexture = a_i_scrollTexture;
194: i.scrollMult = a_i_scrollMult;
195:
196:
197: BlockFrag o = FLWMain(v, i);
198:
199: v2f_texCoords = o.texCoords;
200: v2f_color = o.color;
201: v2f_diffuse = o.diffuse;
202: v2f_light = o.light;
203:
204: }
[12:45:22] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:22] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: //vec3 flw_WorldPos;
88: //vec3 flw_Normal;
89: //vec3 flw_Albedo;
90: //float flw_Alpha;
91: //vec2 flw_LightMap;
92: //vec4 flw_Tint;
93:
94: void main() {
95: BlockFrag f;
96: f.texCoords = v2f_texCoords;
97: f.color = v2f_color;
98: f.diffuse = v2f_diffuse;
99: f.light = v2f_light;
100:
101:
102: FLWMain(f);
103: }
[12:45:23] [main/INFO]: Loading context 'create:context/contraption'
[12:45:23] [main/ERROR]: Shader compilation log for create:contraption_structure.vert: No errors.
[12:45:23] [main/ERROR]: Source for shader 'create:contraption_structure.vert':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #define PI 3.1415926538
5:
6: #if defined(USE_FOG)
7: varying float FragDistance;
8: #endif
9:
10: varying vec3 BoxCoord;
11:
12: uniform vec3 uLightBoxSize;
13: uniform vec3 uLightBoxMin;
14: uniform mat4 uModel;
15:
16: uniform float uTime;
17: uniform mat4 uViewProjection;
18: uniform vec3 uCameraPos;
19:
20: void FLWFinalizeWorldPos(inout vec4 worldPos) {
21: worldPos = uModel * worldPos;
22:
23: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
24:
25: #if defined(USE_FOG)
26: FragDistance = length(worldPos.xyz);
27: #endif
28:
29: gl_Position = uViewProjection * worldPos;
30: }
31:
32: void FLWFinalizeNormal(inout vec3 normal) {
33: mat3 m;
34: m[0] = uModel[0].xyz;
35: m[1] = uModel[1].xyz;
36: m[2] = uModel[2].xyz;
37: normal = m * normal;
38: }
39:
40:
41:
42: mat4 rotate(vec3 axis, float angle) {
43: float s = sin(angle);
44: float c = cos(angle);
45: float oc = 1. - c;
46:
47: vec3 sa = axis * s;
48:
49: mat4 mr = mat4(1.);
50: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
51: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
52: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
53:
54: return mr;
55: }
56:
57: mat4 rotation(vec3 rot) {
58: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
59: }
60:
61: mat3 modelToNormal(mat4 mat) {
62: // Discard the edges. This won't be accurate for scaled or skewed matrices,
63: // but we don't have to work with those often.
64: mat3 m;
65: m[0] = mat[0].xyz;
66: m[1] = mat[1].xyz;
67: m[2] = mat[2].xyz;
68: return m;
69: }
70:
71: float diffuse(vec3 normal) {
72: vec3 n2 = normal * normal * vec3(.6, .25, .8);
73: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
74: }
75:
76:
77: struct Vertex {
78: vec3 pos;
79: vec3 normal;
80: vec2 texCoords;
81: vec4 color;
82: vec2 modelLight;
83: };
84:
85:
86: struct BlockFrag {
87: vec2 texCoords;
88: vec4 color;
89: float diffuse;
90: vec2 light;
91: };
92:
93: BlockFrag FLWMain(Vertex v) {
94: vec4 worldPos = vec4(v.pos, 1.);
95: vec3 norm = v.normal;
96:
97: FLWFinalizeWorldPos(worldPos);
98: FLWFinalizeNormal(norm);
99:
100: BlockFrag b;
101: b.diffuse = diffuse(norm);
102: b.texCoords = v.texCoords;
103: b.light = v.modelLight;
104:
105: #if defined(DEBUG_NORMAL)
106: b.color = vec4(norm, 1.);
107: #else
108: b.color = vec4(v.color.rgb / diffuse(v.normal), v.color.a);
109: #endif
110:
111: return b;
112: }
113: attribute vec3 a_v_pos;
114: attribute vec3 a_v_normal;
115: attribute vec2 a_v_texCoords;
116: attribute vec4 a_v_color;
117: attribute vec2 a_v_modelLight;
118:
119:
120: varying vec2 v2f_texCoords;
121: varying vec4 v2f_color;
122: varying float v2f_diffuse;
123: varying vec2 v2f_light;
124:
125:
126: void main() {
127: Vertex v;
128: v.pos = a_v_pos;
129: v.normal = a_v_normal;
130: v.texCoords = a_v_texCoords;
131: v.color = a_v_color;
132: v.modelLight = a_v_modelLight;
133:
134:
135: BlockFrag o = FLWMain(v);
136:
137: v2f_texCoords = o.texCoords;
138: v2f_color = o.color;
139: v2f_diffuse = o.diffuse;
140: v2f_light = o.light;
141:
142: }
[12:45:25] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:25] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define DEBUG_NORMAL
3:
4: #if defined(USE_FOG)
5: varying float FragDistance;
6: uniform vec4 uFogColor;
7: #endif
8:
9: #if defined(USE_FOG_LINEAR)
10: uniform vec2 uFogRange;
11:
12: float FLWFogFactor() {
13: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
14: }
15: #endif
16:
17: #if defined(USE_FOG_EXP2)
18: uniform float uFogDensity;
19:
20: float FLWFogFactor() {
21: float dist = FragDistance * uFogDensity;
22: return 1. / exp2(dist * dist);
23: }
24: #endif
25: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
26: vec2 shiftLight(vec2 lm) {
27: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
28: }
29:
30: varying vec3 BoxCoord;
31: varying vec2 BoxLight;
32: uniform sampler3D uLightVolume;
33:
34: uniform sampler2D uBlockAtlas;
35: uniform sampler2D uLightMap;
36:
37: vec4 FLWBlockTexture(vec2 texCoords) {
38: return texture2D(uBlockAtlas, texCoords);
39: }
40:
41: void FLWFinalizeColor(vec4 color) {
42: #if defined(USE_FOG)
43: float a = color.a;
44: float fog = clamp(FLWFogFactor(), 0., 1.);
45:
46: color = mix(uFogColor, color, fog);
47: color.a = a;
48: #endif
49:
50: gl_FragColor = color;
51: }
52:
53: vec4 FLWLight(vec2 lightCoords) {
54: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
55:
56: return texture2D(uLightMap, shiftLight(lightCoords));
57: }
58:
59:
60:
61: struct BlockFrag {
62: vec2 texCoords;
63: vec4 color;
64: float diffuse;
65: vec2 light;
66: };
67:
68: void FLWMain(BlockFrag r) {
69: vec4 tex = FLWBlockTexture(r.texCoords);
70:
71: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
72:
73: // flw_WorldPos = ;
74: // flw_Normal = ;
75: // flw_Albedo = tex.rgb;
76: // flw_Alpha = tex.a;
77: // flw_LightMap = r.light;
78: // flw_Tint = r.color;
79: FLWFinalizeColor(color);
80: }
81:
82: varying vec2 v2f_texCoords;
83: varying vec4 v2f_color;
84: varying float v2f_diffuse;
85: varying vec2 v2f_light;
86:
87:
88: void main() {
89: BlockFrag f;
90: f.texCoords = v2f_texCoords;
91: f.color = v2f_color;
92: f.diffuse = v2f_diffuse;
93: f.light = v2f_light;
94:
95:
96: FLWMain(f);
97: }
[12:45:25] [main/ERROR]: Shader compilation log for create:contraption_structure.vert: No errors.
[12:45:25] [main/ERROR]: Source for shader 'create:contraption_structure.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: float diffuse(vec3 normal) {
73: vec3 n2 = normal * normal * vec3(.6, .25, .8);
74: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
75: }
76:
77:
78: struct Vertex {
79: vec3 pos;
80: vec3 normal;
81: vec2 texCoords;
82: vec4 color;
83: vec2 modelLight;
84: };
85:
86:
87: struct BlockFrag {
88: vec2 texCoords;
89: vec4 color;
90: float diffuse;
91: vec2 light;
92: };
93:
94: BlockFrag FLWMain(Vertex v) {
95: vec4 worldPos = vec4(v.pos, 1.);
96: vec3 norm = v.normal;
97:
98: FLWFinalizeWorldPos(worldPos);
99: FLWFinalizeNormal(norm);
100:
101: BlockFrag b;
102: b.diffuse = diffuse(norm);
103: b.texCoords = v.texCoords;
104: b.light = v.modelLight;
105:
106: #if defined(DEBUG_NORMAL)
107: b.color = vec4(norm, 1.);
108: #else
109: b.color = vec4(v.color.rgb / diffuse(v.normal), v.color.a);
110: #endif
111:
112: return b;
113: }
114: attribute vec3 a_v_pos;
115: attribute vec3 a_v_normal;
116: attribute vec2 a_v_texCoords;
117: attribute vec4 a_v_color;
118: attribute vec2 a_v_modelLight;
119:
120:
121: varying vec2 v2f_texCoords;
122: varying vec4 v2f_color;
123: varying float v2f_diffuse;
124: varying vec2 v2f_light;
125:
126:
127: void main() {
128: Vertex v;
129: v.pos = a_v_pos;
130: v.normal = a_v_normal;
131: v.texCoords = a_v_texCoords;
132: v.color = a_v_color;
133: v.modelLight = a_v_modelLight;
134:
135:
136: BlockFrag o = FLWMain(v);
137:
138: v2f_texCoords = o.texCoords;
139: v2f_color = o.color;
140: v2f_diffuse = o.diffuse;
141: v2f_light = o.light;
142:
143: }
[12:45:27] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:27] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_LINEAR
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:45:27] [main/ERROR]: Shader compilation log for create:contraption_structure.vert: No errors.
[12:45:27] [main/ERROR]: Source for shader 'create:contraption_structure.vert':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #define PI 3.1415926538
6:
7: #if defined(USE_FOG)
8: varying float FragDistance;
9: #endif
10:
11: varying vec3 BoxCoord;
12:
13: uniform vec3 uLightBoxSize;
14: uniform vec3 uLightBoxMin;
15: uniform mat4 uModel;
16:
17: uniform float uTime;
18: uniform mat4 uViewProjection;
19: uniform vec3 uCameraPos;
20:
21: void FLWFinalizeWorldPos(inout vec4 worldPos) {
22: worldPos = uModel * worldPos;
23:
24: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
25:
26: #if defined(USE_FOG)
27: FragDistance = length(worldPos.xyz);
28: #endif
29:
30: gl_Position = uViewProjection * worldPos;
31: }
32:
33: void FLWFinalizeNormal(inout vec3 normal) {
34: mat3 m;
35: m[0] = uModel[0].xyz;
36: m[1] = uModel[1].xyz;
37: m[2] = uModel[2].xyz;
38: normal = m * normal;
39: }
40:
41:
42:
43: mat4 rotate(vec3 axis, float angle) {
44: float s = sin(angle);
45: float c = cos(angle);
46: float oc = 1. - c;
47:
48: vec3 sa = axis * s;
49:
50: mat4 mr = mat4(1.);
51: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
52: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
53: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
54:
55: return mr;
56: }
57:
58: mat4 rotation(vec3 rot) {
59: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
60: }
61:
62: mat3 modelToNormal(mat4 mat) {
63: // Discard the edges. This won't be accurate for scaled or skewed matrices,
64: // but we don't have to work with those often.
65: mat3 m;
66: m[0] = mat[0].xyz;
67: m[1] = mat[1].xyz;
68: m[2] = mat[2].xyz;
69: return m;
70: }
71:
72: float diffuse(vec3 normal) {
73: vec3 n2 = normal * normal * vec3(.6, .25, .8);
74: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
75: }
76:
77:
78: struct Vertex {
79: vec3 pos;
80: vec3 normal;
81: vec2 texCoords;
82: vec4 color;
83: vec2 modelLight;
84: };
85:
86:
87: struct BlockFrag {
88: vec2 texCoords;
89: vec4 color;
90: float diffuse;
91: vec2 light;
92: };
93:
94: BlockFrag FLWMain(Vertex v) {
95: vec4 worldPos = vec4(v.pos, 1.);
96: vec3 norm = v.normal;
97:
98: FLWFinalizeWorldPos(worldPos);
99: FLWFinalizeNormal(norm);
100:
101: BlockFrag b;
102: b.diffuse = diffuse(norm);
103: b.texCoords = v.texCoords;
104: b.light = v.modelLight;
105:
106: #if defined(DEBUG_NORMAL)
107: b.color = vec4(norm, 1.);
108: #else
109: b.color = vec4(v.color.rgb / diffuse(v.normal), v.color.a);
110: #endif
111:
112: return b;
113: }
114: attribute vec3 a_v_pos;
115: attribute vec3 a_v_normal;
116: attribute vec2 a_v_texCoords;
117: attribute vec4 a_v_color;
118: attribute vec2 a_v_modelLight;
119:
120:
121: varying vec2 v2f_texCoords;
122: varying vec4 v2f_color;
123: varying float v2f_diffuse;
124: varying vec2 v2f_light;
125:
126:
127: void main() {
128: Vertex v;
129: v.pos = a_v_pos;
130: v.normal = a_v_normal;
131: v.texCoords = a_v_texCoords;
132: v.color = a_v_color;
133: v.modelLight = a_v_modelLight;
134:
135:
136: BlockFrag o = FLWMain(v);
137:
138: v2f_texCoords = o.texCoords;
139: v2f_color = o.color;
140: v2f_diffuse = o.diffuse;
141: v2f_light = o.light;
142:
143: }
[12:45:30] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:30] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2: #define USE_FOG
3: #define USE_FOG_EXP2
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: uniform vec4 uFogColor;
8: #endif
9:
10: #if defined(USE_FOG_LINEAR)
11: uniform vec2 uFogRange;
12:
13: float FLWFogFactor() {
14: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
15: }
16: #endif
17:
18: #if defined(USE_FOG_EXP2)
19: uniform float uFogDensity;
20:
21: float FLWFogFactor() {
22: float dist = FragDistance * uFogDensity;
23: return 1. / exp2(dist * dist);
24: }
25: #endif
26: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
27: vec2 shiftLight(vec2 lm) {
28: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
29: }
30:
31: varying vec3 BoxCoord;
32: varying vec2 BoxLight;
33: uniform sampler3D uLightVolume;
34:
35: uniform sampler2D uBlockAtlas;
36: uniform sampler2D uLightMap;
37:
38: vec4 FLWBlockTexture(vec2 texCoords) {
39: return texture2D(uBlockAtlas, texCoords);
40: }
41:
42: void FLWFinalizeColor(vec4 color) {
43: #if defined(USE_FOG)
44: float a = color.a;
45: float fog = clamp(FLWFogFactor(), 0., 1.);
46:
47: color = mix(uFogColor, color, fog);
48: color.a = a;
49: #endif
50:
51: gl_FragColor = color;
52: }
53:
54: vec4 FLWLight(vec2 lightCoords) {
55: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
56:
57: return texture2D(uLightMap, shiftLight(lightCoords));
58: }
59:
60:
61:
62: struct BlockFrag {
63: vec2 texCoords;
64: vec4 color;
65: float diffuse;
66: vec2 light;
67: };
68:
69: void FLWMain(BlockFrag r) {
70: vec4 tex = FLWBlockTexture(r.texCoords);
71:
72: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
73:
74: // flw_WorldPos = ;
75: // flw_Normal = ;
76: // flw_Albedo = tex.rgb;
77: // flw_Alpha = tex.a;
78: // flw_LightMap = r.light;
79: // flw_Tint = r.color;
80: FLWFinalizeColor(color);
81: }
82:
83: varying vec2 v2f_texCoords;
84: varying vec4 v2f_color;
85: varying float v2f_diffuse;
86: varying vec2 v2f_light;
87:
88:
89: void main() {
90: BlockFrag f;
91: f.texCoords = v2f_texCoords;
92: f.color = v2f_color;
93: f.diffuse = v2f_diffuse;
94: f.light = v2f_light;
95:
96:
97: FLWMain(f);
98: }
[12:45:30] [main/ERROR]: Shader compilation log for create:contraption_structure.vert: No errors.
[12:45:30] [main/ERROR]: Source for shader 'create:contraption_structure.vert':
1: #version 110
2:
3: #define PI 3.1415926538
4:
5: #if defined(USE_FOG)
6: varying float FragDistance;
7: #endif
8:
9: varying vec3 BoxCoord;
10:
11: uniform vec3 uLightBoxSize;
12: uniform vec3 uLightBoxMin;
13: uniform mat4 uModel;
14:
15: uniform float uTime;
16: uniform mat4 uViewProjection;
17: uniform vec3 uCameraPos;
18:
19: void FLWFinalizeWorldPos(inout vec4 worldPos) {
20: worldPos = uModel * worldPos;
21:
22: BoxCoord = (worldPos.xyz - uLightBoxMin) / uLightBoxSize;
23:
24: #if defined(USE_FOG)
25: FragDistance = length(worldPos.xyz);
26: #endif
27:
28: gl_Position = uViewProjection * worldPos;
29: }
30:
31: void FLWFinalizeNormal(inout vec3 normal) {
32: mat3 m;
33: m[0] = uModel[0].xyz;
34: m[1] = uModel[1].xyz;
35: m[2] = uModel[2].xyz;
36: normal = m * normal;
37: }
38:
39:
40:
41: mat4 rotate(vec3 axis, float angle) {
42: float s = sin(angle);
43: float c = cos(angle);
44: float oc = 1. - c;
45:
46: vec3 sa = axis * s;
47:
48: mat4 mr = mat4(1.);
49: mr[0].xyz = oc * axis.xxz * axis.xyx + vec3(c, sa.z, -sa.y);
50: mr[1].xyz = oc * axis.xyy * axis.yyz + vec3(-sa.z, c, sa.x);
51: mr[2].xyz = oc * axis.zyz * axis.xzz + vec3(sa.y, -sa.x, c);
52:
53: return mr;
54: }
55:
56: mat4 rotation(vec3 rot) {
57: return rotate(vec3(0., 1., 0.), rot.y) * rotate(vec3(0., 0., 1.), rot.z) * rotate(vec3(1., 0., 0.), rot.x);
58: }
59:
60: mat3 modelToNormal(mat4 mat) {
61: // Discard the edges. This won't be accurate for scaled or skewed matrices,
62: // but we don't have to work with those often.
63: mat3 m;
64: m[0] = mat[0].xyz;
65: m[1] = mat[1].xyz;
66: m[2] = mat[2].xyz;
67: return m;
68: }
69:
70: float diffuse(vec3 normal) {
71: vec3 n2 = normal * normal * vec3(.6, .25, .8);
72: return min(n2.x + n2.y * (3. + normal.y) + n2.z, 1.);
73: }
74:
75:
76: struct Vertex {
77: vec3 pos;
78: vec3 normal;
79: vec2 texCoords;
80: vec4 color;
81: vec2 modelLight;
82: };
83:
84:
85: struct BlockFrag {
86: vec2 texCoords;
87: vec4 color;
88: float diffuse;
89: vec2 light;
90: };
91:
92: BlockFrag FLWMain(Vertex v) {
93: vec4 worldPos = vec4(v.pos, 1.);
94: vec3 norm = v.normal;
95:
96: FLWFinalizeWorldPos(worldPos);
97: FLWFinalizeNormal(norm);
98:
99: BlockFrag b;
100: b.diffuse = diffuse(norm);
101: b.texCoords = v.texCoords;
102: b.light = v.modelLight;
103:
104: #if defined(DEBUG_NORMAL)
105: b.color = vec4(norm, 1.);
106: #else
107: b.color = vec4(v.color.rgb / diffuse(v.normal), v.color.a);
108: #endif
109:
110: return b;
111: }
112: attribute vec3 a_v_pos;
113: attribute vec3 a_v_normal;
114: attribute vec2 a_v_texCoords;
115: attribute vec4 a_v_color;
116: attribute vec2 a_v_modelLight;
117:
118:
119: varying vec2 v2f_texCoords;
120: varying vec4 v2f_color;
121: varying float v2f_diffuse;
122: varying vec2 v2f_light;
123:
124:
125: void main() {
126: Vertex v;
127: v.pos = a_v_pos;
128: v.normal = a_v_normal;
129: v.texCoords = a_v_texCoords;
130: v.color = a_v_color;
131: v.modelLight = a_v_modelLight;
132:
133:
134: BlockFrag o = FLWMain(v);
135:
136: v2f_texCoords = o.texCoords;
137: v2f_color = o.color;
138: v2f_diffuse = o.diffuse;
139: v2f_light = o.light;
140:
141: }
[12:45:34] [main/ERROR]: Shader compilation log for flywheel:block.frag: No errors.
[12:45:34] [main/ERROR]: Source for shader 'flywheel:block.frag':
1: #version 110
2:
3: #if defined(USE_FOG)
4: varying float FragDistance;
5: uniform vec4 uFogColor;
6: #endif
7:
8: #if defined(USE_FOG_LINEAR)
9: uniform vec2 uFogRange;
10:
11: float FLWFogFactor() {
12: return (uFogRange.y - FragDistance) / (uFogRange.y - uFogRange.x);
13: }
14: #endif
15:
16: #if defined(USE_FOG_EXP2)
17: uniform float uFogDensity;
18:
19: float FLWFogFactor() {
20: float dist = FragDistance * uFogDensity;
21: return 1. / exp2(dist * dist);
22: }
23: #endif
24: // Adjust the [0,1] normalized lightmap value based on the texture matrix from LightTexture#enableLightmap
25: vec2 shiftLight(vec2 lm) {
26: return lm * 0.99609375 + 0.03125;// * 255/256 + 1/32
27: }
28:
29: varying vec3 BoxCoord;
30: varying vec2 BoxLight;
31: uniform sampler3D uLightVolume;
32:
33: uniform sampler2D uBlockAtlas;
34: uniform sampler2D uLightMap;
35:
36: vec4 FLWBlockTexture(vec2 texCoords) {
37: return texture2D(uBlockAtlas, texCoords);
38: }
39:
40: void FLWFinalizeColor(vec4 color) {
41: #if defined(USE_FOG)
42: float a = color.a;
43: float fog = clamp(FLWFogFactor(), 0., 1.);
44:
45: color = mix(uFogColor, color, fog);
46: color.a = a;
47: #endif
48:
49: gl_FragColor = color;
50: }
51:
52: vec4 FLWLight(vec2 lightCoords) {
53: lightCoords = max(lightCoords, texture3D(uLightVolume, BoxCoord).rg);
54:
55: return texture2D(uLightMap, shiftLight(lightCoords));
56: }
57:
58:
59:
60: struct BlockFrag {
61: vec2 texCoords;
62: vec4 color;
63: float diffuse;
64: vec2 light;
65: };
66:
67: void FLWMain(BlockFrag r) {
68: vec4 tex = FLWBlockTexture(r.texCoords);
69:
70: vec4 color = vec4(tex.rgb * FLWLight(r.light).rgb * r.diffuse, tex.a) * r.color;
71:
72: // flw_WorldPos = ;
73: // flw_Normal = ;
74: // flw_Albedo = tex.rgb;
75: // flw_Alpha = tex.a;
76: // flw_LightMap = r.light;
77: // flw_Tint = r.color;
78: FLWFinalizeColor(color);
79: }
80:
81: varying vec2 v2f_texCoords;
82: varying vec4 v2f_color;
83: varying float v2f_diffuse;
84: varying vec2 v2f_light;
85:
86:
87: void main() {
88: BlockFrag f;
89: f.texCoords = v2f_texCoords;
90: f.color = v2f_color;
91: f.diffuse = v2f_diffuse;
92: f.light = v2f_light;
93:
94:
95: FLWMain(f);
96: }
[12:45:34] [main/INFO]: Loaded all shader programs.
[12:45:42] [main/INFO]: OpenAL initialized.
[12:45:42] [main/INFO]: Sound engine started
[12:45:43] [main/INFO]: Created: 128x256x0 jei:textures/atlas/gui.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button_cheat
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/config_button_cheat
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_previous
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_previous
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_next
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/arrow_next
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: minecraft:missingno
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: minecraft:missingno
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/info
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/info
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/recipe_transfer
[12:45:43] [main/WARN]: [OptiFine] Invalid grid V: 16, icon: jei:gui/icons/recipe_transfer
[12:45:43] [main/INFO]: Created: 2048x1024x4 minecraft:textures/atlas/blocks.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 54
[12:45:43] [main/INFO]: Created: 256x128x4 minecraft:textures/atlas/signs.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/INFO]: Created: 512x512x4 minecraft:textures/atlas/banner_patterns.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/INFO]: Created: 512x512x4 minecraft:textures/atlas/shield_patterns.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/INFO]: Created: 256x256x4 minecraft:textures/atlas/chest.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/INFO]: Created: 512x256x4 minecraft:textures/atlas/beds.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:43] [main/INFO]: Created: 512x256x4 minecraft:textures/atlas/shulker_boxes.png-atlas
[12:45:43] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:46] [main/INFO]: Created: 256x256x0 minecraft:textures/atlas/particles.png-atlas
[12:45:46] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:46] [main/INFO]: Created: 256x256x0 minecraft:textures/atlas/paintings.png-atlas
[12:45:46] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:46] [main/INFO]: Created: 128x128x0 minecraft:textures/atlas/mob_effects.png-atlas
[12:45:46] [main/INFO]: [OptiFine] Animated sprites: 0
[12:45:46] [main/INFO]: [OptiFine] *** Reloading custom textures ***
[12:45:46] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:45:47] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:45:47] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:46:03] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:46:03] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:46:03] [main/WARN]: [OptiFine] Unknown resource pack file: mod_resources
[12:46:03] [main/INFO]: [OptiFine] Disable Forge light pipeline
[12:46:03] [main/INFO]: [OptiFine] Set ForgeConfig.CLIENT.forgeLightPipelineEnabled=false
[12:46:04] [Realms Notification Availability checker #1/INFO]: Could not authorize you against Realms server: Invalid session id
[12:46:11] [main/WARN]: Missing data pack mod:tlskincape
[12:46:12] [main/WARN]: Ambiguity between arguments [c, coupling, add, cart1] and [c, coupling, add, carts] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [c, coupling, add, carts] and [c, coupling, add, cart1] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [c, coupling, add, cart1] and [c, coupling, add, carts] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [c, coupling, add, carts] and [c, coupling, add, cart1] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [teleport, destination] and [teleport, targets] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [teleport, location] and [teleport, destination] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:12] [main/WARN]: Ambiguity between arguments [teleport, location] and [teleport, targets] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:12] [main/WARN]: Ambiguity between arguments [teleport, targets] and [teleport, destination] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:12] [main/WARN]: Ambiguity between arguments [teleport, targets, location] and [teleport, targets, destination] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:12] [main/INFO]: Reloading ResourceManager: Default, forge-1.16.5-36.2.39-universal.jar, flywheel-1.16-0.2.5.jar, create-mc1.16.5_v0.3.2g.jar, jei-1.16.5-7.7.1.153.jar
[12:46:16] [main/INFO]: Loaded 19 recipes
[12:46:17] [main/INFO]: Loaded 1663 advancements
[12:46:18] [main/ERROR]: This world was saved with mod tlskincape which appears to be missing, things may not work well
[12:46:18] [main/INFO]: Injecting existing registry data into this CLIENT instance
[12:46:21] [main/WARN]: Missing data pack mod:tlskincape
[12:46:21] [main/WARN]: Ambiguity between arguments [c, coupling, add, cart1] and [c, coupling, add, carts] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [c, coupling, add, carts] and [c, coupling, add, cart1] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [c, coupling, add, cart1] and [c, coupling, add, carts] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [c, coupling, add, carts] and [c, coupling, add, cart1] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [teleport, destination] and [teleport, targets] with inputs: [Player, 0123, @e, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [teleport, location] and [teleport, destination] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:21] [main/WARN]: Ambiguity between arguments [teleport, location] and [teleport, targets] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:21] [main/WARN]: Ambiguity between arguments [teleport, targets] and [teleport, destination] with inputs: [Player, 0123, dd12be42-52a9-4a91-a8a1-11c01849e498]
[12:46:21] [main/WARN]: Ambiguity between arguments [teleport, targets, location] and [teleport, targets, destination] with inputs: [0.1 -0.5 .9, 0 0 0]
[12:46:21] [main/INFO]: Reloading ResourceManager: Default, forge-1.16.5-36.2.39-universal.jar, flywheel-1.16-0.2.5.jar, create-mc1.16.5_v0.3.2g.jar, jei-1.16.5-7.7.1.153.jar
[12:46:24] [main/INFO]: Loaded 19 recipes
[12:46:25] [main/INFO]: Loaded 1663 advancements
[12:46:26] [main/ERROR]: This world was saved with mod tlskincape which appears to be missing, things may not work well
[12:46:26] [main/INFO]: Injecting existing registry data into this CLIENT instance
[12:46:31] [main/INFO]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD'
[12:46:31] [Server thread/INFO]: Starting integrated minecraft server version 1.16.5
[12:46:31] [Server thread/INFO]: Generating keypair
[12:46:32] [Server thread/INFO]: Preparing start region for dimension minecraft:overworld
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:35] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:36] [main/INFO]: A preparar a área de nascimento: 0%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:40] [main/INFO]: A preparar a área de nascimento: 47%
[12:46:41] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:42] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:42] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:43] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:43] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:43] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:44] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:44] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:45] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:45] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:46] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:46] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:47] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:47] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:48] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:48] [main/INFO]: A preparar a área de nascimento: 83%
[12:46:49] [main/INFO]: A preparar a área de nascimento: 84%
[12:46:49] [main/INFO]: A preparar a área de nascimento: 85%
[12:46:50] [main/INFO]: A preparar a área de nascimento: 87%
[12:46:50] [main/INFO]: A preparar a área de nascimento: 87%
[12:46:51] [main/INFO]: A preparar a área de nascimento: 87%
[12:46:51] [main/INFO]: A preparar a área de nascimento: 87%
[12:46:52] [main/INFO]: A preparar a área de nascimento: 88%
[12:46:52] [main/INFO]: A preparar a área de nascimento: 89%
[12:46:53] [main/INFO]: A preparar a área de nascimento: 91%
[12:46:53] [main/INFO]: A preparar a área de nascimento: 91%
[12:46:54] [main/INFO]: A preparar a área de nascimento: 96%
[12:46:54] [main/INFO]: A preparar a área de nascimento: 98%
[12:46:55] [main/INFO]: Time elapsed: 22662 ms
[12:46:56] [Server thread/INFO]: Changing view distance to 2, from 10
[12:47:03] [Server thread/INFO]: Using new advancement loading for net.minecraft.advancements.PlayerAdvancements@50061d1a
[12:47:03] [Netty Local Client IO #0/INFO]: Connected to a modded server.
[12:47:04] [Server thread/INFO]: Vulpes_Ignis[local:E:9d83c9dc] logged in with entity id 334 at (-120.49413395498833, 66.49390748022948, -175.2198610397835)
[12:47:04] [Server thread/INFO]: Vulpes_Ignis entrou no jogo
[12:47:05] [main/INFO]: No shader config found.
[12:47:05] [main/INFO]: Starting JEI...
[12:47:05] [main/INFO]: Registering item subtypes: jei:minecraft ...
[12:47:05] [main/INFO]: Registering item subtypes: jei:minecraft took 36.23 ms
[12:47:05] [main/INFO]: Registering item subtypes: create:jei_plugin ...
[12:47:05] [main/INFO]: Registering item subtypes: create:jei_plugin took 19.25 ?s
[12:47:05] [main/INFO]: Registering item subtypes: jei:debug ...
[12:47:05] [main/INFO]: Registering item subtypes: jei:debug took 43.20 ?s
[12:47:05] [main/INFO]: Registering item subtypes: jei:internal ...
[12:47:05] [main/INFO]: Registering item subtypes: jei:internal took 14.54 ?s
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:minecraft ...
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:minecraft took 42.77 ?s
[12:47:05] [main/INFO]: Registering fluid subtypes: create:jei_plugin ...
[12:47:05] [main/INFO]: Registering fluid subtypes: create:jei_plugin took 2.085 ms
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:debug ...
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:debug took 1.671 ms
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:internal ...
[12:47:05] [main/INFO]: Registering fluid subtypes: jei:internal took 13.69 ?s
[12:47:05] [main/INFO]: Registering ingredients: jei:minecraft ...
[12:47:05] [main/INFO]: Registering ingredients: jei:minecraft took 244.7 ms
[12:47:05] [main/INFO]: Registering ingredients: create:jei_plugin ...
[12:47:05] [main/INFO]: Registering ingredients: create:jei_plugin took 19.25 ?s
[12:47:05] [main/INFO]: Registering ingredients: jei:debug ...
[12:47:05] [main/INFO]: Registering ingredients: jei:debug took 83.40 ?s
[12:47:05] [main/INFO]: Registering ingredients: jei:internal ...
[12:47:05] [main/INFO]: Registering ingredients: jei:internal took 13.69 ?s
[12:47:05] [main/INFO]: Registering categories: jei:minecraft ...
[12:47:06] [Server thread/WARN]: Can't keep up! Is the server overloaded? Running 2578ms or 51 ticks behind
[12:47:06] [Server thread/INFO]: Saving and pausing game...
[12:47:06] [main/INFO]: Registering categories: jei:minecraft took 289.3 ms
[12:47:06] [main/INFO]: Registering categories: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering categories: create:jei_plugin took 30.68 ms
[12:47:06] [main/INFO]: Registering categories: jei:debug ...
[12:47:06] [main/INFO]: Registering categories: jei:debug took 22.67 ?s
[12:47:06] [main/INFO]: Registering categories: jei:internal ...
[12:47:06] [main/INFO]: Registering categories: jei:internal took 6.502 ms
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:minecraft ...
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:minecraft took 9.155 ms
[12:47:06] [main/INFO]: Registering vanilla category extensions: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering vanilla category extensions: create:jei_plugin took 19.25 ?s
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:debug ...
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:debug took 15.82 ?s
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:internal ...
[12:47:06] [main/INFO]: Registering vanilla category extensions: jei:internal took 19.67 ?s
[12:47:06] [main/INFO]: Registering recipes: jei:minecraft ...
[12:47:06] [main/INFO]: Registering recipes: jei:minecraft took 388.1 ms
[12:47:06] [main/INFO]: Registering recipes: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering recipes: create:jei_plugin took 206.6 ms
[12:47:06] [main/INFO]: Registering recipes: jei:debug ...
[12:47:06] [main/INFO]: Registering recipes: jei:debug took 73.13 ?s
[12:47:06] [main/INFO]: Registering recipes: jei:internal ...
[12:47:06] [main/INFO]: Registering recipes: jei:internal took 14.97 ?s
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:minecraft ...
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:minecraft took 8.950 ms
[12:47:06] [main/INFO]: Registering recipes transfer handlers: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering recipes transfer handlers: create:jei_plugin took 2.025 ms
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:debug ...
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:debug took 17.54 ?s
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:internal ...
[12:47:06] [main/INFO]: Registering recipes transfer handlers: jei:internal took 11.98 ?s
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:minecraft ...
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:minecraft took 326.8 ?s
[12:47:06] [main/INFO]: Registering recipe catalysts: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering recipe catalysts: create:jei_plugin took 2.064 ms
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:debug ...
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:debug took 20.96 ?s
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:internal ...
[12:47:06] [main/INFO]: Registering recipe catalysts: jei:internal took 14.97 ?s
[12:47:06] [main/INFO]: Registering gui handlers: jei:minecraft ...
[12:47:06] [main/INFO]: Registering gui handlers: jei:minecraft took 12.49 ms
[12:47:06] [main/INFO]: Registering gui handlers: create:jei_plugin ...
[12:47:06] [main/INFO]: Registering gui handlers: create:jei_plugin took 3.994 ms
[12:47:06] [main/INFO]: Registering gui handlers: jei:debug ...
[12:47:06] [main/INFO]: Registering gui handlers: jei:debug took 20.10 ?s
[12:47:06] [main/INFO]: Registering gui handlers: jei:internal ...
[12:47:06] [main/INFO]: Registering gui handlers: jei:internal took 16.61 ms
[12:47:06] [main/INFO]: Registering advanced plugins: jei:minecraft ...
[12:47:06] [main/INFO]: Registering advanced plugins: jei:minecraft took 42.77 ?s
[12:47:06] [main/INFO]: Registering advanced plugins: create:jei_plugin ...
[12:47:07] [main/INFO]: Registering advanced plugins: create:jei_plugin took 51.32 ?s
[12:47:07] [main/INFO]: Registering advanced plugins: jei:debug ...
[12:47:07] [main/INFO]: Registering advanced plugins: jei:debug took 17.96 ?s
[12:47:07] [main/INFO]: Registering advanced plugins: jei:internal ...
[12:47:07] [main/INFO]: Registering advanced plugins: jei:internal took 11.98 ?s
[12:47:07] [main/INFO]: Building ingredient list...
[12:47:07] [main/INFO]: Building ingredient list took 14.05 ms
[12:47:07] [main/INFO]: Building ingredient filter...
[12:47:06] [Server thread/INFO]: Saving chunks for level 'ServerLevel[Pls work sad face]'/minecraft:overworld
[12:47:07] [main/INFO]: Building ingredient filter took 808.5 ms
[12:47:07] [main/INFO]: Building bookmarks...
[12:47:07] [main/INFO]: Building bookmarks took 3.388 ms
[12:47:07] [main/INFO]: Building recipe registry...
[12:47:08] [main/INFO]: Building recipe registry took 274.8 ms
[12:47:08] [main/INFO]: Building runtime...
[12:47:08] [main/INFO]: Building runtime took 132.3 ms
[12:47:08] [main/INFO]: Sending Runtime: jei:minecraft ...
[12:47:08] [main/INFO]: Sending Runtime: jei:minecraft took 81.26 ?s
[12:47:08] [main/INFO]: Sending Runtime: create:jei_plugin ...
[12:47:08] [main/INFO]: Sending Runtime: create:jei_plugin took 56.45 ?s
[12:47:08] [main/INFO]: Sending Runtime: jei:debug ...
[12:47:08] [main/INFO]: Sending Runtime: jei:debug took 149.3 ?s
[12:47:08] [main/INFO]: Sending Runtime: jei:internal ...
[12:47:08] [main/INFO]: Sending Runtime: jei:internal took 74.42 ?s
[12:47:08] [main/INFO]: Starting JEI took 2.862 s
[12:47:09] [main/INFO]: No shader config found.
[12:47:09] [Server thread/INFO]: Saving chunks for level 'ServerLevel[Pls work sad face]'/minecraft:the_nether
[12:47:11] [Server thread/INFO]: Saving chunks for level 'ServerLevel[Pls work sad face]'/minecraft:the_end
[12:47:11] [main/INFO]: Loaded 18 advancements
