molstar 4.2.0 → 4.3.0

package/lib/commonjs/mol-gl/shader/chunks/fade-lod.glsl.js

@@ -6,46 +6,46 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fade_lod = void 0;
-exports.fade_lod = `
-if (uLod.w == 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
-    float d = dot(uCameraPlane.xyz, vModelPosition) + uCameraPlane.w;
-    float ta = min(
-        smoothstep(uLod.x, uLod.x + uLod.z, d),
-        1.0 - smoothstep(uLod.y - uLod.z, uLod.y, d)
-    );
-
-    #if defined(dRenderVariant_color)
-        float at = 0.0;
-
-        // shift by view-offset during multi-sample rendering to allow for blending
-        vec2 coord = gl_FragCoord.xy + uViewOffset * 0.25;
-
-        const mat4 thresholdMatrix = mat4(
-            1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,
-            13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,
-            4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,
-            16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0
-        );
-        int ci = int(intMod(coord.x, 4.0));
-        int ri = int(intMod(coord.y, 4.0));
-        #if __VERSION__ == 100
-            vec4 i = vec4(float(ci * 4 + ri));
-            vec4 v = thresholdMatrix[0] * vec4(equal(i, vec4(0.0, 1.0, 2.0, 3.0))) +
-                thresholdMatrix[1] * vec4(equal(i, vec4(4.0, 5.0, 6.0, 7.0))) +
-                thresholdMatrix[2] * vec4(equal(i, vec4(8.0, 9.0, 10.0, 11.0))) +
-                thresholdMatrix[3] * vec4(equal(i, vec4(12.0, 13.0, 14.0, 15.0)));
-            at = v.x + v.y + v.z + v.w;
-        #else
-            at = thresholdMatrix[ci][ri];
-        #endif
-
-        if (ta < 0.99 && (ta < 0.01 || ta < at)) {
-            discard;
-        }
-    #else
-        if (ta < uPickingAlphaThreshold) {
-            discard;
-        }
-    #endif
-}
+exports.fade_lod = `
+if (uLod.w == 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
+    float d = dot(uCameraPlane.xyz, vModelPosition) + uCameraPlane.w;
+    float ta = min(
+        smoothstep(uLod.x, uLod.x + uLod.z, d),
+        1.0 - smoothstep(uLod.y - uLod.z, uLod.y, d)
+    );
+
+    #if defined(dRenderVariant_color)
+        float at = 0.0;
+
+        // shift by view-offset during multi-sample rendering to allow for blending
+        vec2 coord = gl_FragCoord.xy + uViewOffset * 0.25;
+
+        const mat4 thresholdMatrix = mat4(
+            1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,
+            13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,
+            4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,
+            16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0
+        );
+        int ci = int(intMod(coord.x, 4.0));
+        int ri = int(intMod(coord.y, 4.0));
+        #if __VERSION__ == 100
+            vec4 i = vec4(float(ci * 4 + ri));
+            vec4 v = thresholdMatrix[0] * vec4(equal(i, vec4(0.0, 1.0, 2.0, 3.0))) +
+                thresholdMatrix[1] * vec4(equal(i, vec4(4.0, 5.0, 6.0, 7.0))) +
+                thresholdMatrix[2] * vec4(equal(i, vec4(8.0, 9.0, 10.0, 11.0))) +
+                thresholdMatrix[3] * vec4(equal(i, vec4(12.0, 13.0, 14.0, 15.0)));
+            at = v.x + v.y + v.z + v.w;
+        #else
+            at = thresholdMatrix[ci][ri];
+        #endif
+
+        if (ta < 0.99 && (ta < 0.01 || ta < at)) {
+            discard;
+        }
+    #else
+        if (ta < uPickingAlphaThreshold) {
+            discard;
+        }
+    #endif
+}
 `;

package/lib/commonjs/mol-gl/shader/chunks/float-to-rgba.glsl.js

@@ -6,43 +6,43 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.float_to_rgba = void 0;
-exports.float_to_rgba = `
-    // floatToRgba adapted from https://github.com/equinor/glsl-float-to-rgba
-    // MIT License, Copyright (c) 2020 Equinor
-
-    float shiftRight (float v, float amt) {
-    v = floor(v) + 0.5;
-    return floor(v / exp2(amt));
-    }
-    float shiftLeft (float v, float amt) {
-        return floor(v * exp2(amt) + 0.5);
-    }
-    float maskLast (float v, float bits) {
-        return mod(v, shiftLeft(1.0, bits));
-    }
-    float extractBits (float num, float from, float to) {
-        from = floor(from + 0.5); to = floor(to + 0.5);
-        return maskLast(shiftRight(num, from), to - from);
-    }
-
-    vec4 floatToRgba(float texelFloat, bool littleEndian) {
-        if (texelFloat == 0.0) return vec4(0.0, 0.0, 0.0, 0.0);
-        float sign = texelFloat > 0.0 ? 0.0 : 1.0;
-        texelFloat = abs(texelFloat);
-        float exponent = floor(log2(texelFloat));
-        float biased_exponent = exponent + 127.0;
-        float fraction = ((texelFloat / exp2(exponent)) - 1.0) * 8388608.0;
-        float t = biased_exponent / 2.0;
-        float last_bit_of_biased_exponent = fract(t) * 2.0;
-        float remaining_bits_of_biased_exponent = floor(t);
-        float byte4 = extractBits(fraction, 0.0, 8.0) / 255.0;
-        float byte3 = extractBits(fraction, 8.0, 16.0) / 255.0;
-        float byte2 = (last_bit_of_biased_exponent * 128.0 + extractBits(fraction, 16.0, 23.0)) / 255.0;
-        float byte1 = (sign * 128.0 + remaining_bits_of_biased_exponent) / 255.0;
-        return (
-            littleEndian
-                ? vec4(byte4, byte3, byte2, byte1)
-                : vec4(byte1, byte2, byte3, byte4)
-        );
-    }
+exports.float_to_rgba = `
+    // floatToRgba adapted from https://github.com/equinor/glsl-float-to-rgba
+    // MIT License, Copyright (c) 2020 Equinor
+
+    float shiftRight (float v, float amt) {
+    v = floor(v) + 0.5;
+    return floor(v / exp2(amt));
+    }
+    float shiftLeft (float v, float amt) {
+        return floor(v * exp2(amt) + 0.5);
+    }
+    float maskLast (float v, float bits) {
+        return mod(v, shiftLeft(1.0, bits));
+    }
+    float extractBits (float num, float from, float to) {
+        from = floor(from + 0.5); to = floor(to + 0.5);
+        return maskLast(shiftRight(num, from), to - from);
+    }
+
+    vec4 floatToRgba(float texelFloat, bool littleEndian) {
+        if (texelFloat == 0.0) return vec4(0.0, 0.0, 0.0, 0.0);
+        float sign = texelFloat > 0.0 ? 0.0 : 1.0;
+        texelFloat = abs(texelFloat);
+        float exponent = floor(log2(texelFloat));
+        float biased_exponent = exponent + 127.0;
+        float fraction = ((texelFloat / exp2(exponent)) - 1.0) * 8388608.0;
+        float t = biased_exponent / 2.0;
+        float last_bit_of_biased_exponent = fract(t) * 2.0;
+        float remaining_bits_of_biased_exponent = floor(t);
+        float byte4 = extractBits(fraction, 0.0, 8.0) / 255.0;
+        float byte3 = extractBits(fraction, 8.0, 16.0) / 255.0;
+        float byte2 = (last_bit_of_biased_exponent * 128.0 + extractBits(fraction, 16.0, 23.0)) / 255.0;
+        float byte1 = (sign * 128.0 + remaining_bits_of_biased_exponent) / 255.0;
+        return (
+            littleEndian
+                ? vec4(byte4, byte3, byte2, byte1)
+                : vec4(byte1, byte2, byte3, byte4)
+        );
+    }
 `;

package/lib/commonjs/mol-gl/shader/chunks/light-frag-params.glsl.js

@@ -9,131 +9,131 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.light_frag_params = void 0;
-exports.light_frag_params = `
-#if dLightCount != 0
-    uniform vec3 uLightDirection[dLightCount];
-    uniform vec3 uLightColor[dLightCount];
-#endif
-uniform vec3 uAmbientColor;
-
-struct PhysicalMaterial {
-    vec3 diffuseColor;
-    float roughness;
-    vec3 specularColor;
-    float specularF90;
-};
-
-struct IncidentLight {
-    vec3 color;
-    vec3 direction;
-};
-
-struct ReflectedLight {
-    vec3 directDiffuse;
-    vec3 directSpecular;
-    vec3 indirectDiffuse;
-    vec3 indirectSpecular;
-};
-
-struct GeometricContext {
-    vec3 position;
-    vec3 normal;
-    vec3 viewDir;
-};
-
-vec3 BRDF_Lambert(const in vec3 diffuseColor) {
-    return RECIPROCAL_PI * diffuseColor;
-}
-
-vec3 F_Schlick(const in vec3 f0, const in float f90, const in float dotVH) {
-    // Original approximation by Christophe Schlick '94
-    // float fresnel = pow( 1.0 - dotVH, 5.0 );
-    // Optimized variant (presented by Epic at SIGGRAPH '13)
-    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
-    float fresnel = exp2((-5.55473 * dotVH - 6.98316) * dotVH);
-    return f0 * (1.0 - fresnel) + (f90 * fresnel);
-}
-
-// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
-// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
-float V_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {
-    float a2 = pow2(alpha);
-    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));
-    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));
-    return 0.5 / max(gv + gl, EPSILON);
-}
-
-// Microfacet Models for Refraction through Rough Surfaces - equation (33)
-// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
-// alpha is "roughness squared" in Disney’s reparameterization
-float D_GGX(const in float alpha, const in float dotNH) {
-    float a2 = pow2(alpha);
-    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1
-    return RECIPROCAL_PI * a2 / pow2(denom);
-}
-
-// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-vec3 BRDF_GGX(const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness) {
-    float alpha = pow2(roughness); // UE4's roughness
-    vec3 halfDir = normalize( lightDir + viewDir);
-    float dotNL = saturate(dot(normal, lightDir));
-    float dotNV = saturate(dot(normal, viewDir));
-    float dotNH = saturate(dot(normal, halfDir));
-    float dotVH = saturate(dot(viewDir, halfDir));
-    vec3 F = F_Schlick(f0, f90, dotVH);
-    float V = V_GGX_SmithCorrelated(alpha, dotNL, dotNV);
-    float D = D_GGX(alpha, dotNH);
-    return F * (V * D);
-}
-
-// Analytical approximation of the DFG LUT, one half of the
-// split-sum approximation used in indirect specular lighting.
-// via 'environmentBRDF' from "Physically Based Shading on Mobile"
-// https://www.unrealengine.com/blog/physically-based-shading-on-mobile
-vec2 DFGApprox(const in vec3 normal, const in vec3 viewDir, const in float roughness) {
-    float dotNV = saturate(dot(normal, viewDir));
-    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);
-    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);
-    vec4 r = roughness * c0 + c1;
-    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;
-    vec2 fab = vec2(-1.04, 1.04) * a004 + r.zw;
-    return fab;
-}
-
-// Fdez-Agüera's "Multiple-Scattering Microfacet Model for Real-Time Image Based Lighting"
-// Approximates multiscattering in order to preserve energy.
-// http://www.jcgt.org/published/0008/01/03/
-void computeMultiscattering(const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter) {
-    vec2 fab = DFGApprox(normal, viewDir, roughness);
-    vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
-    float Ess = fab.x + fab.y;
-    float Ems = 1.0 - Ess;
-    vec3 Favg = specularColor + (1.0 - specularColor) * 0.047619; // 1/21
-    vec3 Fms = FssEss * Favg / (1.0 - Ems * Favg);
-    singleScatter += FssEss;
-    multiScatter += Fms * Ems;
-}
-
-void RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
-    float dotNL = saturate(dot(geometry.normal, directLight.direction));
-    vec3 irradiance = dotNL * directLight.color;
-    reflectedLight.directSpecular += irradiance * BRDF_GGX(directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness);
-    reflectedLight.directDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);
-}
-
-void RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
-    reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);
-}
-
-void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
-    // Both indirect specular and indirect diffuse light accumulate here
-    vec3 singleScattering = vec3(0.0);
-    vec3 multiScattering = vec3(0.0);
-    vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
-    computeMultiscattering(geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering);
-    vec3 diffuse = material.diffuseColor * (1.0 - ( singleScattering + multiScattering));
-    reflectedLight.indirectSpecular += radiance * singleScattering;
-    reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
-    reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
-}
+exports.light_frag_params = `
+#if dLightCount != 0
+    uniform vec3 uLightDirection[dLightCount];
+    uniform vec3 uLightColor[dLightCount];
+#endif
+uniform vec3 uAmbientColor;
+
+struct PhysicalMaterial {
+    vec3 diffuseColor;
+    float roughness;
+    vec3 specularColor;
+    float specularF90;
+};
+
+struct IncidentLight {
+    vec3 color;
+    vec3 direction;
+};
+
+struct ReflectedLight {
+    vec3 directDiffuse;
+    vec3 directSpecular;
+    vec3 indirectDiffuse;
+    vec3 indirectSpecular;
+};
+
+struct GeometricContext {
+    vec3 position;
+    vec3 normal;
+    vec3 viewDir;
+};
+
+vec3 BRDF_Lambert(const in vec3 diffuseColor) {
+    return RECIPROCAL_PI * diffuseColor;
+}
+
+vec3 F_Schlick(const in vec3 f0, const in float f90, const in float dotVH) {
+    // Original approximation by Christophe Schlick '94
+    // float fresnel = pow( 1.0 - dotVH, 5.0 );
+    // Optimized variant (presented by Epic at SIGGRAPH '13)
+    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+    float fresnel = exp2((-5.55473 * dotVH - 6.98316) * dotVH);
+    return f0 * (1.0 - fresnel) + (f90 * fresnel);
+}
+
+// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
+// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+float V_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {
+    float a2 = pow2(alpha);
+    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));
+    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));
+    return 0.5 / max(gv + gl, EPSILON);
+}
+
+// Microfacet Models for Refraction through Rough Surfaces - equation (33)
+// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+// alpha is "roughness squared" in Disney’s reparameterization
+float D_GGX(const in float alpha, const in float dotNH) {
+    float a2 = pow2(alpha);
+    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1
+    return RECIPROCAL_PI * a2 / pow2(denom);
+}
+
+// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
+vec3 BRDF_GGX(const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness) {
+    float alpha = pow2(roughness); // UE4's roughness
+    vec3 halfDir = normalize( lightDir + viewDir);
+    float dotNL = saturate(dot(normal, lightDir));
+    float dotNV = saturate(dot(normal, viewDir));
+    float dotNH = saturate(dot(normal, halfDir));
+    float dotVH = saturate(dot(viewDir, halfDir));
+    vec3 F = F_Schlick(f0, f90, dotVH);
+    float V = V_GGX_SmithCorrelated(alpha, dotNL, dotNV);
+    float D = D_GGX(alpha, dotNH);
+    return F * (V * D);
+}
+
+// Analytical approximation of the DFG LUT, one half of the
+// split-sum approximation used in indirect specular lighting.
+// via 'environmentBRDF' from "Physically Based Shading on Mobile"
+// https://www.unrealengine.com/blog/physically-based-shading-on-mobile
+vec2 DFGApprox(const in vec3 normal, const in vec3 viewDir, const in float roughness) {
+    float dotNV = saturate(dot(normal, viewDir));
+    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);
+    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);
+    vec4 r = roughness * c0 + c1;
+    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;
+    vec2 fab = vec2(-1.04, 1.04) * a004 + r.zw;
+    return fab;
+}
+
+// Fdez-Agüera's "Multiple-Scattering Microfacet Model for Real-Time Image Based Lighting"
+// Approximates multiscattering in order to preserve energy.
+// http://www.jcgt.org/published/0008/01/03/
+void computeMultiscattering(const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter) {
+    vec2 fab = DFGApprox(normal, viewDir, roughness);
+    vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
+    float Ess = fab.x + fab.y;
+    float Ems = 1.0 - Ess;
+    vec3 Favg = specularColor + (1.0 - specularColor) * 0.047619; // 1/21
+    vec3 Fms = FssEss * Favg / (1.0 - Ems * Favg);
+    singleScatter += FssEss;
+    multiScatter += Fms * Ems;
+}
+
+void RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
+    float dotNL = saturate(dot(geometry.normal, directLight.direction));
+    vec3 irradiance = dotNL * directLight.color;
+    reflectedLight.directSpecular += irradiance * BRDF_GGX(directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness);
+    reflectedLight.directDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);
+}
+
+void RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
+    reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);
+}
+
+void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
+    // Both indirect specular and indirect diffuse light accumulate here
+    vec3 singleScattering = vec3(0.0);
+    vec3 multiScattering = vec3(0.0);
+    vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
+    computeMultiscattering(geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering);
+    vec3 diffuse = material.diffuseColor * (1.0 - ( singleScattering + multiScattering));
+    reflectedLight.indirectSpecular += radiance * singleScattering;
+    reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
+    reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
+}
 `;

package/lib/commonjs/mol-gl/shader/chunks/matrix-scale.glsl.js

@@ -6,9 +6,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matrix_scale = void 0;
-exports.matrix_scale = `
-float matrixScale(in mat4 m){
-    vec4 r = m[0];
-    return sqrt(r[0] * r[0] + r[1] * r[1] + r[2] * r[2]);
-}
+exports.matrix_scale = `
+float matrixScale(in mat4 m){
+    vec4 r = m[0];
+    return sqrt(r[0] * r[0] + r[1] * r[1] + r[2] * r[2]);
+}
 `;

package/lib/commonjs/mol-gl/shader/chunks/normal-frag-params.glsl.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normal_frag_params = void 0;
-exports.normal_frag_params = `
-varying vec3 vNormal;
+exports.normal_frag_params = `
+varying vec3 vNormal;
 `;

package/lib/commonjs/mol-gl/shader/chunks/read-from-texture.glsl.js

@@ -6,18 +6,18 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.read_from_texture = void 0;
-exports.read_from_texture = `
-vec4 readFromTexture(const in sampler2D tex, const in float i, const in vec2 dim) {
-    float x = intMod(i, dim.x);
-    float y = floor(intDiv(i, dim.x));
-    vec2 uv = (vec2(x, y) + 0.5) / dim;
-    return texture2D(tex, uv);
-}
-
-vec4 readFromTexture(const in sampler2D tex, const in int i, const in vec2 dim) {
-    int x = imod(i, int(dim.x));
-    int y = i / int(dim.x);
-    vec2 uv = (vec2(x, y) + 0.5) / dim;
-    return texture2D(tex, uv);
-}
+exports.read_from_texture = `
+vec4 readFromTexture(const in sampler2D tex, const in float i, const in vec2 dim) {
+    float x = intMod(i, dim.x);
+    float y = floor(intDiv(i, dim.x));
+    vec2 uv = (vec2(x, y) + 0.5) / dim;
+    return texture2D(tex, uv);
+}
+
+vec4 readFromTexture(const in sampler2D tex, const in int i, const in vec2 dim) {
+    int x = imod(i, int(dim.x));
+    int y = i / int(dim.x);
+    vec2 uv = (vec2(x, y) + 0.5) / dim;
+    return texture2D(tex, uv);
+}
 `;