babylon.quarks 0.17.4 → 0.17.7

package/src/shaders/chunks/tile_pars_vertex.glsl.ts

@@ -1,28 +1,28 @@
-export default /* glsl */ `
-#ifdef UV_TILE
-    attribute float uvTile;
-    uniform vec2 tileCount;
-
-    mat3 makeTileTransform(float tileIndex) {
-        float col = mod(tileIndex, tileCount.x);
-        float row = (tileCount.y - floor(tileIndex / tileCount.x) - 1.0);
-        return mat3(
-            1.0 / tileCount.x, 0.0, 0.0,
-            0.0, 1.0 / tileCount.y, 0.0,
-            col / tileCount.x, row / tileCount.y, 1.0
-        );
-    }
-#else
-    mat3 makeTileTransform(float tileIndex) {
-        return mat3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    }
-#endif
-
-#if defined(USE_UV)
-    varying vec2 vUv;
-    #ifdef TILE_BLEND
-        varying vec2 vUvNext;
-        varying float vUvBlend;
-    #endif
-#endif
-`;
+export default /* glsl */ `
+#ifdef UV_TILE
+    attribute float uvTile;
+    uniform vec2 tileCount;
+
+    mat3 makeTileTransform(float tileIndex) {
+        float col = mod(tileIndex, tileCount.x);
+        float row = (tileCount.y - floor(tileIndex / tileCount.x) - 1.0);
+        return mat3(
+            1.0 / tileCount.x, 0.0, 0.0,
+            0.0, 1.0 / tileCount.y, 0.0,
+            col / tileCount.x, row / tileCount.y, 1.0
+        );
+    }
+#else
+    mat3 makeTileTransform(float tileIndex) {
+        return mat3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    }
+#endif
+
+#if defined(USE_UV)
+    varying vec2 vUv;
+    #ifdef TILE_BLEND
+        varying vec2 vUvNext;
+        varying float vUvBlend;
+    #endif
+#endif
+`;

package/src/shaders/chunks/tile_vertex.glsl.ts

@@ -1,18 +1,18 @@
-export default /* glsl */ `
-#ifdef UV_TILE
-    mat3 tileTransform = makeTileTransform(floor(uvTile));
-    #ifdef TILE_BLEND
-        mat3 nextTileTransform = makeTileTransform(ceil(uvTile));
-        vUvBlend = fract(uvTile);
-    #endif
-#else
-    mat3 tileTransform = makeTileTransform(0.0);
-#endif
-
-#if defined(USE_UV)
-    vUv = (tileTransform * vec3(uv, 1.0)).xy;
-    #if defined(TILE_BLEND) && defined(UV_TILE)
-        vUvNext = (nextTileTransform * vec3(uv, 1.0)).xy;
-    #endif
-#endif
-`;
+export default /* glsl */ `
+#ifdef UV_TILE
+    mat3 tileTransform = makeTileTransform(floor(uvTile));
+    #ifdef TILE_BLEND
+        mat3 nextTileTransform = makeTileTransform(ceil(uvTile));
+        vUvBlend = fract(uvTile);
+    #endif
+#else
+    mat3 tileTransform = makeTileTransform(0.0);
+#endif
+
+#if defined(USE_UV)
+    vUv = (tileTransform * vec3(uv, 1.0)).xy;
+    #if defined(TILE_BLEND) && defined(UV_TILE)
+        vUvNext = (nextTileTransform * vec3(uv, 1.0)).xy;
+    #endif
+#endif
+`;

package/src/shaders/index.ts

@@ -1,9 +1,9 @@
-export * from './chunks';
-export {default as particleVertShader} from './particle_vert.glsl';
-export {default as particleFragShader} from './particle_frag.glsl';
-export {default as localParticleVertShader} from './local_particle_vert.glsl';
-export {default as localParticlePhysicsVertShader} from './local_particle_physics_vert.glsl';
-export {default as particlePhysicsFragShader} from './particle_physics_frag.glsl';
-export {default as stretchedBillboardVertShader} from './stretched_bb_particle_vert.glsl';
-export {default as trailVertShader} from './trail_vert.glsl';
-export {default as trailFragShader} from './trail_frag.glsl';
+export * from './chunks';
+export {default as particleVertShader} from './particle_vert.glsl';
+export {default as particleFragShader} from './particle_frag.glsl';
+export {default as localParticleVertShader} from './local_particle_vert.glsl';
+export {default as localParticlePhysicsVertShader} from './local_particle_physics_vert.glsl';
+export {default as particlePhysicsFragShader} from './particle_physics_frag.glsl';
+export {default as stretchedBillboardVertShader} from './stretched_bb_particle_vert.glsl';
+export {default as trailVertShader} from './trail_vert.glsl';
+export {default as trailFragShader} from './trail_frag.glsl';

package/src/shaders/local_particle_physics_vert.glsl.ts

@@ -1,79 +1,79 @@
-export default /* glsl */ `
-attribute vec3 position;
-attribute vec2 uv;
-attribute vec3 normal;
-attribute vec3 offset;
-attribute vec4 color;
-attribute vec3 size;
-attribute vec4 rotation;
-attribute float uvTile;
-
-uniform mat4 world;
-uniform mat4 view;
-uniform mat4 projection;
-
-#ifdef UV_TILE
-uniform float tileCountX;
-uniform float tileCountY;
-#endif
-
-varying vec2 vUV;
-varying vec4 vColor;
-varying vec3 vNormal;
-varying vec3 vWorldPos;
-
-#ifdef TILE_BLEND
-varying vec2 vUV2;
-varying float vTileBlend;
-#endif
-
-#ifdef SOFT_PARTICLES
-varying vec4 projPosition;
-varying float linearDepth;
-#endif
-
-vec3 applyQuaternion(vec3 v, vec4 q) {
-    vec3 qVec = q.xyz;
-    float qW = q.w;
-    vec3 t = 2.0 * cross(qVec, v);
-    return v + qW * t + cross(qVec, t);
-}
-
-void main() {
-    vec3 scaledPosition = position * size;
-    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);
-    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));
-    vec3 localPos = rotatedPosition + offset;
-
-    vec4 worldPos = world * vec4(localPos, 1.0);
-    vec4 viewPos = view * worldPos;
-    gl_Position = projection * viewPos;
-
-    vWorldPos = worldPos.xyz;
-    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);
-
-#ifdef SOFT_PARTICLES
-    projPosition = gl_Position;
-    linearDepth = -viewPos.z;
-#endif
-
-#ifdef UV_TILE
-    vec2 tc = vec2(tileCountX, tileCountY);
-    float baseTile = floor(uvTile);
-    float tileU = mod(baseTile, tc.x) / tc.x;
-    float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
-    vUV = uv / tc + vec2(tileU, tileV);
-    #ifdef TILE_BLEND
-        float nextTile = ceil(uvTile);
-        float nextU = mod(nextTile, tc.x) / tc.x;
-        float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
-        vUV2 = uv / tc + vec2(nextU, nextV);
-        vTileBlend = fract(uvTile);
-    #endif
-#else
-    vUV = uv;
-#endif
-
-    vColor = color;
-}
-`;
+export default /* glsl */ `
+attribute vec3 position;
+attribute vec2 uv;
+attribute vec3 normal;
+attribute vec3 offset;
+attribute vec4 color;
+attribute vec3 size;
+attribute vec4 rotation;
+attribute float uvTile;
+
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 projection;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying vec3 vNormal;
+varying vec3 vWorldPos;
+
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+
+#ifdef SOFT_PARTICLES
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+vec3 applyQuaternion(vec3 v, vec4 q) {
+    vec3 qVec = q.xyz;
+    float qW = q.w;
+    vec3 t = 2.0 * cross(qVec, v);
+    return v + qW * t + cross(qVec, t);
+}
+
+void main() {
+    vec3 scaledPosition = position * size;
+    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);
+    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));
+    vec3 localPos = rotatedPosition + offset;
+
+    vec4 worldPos = world * vec4(localPos, 1.0);
+    vec4 viewPos = view * worldPos;
+    gl_Position = projection * viewPos;
+
+    vWorldPos = worldPos.xyz;
+    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);
+
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -viewPos.z;
+#endif
+
+#ifdef UV_TILE
+    vec2 tc = vec2(tileCountX, tileCountY);
+    float baseTile = floor(uvTile);
+    float tileU = mod(baseTile, tc.x) / tc.x;
+    float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
+    vUV = uv / tc + vec2(tileU, tileV);
+    #ifdef TILE_BLEND
+        float nextTile = ceil(uvTile);
+        float nextU = mod(nextTile, tc.x) / tc.x;
+        float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
+        vUV2 = uv / tc + vec2(nextU, nextV);
+        vTileBlend = fract(uvTile);
+    #endif
+#else
+    vUV = uv;
+#endif
+
+    vColor = color;
+}
+`;

package/src/shaders/local_particle_vert.glsl.ts

@@ -1,50 +1,50 @@
-export default /* glsl */ `
-// Per-vertex attributes
-attribute vec3 position;
-attribute vec2 uv;
-
-// Per-instance attributes
-attribute vec3 offset;
-attribute vec4 color;
-attribute vec3 size;
-attribute vec4 rotation;
-attribute float uvTile;
-
-// Uniforms
-uniform mat4 worldViewProjection;
-
-#ifdef UV_TILE
-uniform float tileCountX;
-uniform float tileCountY;
-#endif
-
-// Varyings
-varying vec2 vUV;
-varying vec4 vColor;
-
-vec3 applyQuaternion(vec3 v, vec4 q) {
-    vec3 qVec = q.xyz;
-    float qW = q.w;
-    vec3 t = 2.0 * cross(qVec, v);
-    return v + qW * t + cross(qVec, t);
-}
-
-void main() {
-    vec3 rotatedPosition = applyQuaternion(position * size, rotation);
-    vec3 worldPos = rotatedPosition + offset;
-
-    gl_Position = worldViewProjection * vec4(worldPos, 1.0);
-
-    #ifdef UV_TILE
-        vec2 tc = vec2(tileCountX, tileCountY);
-        float baseTile = floor(uvTile);
-        float tileU = mod(baseTile, tc.x) / tc.x;
-        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
-        vUV = uv / tc + vec2(tileU, tileV);
-    #else
-        vUV = uv;
-    #endif
-
-    vColor = color;
-}
-`;
+export default /* glsl */ `
+// Per-vertex attributes
+attribute vec3 position;
+attribute vec2 uv;
+
+// Per-instance attributes
+attribute vec3 offset;
+attribute vec4 color;
+attribute vec3 size;
+attribute vec4 rotation;
+attribute float uvTile;
+
+// Uniforms
+uniform mat4 worldViewProjection;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+// Varyings
+varying vec2 vUV;
+varying vec4 vColor;
+
+vec3 applyQuaternion(vec3 v, vec4 q) {
+    vec3 qVec = q.xyz;
+    float qW = q.w;
+    vec3 t = 2.0 * cross(qVec, v);
+    return v + qW * t + cross(qVec, t);
+}
+
+void main() {
+    vec3 rotatedPosition = applyQuaternion(position * size, rotation);
+    vec3 worldPos = rotatedPosition + offset;
+
+    gl_Position = worldViewProjection * vec4(worldPos, 1.0);
+
+    #ifdef UV_TILE
+        vec2 tc = vec2(tileCountX, tileCountY);
+        float baseTile = floor(uvTile);
+        float tileU = mod(baseTile, tc.x) / tc.x;
+        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
+        vUV = uv / tc + vec2(tileU, tileV);
+    #else
+        vUV = uv;
+    #endif
+
+    vColor = color;
+}
+`;

package/src/shaders/particle_frag.glsl.ts

@@ -1,61 +1,61 @@
-export default /* glsl */ `
-varying vec2 vUV;
-varying vec4 vColor;
-
-#ifdef TILE_BLEND
-varying vec2 vUV2;
-varying float vTileBlend;
-#endif
-
-#ifdef USE_MAP
-uniform sampler2D map;
-#endif
-
-#ifdef SOFT_PARTICLES
-uniform sampler2D depthTexture;
-uniform vec2 softParams;
-uniform vec4 projParams;
-varying vec4 projPosition;
-varying float linearDepth;
-#endif
-
-#ifdef USE_ALPHATEST
-uniform float alphaTest;
-#endif
-
-void main() {
-    vec4 baseColor = vColor;
-
-#ifdef USE_MAP
-    vec4 texColor = texture2D(map, vUV);
-    #ifdef TILE_BLEND
-        vec4 texColor2 = texture2D(map, vUV2);
-        texColor = mix(texColor, texColor2, vTileBlend);
-    #endif
-    baseColor *= texColor;
-#endif
-
-#ifdef USE_COLOR_AS_ALPHA
-    baseColor.a *= (baseColor.r + baseColor.g + baseColor.b) / 3.0;
-#endif
-
-#ifdef USE_ALPHATEST
-    if (baseColor.a < alphaTest) discard;
-#else
-    if (baseColor.a < 0.01) discard;
-#endif
-
-    gl_FragColor = baseColor;
-
-#ifdef SOFT_PARTICLES
-    vec2 p2 = projPosition.xy / projPosition.w;
-    p2 = 0.5 * p2 + 0.5;
-    float readDepth = texture2D(depthTexture, p2.xy).r;
-    float zNear = projParams.x;
-    float zFar = projParams.y;
-    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
-    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);
-    gl_FragColor *= fade;
-#endif
-}
-`;
+export default /* glsl */ `
+varying vec2 vUV;
+varying vec4 vColor;
+
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+
+#ifdef USE_MAP
+uniform sampler2D map;
+#endif
+
+#ifdef SOFT_PARTICLES
+uniform sampler2D depthTexture;
+uniform vec2 softParams;
+uniform vec4 projParams;
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+#ifdef USE_ALPHATEST
+uniform float alphaTest;
+#endif
+
+void main() {
+    vec4 baseColor = vColor;
+
+#ifdef USE_MAP
+    vec4 texColor = texture2D(map, vUV);
+    #ifdef TILE_BLEND
+        vec4 texColor2 = texture2D(map, vUV2);
+        texColor = mix(texColor, texColor2, vTileBlend);
+    #endif
+    baseColor *= texColor;
+#endif
+
+#ifdef USE_COLOR_AS_ALPHA
+    baseColor.a *= (baseColor.r + baseColor.g + baseColor.b) / 3.0;
+#endif
+
+#ifdef USE_ALPHATEST
+    if (baseColor.a < alphaTest) discard;
+#else
+    if (baseColor.a < 0.01) discard;
+#endif
+
+    gl_FragColor = baseColor;
+
+#ifdef SOFT_PARTICLES
+    vec2 p2 = projPosition.xy / projPosition.w;
+    p2 = 0.5 * p2 + 0.5;
+    float readDepth = texture2D(depthTexture, p2.xy).r;
+    float zNear = projParams.x;
+    float zFar = projParams.y;
+    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
+    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);
+    gl_FragColor *= fade;
+#endif
+}
+`;

package/src/shaders/particle_physics_frag.glsl.ts

@@ -1,67 +1,67 @@
-export default /* glsl */ `
-varying vec2 vUV;
-varying vec4 vColor;
-varying vec3 vNormal;
-
-uniform vec3 lightDirection;
-uniform vec3 lightColor;
-uniform vec3 ambientColor;
-
-#ifdef TILE_BLEND
-varying vec2 vUV2;
-varying float vTileBlend;
-#endif
-
-#ifdef USE_MAP
-uniform sampler2D map;
-#endif
-
-#ifdef SOFT_PARTICLES
-uniform sampler2D depthTexture;
-uniform vec2 softParams;
-uniform vec4 projParams;
-varying vec4 projPosition;
-varying float linearDepth;
-#endif
-
-#ifdef USE_ALPHATEST
-uniform float alphaTest;
-#endif
-
-void main() {
-    vec4 baseColor = vColor;
-
-#ifdef USE_MAP
-    vec4 texColor = texture2D(map, vUV);
-    #ifdef TILE_BLEND
-        vec4 texColor2 = texture2D(map, vUV2);
-        texColor = mix(texColor, texColor2, vTileBlend);
-    #endif
-    baseColor *= texColor;
-#endif
-
-#ifdef USE_ALPHATEST
-    if (baseColor.a < alphaTest) discard;
-#else
-    if (baseColor.a < 0.01) discard;
-#endif
-
-    vec3 N = normalize(vNormal);
-    vec3 L = normalize(-lightDirection);
-    float NdotL = max(dot(N, L), 0.0);
-    vec3 litColor = ambientColor + lightColor * NdotL;
-
-    gl_FragColor = vec4(baseColor.rgb * litColor, baseColor.a);
-
-#ifdef SOFT_PARTICLES
-    vec2 p2 = projPosition.xy / projPosition.w;
-    p2 = 0.5 * p2 + 0.5;
-    float readDepth = texture2D(depthTexture, p2.xy).r;
-    float zNear = projParams.x;
-    float zFar = projParams.y;
-    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
-    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);
-    gl_FragColor *= fade;
-#endif
-}
-`;
+export default /* glsl */ `
+varying vec2 vUV;
+varying vec4 vColor;
+varying vec3 vNormal;
+
+uniform vec3 lightDirection;
+uniform vec3 lightColor;
+uniform vec3 ambientColor;
+
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+
+#ifdef USE_MAP
+uniform sampler2D map;
+#endif
+
+#ifdef SOFT_PARTICLES
+uniform sampler2D depthTexture;
+uniform vec2 softParams;
+uniform vec4 projParams;
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+#ifdef USE_ALPHATEST
+uniform float alphaTest;
+#endif
+
+void main() {
+    vec4 baseColor = vColor;
+
+#ifdef USE_MAP
+    vec4 texColor = texture2D(map, vUV);
+    #ifdef TILE_BLEND
+        vec4 texColor2 = texture2D(map, vUV2);
+        texColor = mix(texColor, texColor2, vTileBlend);
+    #endif
+    baseColor *= texColor;
+#endif
+
+#ifdef USE_ALPHATEST
+    if (baseColor.a < alphaTest) discard;
+#else
+    if (baseColor.a < 0.01) discard;
+#endif
+
+    vec3 N = normalize(vNormal);
+    vec3 L = normalize(-lightDirection);
+    float NdotL = max(dot(N, L), 0.0);
+    vec3 litColor = ambientColor + lightColor * NdotL;
+
+    gl_FragColor = vec4(baseColor.rgb * litColor, baseColor.a);
+
+#ifdef SOFT_PARTICLES
+    vec2 p2 = projPosition.xy / projPosition.w;
+    p2 = 0.5 * p2 + 0.5;
+    float readDepth = texture2D(depthTexture, p2.xy).r;
+    float zNear = projParams.x;
+    float zFar = projParams.y;
+    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
+    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);
+    gl_FragColor *= fade;
+#endif
+}
+`;