Jump to content

Create crashes when something moves


VuIpes

Recommended Posts

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
 

Link to comment
Share on other sites

Guest
This topic is now closed to further replies.

Announcements



  • Recently Browsing

    • No registered users viewing this page.
  • Posts

    • Hello, I want to add more memory to the RunClient gradle task. I added VM options into the configurations and put in "-Xms256m -Xmx2048m" but it doesn't work.
    • Hello, I'm trying to modify the effects of native enchantments for bows and arrows in Minecraft. After using a decompilation tool, I found that the specific implementations of native bow and arrow enchantments (including `ArrowDamageEnchantment`, `ArrowKnockbackEnchantment`, `ArrowFireEnchantment`, `ArrowInfiniteEnchantment`, `ArrowPiercingEnchantment`) do not contain any information about the enchantment effects (such as the `getDamageProtection` function for `ProtectionEnchantment`, `getDamageBonus` function for `DamageEnchantment`, etc.). Upon searching for the base class of arrows, `AbstractArrow`, I found a function named setEnchantmentEffectsFromEntity`, which seems to be used to retrieve the enchantment levels of the tool held by a `LivingEntity` and calculate the specific values of the enchantment effects. However, after testing with the following code, I found that this function is not being called:   @Mixin(AbstractArrow.class) public class ModifyArrowEnchantmentEffects {     private static final Logger LOGGER = LogUtils.getLogger();     @Inject(         method = "setEnchantmentEffectsFromEntity",         at = @At("HEAD")     )     private void logArrowEnchantmentEffectsFromEntity(CallbackInfo ci) {         LOGGER.info("Arrow enchantment effects from entity");     } }   Upon further investigation, I found that within the onHitEntity method, there are several lines of code:               if (!this.level().isClientSide && entity1 instanceof LivingEntity) {                EnchantmentHelper.doPostHurtEffects(livingentity, entity1);                EnchantmentHelper.doPostDamageEffects((LivingEntity)entity1, livingentity);             }   These lines of code actually call the doPostHurt and doPostAttack methods of each enchantment in the enchantment list. However, this leads back to the issue because native bow and arrow enchantments do not implement these functions. Although their base class defines the functions, they are empty. At this point, I'm completely stumped and seeking assistance. Thank you.
    • I have been trying to make a server with forge but I keep running into an issue. I have jdk 22 installed as well as Java 8. here is the debug file  
    • it crashed again     What the console says : [00:02:03] [Server thread/INFO] [Easy NPC/]: [EntityManager] Server started! [00:02:03] [Server thread/INFO] [co.gi.al.ic.IceAndFire/]: {iceandfire:fire_dragon_roost=true, iceandfire:fire_lily=true, iceandfire:spawn_dragon_skeleton_fire=true, iceandfire:lightning_dragon_roost=true, iceandfire:spawn_dragon_skeleton_lightning=true, iceandfire:ice_dragon_roost=true, iceandfire:ice_dragon_cave=true, iceandfire:lightning_dragon_cave=true, iceandfire:cyclops_cave=true, iceandfire:spawn_wandering_cyclops=true, iceandfire:spawn_sea_serpent=true, iceandfire:frost_lily=true, iceandfire:hydra_cave=true, iceandfire:lightning_lily=true, iceandfireixie_village=true, iceandfire:myrmex_hive_jungle=true, iceandfire:myrmex_hive_desert=true, iceandfire:silver_ore=true, iceandfire:siren_island=true, iceandfire:spawn_dragon_skeleton_ice=true, iceandfire:spawn_stymphalian_bird=true, iceandfire:fire_dragon_cave=true, iceandfire:sapphire_ore=true, iceandfire:spawn_hippocampus=true, iceandfire:spawn_death_worm=true} [00:02:03] [Server thread/INFO] [co.gi.al.ic.IceAndFire/]: {TROLL_S=true, HIPPOGRYPH=true, AMPHITHERE=true, COCKATRICE=true, TROLL_M=true, DREAD_LICH=true, TROLL_F=true} [00:02:03] [Server thread/INFO] [ne.be.lo.WeaponRegistry/]: Encoded Weapon Attribute registry size (with package overhead): 41976 bytes (in 5 string chunks with the size of 10000) [00:02:03] [Server thread/INFO] [patchouli/]: Sending reload packet to clients [00:02:03] [Server thread/WARN] [voicechat/]: [voicechat] Running in offline mode - Voice chat encryption is not secure! [00:02:03] [VoiceChatServerThread/INFO] [voicechat/]: [voicechat] Using server-ip as bind address: 0.0.0.0 [00:02:03] [Server thread/WARN] [ModernFix/]: Dedicated server took 22.521 seconds to load [00:02:03] [VoiceChatServerThread/INFO] [voicechat/]: [voicechat] Voice chat server started at 0.0.0.0:25565 [00:02:03] [Server thread/WARN] [minecraft/SynchedEntityData]: defineId called for: class net.minecraft.world.entity.player.Player from class tschipp.carryon.common.carry.CarryOnDataManager [00:02:03] [Server thread/INFO] [ne.mi.co.AdvancementLoadFix/]: Using new advancement loading for net.minecraft.server.PlayerAdvancements@2941ffd5 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 0 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 1 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 2 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 3 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 4 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 5 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 6 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 7 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 8 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 9 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 10 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 11 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 12 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 13 [00:02:10] [Netty Epoll Server IO #2/INFO] [Calio/]: Received acknowledgment for login packet with id 14 [00:02:19] [Server thread/INFO] [ne.mi.co.AdvancementLoadFix/]: Using new advancement loading for net.minecraft.server.PlayerAdvancements@ebc7ef2 [00:02:19] [Server thread/INFO] [minecraft/PlayerList]: ZacAdos[/90.2.17.162:49242] logged in with entity id 1062 at (-1848.6727005281205, 221.0, -3054.2468255848935) [00:02:19] [Server thread/ERROR] [ModernFix/]: Skipping entity ID sync for com.talhanation.smallships.world.entity.ship.Ship: java.lang.NoClassDefFoundError: net/minecraft/client/CameraType [00:02:19] [Server thread/INFO] [minecraft/MinecraftServer]: - Gloop - ZacAdos joined the game [00:02:19] [Server thread/INFO] [xa.pa.OpenPartiesAndClaims/]: Updating all forceload tickets for cc56befd-d376-3526-a760-340713c478bd [00:02:19] [Server thread/INFO] [se.mi.te.da.DataManager/]: Sending data to client: ZacAdos [00:02:19] [Server thread/INFO] [voicechat/]: [voicechat] Received secret request of - Gloop - ZacAdos (17) [00:02:19] [Server thread/INFO] [voicechat/]: [voicechat] Sent secret to - Gloop - ZacAdos [00:02:21] [VoiceChatPacketProcessingThread/INFO] [voicechat/]: [voicechat] Successfully authenticated player cc56befd-d376-3526-a760-340713c478bd [00:02:22] [VoiceChatPacketProcessingThread/INFO] [voicechat/]: [voicechat] Successfully validated connection of player cc56befd-d376-3526-a760-340713c478bd [00:02:22] [VoiceChatPacketProcessingThread/INFO] [voicechat/]: [voicechat] Player - Gloop - ZacAdos (cc56befd-d376-3526-a760-340713c478bd) successfully connected to voice chat stop [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Stopping the server [00:02:34] [Server thread/INFO] [mo.pl.ar.ArmourersWorkshop/]: stop local service [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Stopping server [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Saving players [00:02:34] [Server thread/INFO] [minecraft/ServerGamePacketListenerImpl]: ZacAdos lost connection: Server closed [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: - Gloop - ZacAdos left the game [00:02:34] [Server thread/INFO] [xa.pa.OpenPartiesAndClaims/]: Updating all forceload tickets for cc56befd-d376-3526-a760-340713c478bd [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Saving worlds [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Saving chunks for level 'ServerLevel[world]'/minecraft:overworld [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Saving chunks for level 'ServerLevel[world]'/minecraft:the_end [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: Saving chunks for level 'ServerLevel[world]'/minecraft:the_nether [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: ThreadedAnvilChunkStorage (world): All chunks are saved [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: ThreadedAnvilChunkStorage (DIM1): All chunks are saved [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: ThreadedAnvilChunkStorage (DIM-1): All chunks are saved [00:02:34] [Server thread/INFO] [minecraft/MinecraftServer]: ThreadedAnvilChunkStorage: All dimensions are saved [00:02:34] [Server thread/INFO] [xa.pa.OpenPartiesAndClaims/]: Stopping IO worker... [00:02:34] [Server thread/INFO] [xa.pa.OpenPartiesAndClaims/]: Stopped IO worker! [00:02:34] [Server thread/INFO] [Calio/]: Removing Dynamic Registries for: net.minecraft.server.dedicated.DedicatedServer@7dc879e1 [MineStrator Daemon]: Checking server disk space usage, this could take a few seconds... [MineStrator Daemon]: Updating process configuration files... [MineStrator Daemon]: Ensuring file permissions are set correctly, this could take a few seconds... [MineStrator Daemon]: Pulling Docker container image, this could take a few minutes to complete... [MineStrator Daemon]: Finished pulling Docker container image container@pterodactyl~ java -version openjdk version "17.0.10" 2024-01-16 OpenJDK Runtime Environment Temurin-17.0.10+7 (build 17.0.10+7) OpenJDK 64-Bit Server VM Temurin-17.0.10+7 (build 17.0.10+7, mixed mode, sharing) container@pterodactyl~ java -Xms128M -Xmx6302M -Dterminal.jline=false -Dterminal.ansi=true -Djline.terminal=jline.UnsupportedTerminal -p libraries/cpw/mods/bootstraplauncher/1.1.2/bootstraplauncher-1.1.2.jar:libraries/cpw/mods/securejarhandler/2.1.4/securejarhandler-2.1.4.jar:libraries/org/ow2/asm/asm-commons/9.5/asm-commons-9.5.jar:libraries/org/ow2/asm/asm-util/9.5/asm-util-9.5.jar:libraries/org/ow2/asm/asm-analysis/9.5/asm-analysis-9.5.jar:libraries/org/ow2/asm/asm-tree/9.5/asm-tree-9.5.jar:libraries/org/ow2/asm/asm/9.5/asm-9.5.jar:libraries/net/minecraftforge/JarJarFileSystems/0.3.16/JarJarFileSystems-0.3.16.jar --add-modules ALL-MODULE-PATH --add-opens java.base/java.util.jar=cpw.mods.securejarhandler --add-opens java.base/java.lang.invoke=cpw.mods.securejarhandler --add-exports java.base/sun.security.util=cpw.mods.securejarhandler --add-exports jdk.naming.dns/com.sun.jndi.dns=java.naming -Djava.net.preferIPv6Addresses=system -DignoreList=bootstraplauncher-1.1.2.jar,securejarhandler-2.1.4.jar,asm-commons-9.5.jar,asm-util-9.5.jar,asm-analysis-9.5.jar,asm-tree-9.5.jar,asm-9.5.jar,JarJarFileSystems-0.3.16.jar -DlibraryDirectory=libraries -DlegacyClassPath=libraries/cpw/mods/securejarhandler/2.1.4/securejarhandler-2.1.4.jar:libraries/org/ow2/asm/asm/9.5/asm-9.5.jar:libraries/org/ow2/asm/asm-commons/9.5/asm-commons-9.5.jar:libraries/org/ow2/asm/asm-tree/9.5/asm-tree-9.5.jar:libraries/org/ow2/asm/asm-util/9.5/asm-util-9.5.jar:libraries/org/ow2/asm/asm-analysis/9.5/asm-analysis-9.5.jar:libraries/net/minecraftforge/accesstransformers/8.0.4/accesstransformers-8.0.4.jar:libraries/org/antlr/antlr4-runtime/4.9.1/antlr4-runtime-4.9.1.jar:libraries/net/minecraftforge/eventbus/6.0.3/eventbus-6.0.3.jar:libraries/net/minecraftforge/forgespi/6.0.0/forgespi-6.0.0.jar:libraries/net/minecraftforge/coremods/5.0.1/coremods-5.0.1.jar:libraries/cpw/mods/modlauncher/10.0.8/modlauncher-10.0.8.jar:libraries/net/minecraftforge/unsafe/0.2.0/unsafe-0.2.0.jar:libraries/com/electronwill/night-config/core/3.6.4/core-3.6.4.jar:libraries/com/electronwill/night-config/toml/3.6.4/toml-3.6.4.jar:libraries/org/apache/maven/maven-artifact/3.8.5/maven-artifact-3.8.5.jar:libraries/net/jodah/typetools/0.8.3/typetools-0.8.3.jar:libraries/net/minecrell/terminalconsoleappender/1.2.0/terminalconsoleappender-1.2.0.jar:libraries/org/jline/jline-reader/3.12.1/jline-reader-3.12.1.jar:libraries/org/jline/jline-terminal/3.12.1/jline-terminal-3.12.1.jar:libraries/org/spongepowered/mixin/0.8.5/mixin-0.8.5.jar:libraries/org/openjdk/nashorn/nashorn-core/15.3/nashorn-core-15.3.jar:libraries/net/minecraftforge/JarJarSelector/0.3.16/JarJarSelector-0.3.16.jar:libraries/net/minecraftforge/JarJarMetadata/0.3.16/JarJarMetadata-0.3.16.jar:libraries/net/minecraftforge/fmlloader/1.19.2-43.3.0/fmlloader-1.19.2-43.3.0.jar:libraries/net/minecraft/server/1.19.2-20220805.130853/server-1.19.2-20220805.130853-extra.jar:libraries/com/github/oshi/oshi-core/5.8.5/oshi-core-5.8.5.jar:libraries/com/google/code/gson/gson/2.8.9/gson-2.8.9.jar:libraries/com/google/guava/failureaccess/1.0.1/failureaccess-1.0.1.jar:libraries/com/google/guava/guava/31.0.1-jre/guava-31.0.1-jre.jar:libraries/com/mojang/authlib/3.11.49/authlib-3.11.49.jar:libraries/com/mojang/brigadier/1.0.18/brigadier-1.0.18.jar:libraries/com/mojang/datafixerupper/5.0.28/datafixerupper-5.0.28.jar:libraries/com/mojang/javabridge/1.2.24/javabridge-1.2.24.jar:libraries/com/mojang/logging/1.0.0/logging-1.0.0.jar:libraries/commons-io/commons-io/2.11.0/commons-io-2.11.0.jar:libraries/io/netty/netty-buffer/4.1.77.Final/netty-buffer-4.1.77.Final.jar:libraries/io/netty/netty-codec/4.1.77.Final/netty-codec-4.1.77.Final.jar:libraries/io/netty/netty-common/4.1.77.Final/netty-common-4.1.77.Final.jar:libraries/io/netty/netty-handler/4.1.77.Final/netty-handler-4.1.77.Final.jar:libraries/io/netty/netty-resolver/4.1.77.Final/netty-resolver-4.1.77.Final.jar:libraries/io/netty/netty-transport/4.1.77.Final/netty-transport-4.1.77.Final.jar:libraries/io/netty/netty-transport-classes-epoll/4.1.77.Final/netty-transport-classes-epoll-4.1.77.Final.jar:libraries/io/netty/netty-transport-native-epoll/4.1.77.Final/netty-transport-native-epoll-4.1.77.Final-linux-x86_64.jar:libraries/io/netty/netty-transport-native-epoll/4.1.77.Final/netty-transport-native-epoll-4.1.77.Final-linux-aarch_64.jar:libraries/io/netty/netty-transport-native-unix-common/4.1.77.Final/netty-transport-native-unix-common-4.1.77.Final.jar:libraries/it/unimi/dsi/fastutil/8.5.6/fastutil-8.5.6.jar:libraries/net/java/dev/jna/jna/5.10.0/jna-5.10.0.jar:libraries/net/java/dev/jna/jna-platform/5.10.0/jna-platform-5.10.0.jar:libraries/net/sf/jopt-simple/jopt-simple/5.0.4/jopt-simple-5.0.4.jar:libraries/org/apache/commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar:libraries/org/apache/logging/log4j/log4j-api/2.17.0/log4j-api-2.17.0.jar:libraries/org/apache/logging/log4j/log4j-core/2.17.0/log4j-core-2.17.0.jar:libraries/org/apache/logging/log4j/log4j-slf4j18-impl/2.17.0/log4j-slf4j18-impl-2.17.0.jar:libraries/org/slf4j/slf4j-api/1.8.0-beta4/slf4j-api-1.8.0-beta4.jar cpw.mods.bootstraplauncher.BootstrapLauncher --launchTarget forgeserver --fml.forgeVersion 43.3.0 --fml.mcVersion 1.19.2 --fml.forgeGroup net.minecraftforge --fml.mcpVersion 20220805.130853 [00:02:42] [main/INFO] [cp.mo.mo.Launcher/MODLAUNCHER]: ModLauncher running: args [--launchTarget, forgeserver, --fml.forgeVersion, 43.3.0, --fml.mcVersion, 1.19.2, --fml.forgeGroup, net.minecraftforge, --fml.mcpVersion, 20220805.130853] [00:02:42] [main/INFO] [cp.mo.mo.Launcher/MODLAUNCHER]: ModLauncher 10.0.8+10.0.8+main.0ef7e830 starting: java version 17.0.10 by Eclipse Adoptium; OS Linux arch amd64 version 6.1.0-12-amd64 [00:02:43] [main/INFO] [mixin/]: SpongePowered MIXIN Subsystem Version=0.8.5 Source=union:/home/container/libraries/org/spongepowered/mixin/0.8.5/mixin-0.8.5.jar%2363!/ Service=ModLauncher Env=SERVER [00:02:43] [main/WARN] [ne.mi.fm.lo.mo.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/fmlcore/1.19.2-43.3.0/fmlcore-1.19.2-43.3.0.jar is missing mods.toml file [00:02:43] [main/WARN] [ne.mi.fm.lo.mo.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/javafmllanguage/1.19.2-43.3.0/javafmllanguage-1.19.2-43.3.0.jar is missing mods.toml file [00:02:43] [main/WARN] [ne.mi.fm.lo.mo.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/lowcodelanguage/1.19.2-43.3.0/lowcodelanguage-1.19.2-43.3.0.jar is missing mods.toml file [00:02:43] [main/WARN] [ne.mi.fm.lo.mo.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/mclanguage/1.19.2-43.3.0/mclanguage-1.19.2-43.3.0.jar is missing mods.toml file [00:02:44] [main/WARN] [ne.mi.ja.se.JarSelector/]: Attempted to select two dependency jars from JarJar which have the same identification: Mod File: and Mod File: . Using Mod File: [00:02:44] [main/WARN] [ne.mi.ja.se.JarSelector/]: Attempted to select a dependency jar for JarJar which was passed in as source: resourcefullib. Using Mod File: /home/container/mods/resourcefullib-forge-1.19.2-1.1.24.jar [00:02:44] [main/INFO] [ne.mi.fm.lo.mo.JarInJarDependencyLocator/]: Found 13 dependencies adding them to mods collection Latest log [29Mar2024 00:02:42.803] [main/INFO] [cpw.mods.modlauncher.Launcher/MODLAUNCHER]: ModLauncher running: args [--launchTarget, forgeserver, --fml.forgeVersion, 43.3.0, --fml.mcVersion, 1.19.2, --fml.forgeGroup, net.minecraftforge, --fml.mcpVersion, 20220805.130853] [29Mar2024 00:02:42.805] [main/INFO] [cpw.mods.modlauncher.Launcher/MODLAUNCHER]: ModLauncher 10.0.8+10.0.8+main.0ef7e830 starting: java version 17.0.10 by Eclipse Adoptium; OS Linux arch amd64 version 6.1.0-12-amd64 [29Mar2024 00:02:43.548] [main/INFO] [mixin/]: SpongePowered MIXIN Subsystem Version=0.8.5 Source=union:/home/container/libraries/org/spongepowered/mixin/0.8.5/mixin-0.8.5.jar%2363!/ Service=ModLauncher Env=SERVER [29Mar2024 00:02:43.876] [main/WARN] [net.minecraftforge.fml.loading.moddiscovery.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/fmlcore/1.19.2-43.3.0/fmlcore-1.19.2-43.3.0.jar is missing mods.toml file [29Mar2024 00:02:43.877] [main/WARN] [net.minecraftforge.fml.loading.moddiscovery.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/javafmllanguage/1.19.2-43.3.0/javafmllanguage-1.19.2-43.3.0.jar is missing mods.toml file [29Mar2024 00:02:43.877] [main/WARN] [net.minecraftforge.fml.loading.moddiscovery.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/lowcodelanguage/1.19.2-43.3.0/lowcodelanguage-1.19.2-43.3.0.jar is missing mods.toml file [29Mar2024 00:02:43.878] [main/WARN] [net.minecraftforge.fml.loading.moddiscovery.ModFileParser/LOADING]: Mod file /home/container/libraries/net/minecraftforge/mclanguage/1.19.2-43.3.0/mclanguage-1.19.2-43.3.0.jar is missing mods.toml file [29Mar2024 00:02:44.033] [main/WARN] [net.minecraftforge.jarjar.selection.JarSelector/]: Attempted to select two dependency jars from JarJar which have the same identification: Mod File: and Mod File: . Using Mod File: [29Mar2024 00:02:44.034] [main/WARN] [net.minecraftforge.jarjar.selection.JarSelector/]: Attempted to select a dependency jar for JarJar which was passed in as source: resourcefullib. Using Mod File: /home/container/mods/resourcefullib-forge-1.19.2-1.1.24.jar [29Mar2024 00:02:44.034] [main/INFO] [net.minecraftforge.fml.loading.moddiscovery.JarInJarDependencyLocator/]: Found 13 dependencies adding them to mods collection
  • Topics

×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.