VuIpes

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