babylon.quarks 0.17.0

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

@@ -0,0 +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
+`;

package/src/shaders/index.ts

@@ -0,0 +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';

package/src/shaders/local_particle_physics_vert.glsl.ts

@@ -0,0 +1,66 @@
+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 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 tileU = mod(uvTile, tc.x) / tc.x;
+    float tileV = 1.0 - floor(uvTile / tc.x) / tc.y - 1.0 / tc.y;
+    vUV = uv / tc + vec2(tileU, tileV);
+#else
+    vUV = uv;
+#endif
+
+    vColor = color;
+}
+`;

package/src/shaders/local_particle_vert.glsl.ts

@@ -0,0 +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;
+}
+`;

package/src/shaders/particle_frag.glsl.ts

@@ -0,0 +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
+}
+`;

package/src/shaders/particle_physics_frag.glsl.ts

@@ -0,0 +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
+}
+`;

package/src/shaders/particle_vert.glsl.ts

@@ -0,0 +1,85 @@
+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 float rotation;
+attribute float uvTile;
+
+// Uniforms
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat4 worldViewProjection;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+// Varyings
+varying vec2 vUV;
+varying vec4 vColor;
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+#ifdef SOFT_PARTICLES
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+void main() {
+    float c = cos(rotation);
+    float s = sin(rotation);
+
+    vec2 alignedPosition = position.xy * size.xy;
+    vec2 rotatedPosition;
+    rotatedPosition.x = c * alignedPosition.x - s * alignedPosition.y;
+    rotatedPosition.y = s * alignedPosition.x + c * alignedPosition.y;
+
+#ifdef HORIZONTAL
+    vec4 mvPosition = world * vec4(offset, 1.0);
+    mvPosition.x += rotatedPosition.x;
+    mvPosition.z -= rotatedPosition.y;
+    mvPosition = view * mvPosition;
+#elif defined(VERTICAL)
+    vec4 mvPosition = world * vec4(offset, 1.0);
+    mvPosition.y += rotatedPosition.y;
+    mvPosition = view * mvPosition;
+    mvPosition.x += rotatedPosition.x;
+#else
+    vec4 mvPosition = view * world * vec4(offset, 1.0);
+    mvPosition.xy += rotatedPosition;
+#endif
+
+    gl_Position = projection * mvPosition;
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -mvPosition.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/stretched_bb_particle_vert.glsl.ts

@@ -0,0 +1,74 @@
+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 float rotation;
+attribute float uvTile;
+attribute vec4 velocity;
+
+// Uniforms
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 projection;
+uniform float speedFactor;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+// Varyings
+varying vec2 vUV;
+varying vec4 vColor;
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+#ifdef SOFT_PARTICLES
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+void main() {
+    float lengthFactor = velocity.w;
+    float avgSize = (size.x + size.y) * 0.5;
+    vec4 mvPosition = view * world * vec4(offset, 1.0);
+    vec3 viewVelocity = mat3(view * world) * velocity.xyz;
+    float vlength = length(viewVelocity);
+    if (vlength < 0.0001) {
+        vlength = 0.0001;
+        viewVelocity = vec3(0.0, 0.0, 1.0);
+    }
+    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, viewVelocity)) * avgSize;
+    mvPosition.xyz -= (position.x + 0.5) * viewVelocity * (1.0 + lengthFactor / vlength) * avgSize;
+    gl_Position = projection * mvPosition;
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -mvPosition.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/trail_frag.glsl.ts

@@ -0,0 +1,21 @@
+export default /* glsl */ `
+varying vec2 vUV;
+varying vec4 vColor;
+
+#ifdef USE_MAP
+uniform sampler2D map;
+#endif
+
+void main() {
+    vec4 baseColor = vColor;
+
+#ifdef USE_MAP
+    vec4 texColor = texture2D(map, vUV);
+    baseColor *= texColor;
+#endif
+
+    if (baseColor.a < 0.01) discard;
+
+    gl_FragColor = baseColor;
+}
+`;

package/src/shaders/trail_vert.glsl.ts

@@ -0,0 +1,58 @@
+export default /* glsl */ `
+attribute vec3 position;
+attribute vec3 previous;
+attribute vec3 next;
+attribute float side;
+attribute float width;
+attribute vec2 uv;
+attribute vec4 color;
+
+uniform mat4 view;
+uniform mat4 projection;
+uniform float lineWidth;
+uniform vec2 resolution;
+uniform float sizeAttenuation;
+
+varying vec2 vUV;
+varying vec4 vColor;
+
+vec2 fix(vec4 i, float aspect) {
+    vec2 res = i.xy / i.w;
+    res.x *= aspect;
+    return res;
+}
+
+void main() {
+    float aspect = resolution.x / resolution.y;
+    vec4 finalPosition = projection * view * vec4(position, 1.0);
+    vec4 prevPos = projection * view * vec4(previous, 1.0);
+    vec4 nextPos = projection * view * vec4(next, 1.0);
+
+    vec2 currentP = fix(finalPosition, aspect);
+    vec2 prevP = fix(prevPos, aspect);
+    vec2 nextP = fix(nextPos, aspect);
+
+    float w = lineWidth * width;
+    vec2 dir;
+    if (distance(nextP, currentP) < 0.0001) {
+        dir = normalize(currentP - prevP);
+    } else if (distance(prevP, currentP) < 0.0001) {
+        dir = normalize(nextP - currentP);
+    } else {
+        vec2 dir1 = normalize(currentP - prevP);
+        vec2 dir2 = normalize(nextP - currentP);
+        dir = normalize(dir1 + dir2);
+    }
+    vec4 normal = vec4(-dir.y, dir.x, 0.0, 1.0);
+    normal.xy *= 0.5 * w;
+    normal *= projection;
+    if (sizeAttenuation == 0.0) {
+        normal.xy *= finalPosition.w;
+        normal.xy /= (vec4(resolution, 0.0, 1.0) * projection).xy;
+    }
+    finalPosition.xy += normal.xy * side;
+    gl_Position = finalPosition;
+    vUV = uv;
+    vColor = color;
+}
+`;