@wolsok/thanos 17.0.37 → 18.0.0

package/esm2022/lib/webgl/webgl-shaders.js

@@ -0,0 +1,323 @@
+import { MIN_PARTICLE_ALPHA } from '../particles';
+import { FLOW_FIELD, FRONT_FRAY } from '../vaporizing-front';
+import { SIMPLEX_NOISE_3D } from './simplex-noise.glsl';
+/** attribute locations shared by all programs */
+export const AttributeLocation = {
+    POSITION: 0,
+    VELOCITY: 1,
+    ACCELERATION: 2,
+    ALPHA: 3,
+    COLOR: 4,
+    RELEASED_AT: 5,
+    CRACK: 6,
+    CELL_RANDOM: 7,
+};
+/** crumble mode as passed to the shaders */
+export const CRUMBLE_MODE = {
+    dust: 0,
+    cracks: 1,
+    shards: 2,
+    chunks: 3,
+};
+export const UPDATE_FEEDBACK_VARYINGS = [
+    'vPosition',
+    'vVelocity',
+    'vAcceleration',
+    'vAlpha',
+    'vReleasedAt',
+];
+export const CRACK_FEEDBACK_VARYINGS = ['vCrack', 'vCellRandom'];
+/** floats per particle written by the crack program */
+export const CRACK_LENGTH = 5;
+const L = AttributeLocation;
+/** GLSL float literal */
+const f = (value) => Number.isInteger(value) ? value.toFixed(1) : String(value);
+const IS_VISIBLE_INSIDE = /* glsl */ `
+bool isVisibleInside(vec2 position, float alpha, vec2 size) {
+  return position.x <= size.x && position.x >= 0.0 &&
+    position.y <= size.y && position.y >= 0.0 &&
+    alpha >= ${f(MIN_PARTICLE_ALPHA)};
+}
+`;
+const HASH = /* glsl */ `
+uint hash(uint x) {
+  x ^= x >> 16;
+  x *= 0x7feb352du;
+  x ^= x >> 15;
+  x *= 0x846ca68bu;
+  x ^= x >> 16;
+  return x;
+}
+
+float toUnit(uint x) {
+  return float(x) / 4294967295.0;
+}
+`;
+/**
+ * Shards shift and tilt around their center while uShardGrow rises.
+ * aCrack: shard center (xy), distance to the next coarse (z) and fine (w) crack, in device pixels.
+ */
+const SHARD_OFFSET = /* glsl */ `
+vec2 shardOffset(vec2 position, vec4 crack, float cellRandom) {
+  if (uShardGrow == 0.0) {
+    return vec2(0.0);
+  }
+  float angle = (cellRandom - 0.5) * 0.14 * uShardGrow;
+  vec2 relative = position - crack.xy;
+  vec2 rotated = mat2(cos(angle), sin(angle), -sin(angle), cos(angle)) * relative;
+  float direction = fract(cellRandom * 7.31) * 6.2831853;
+  vec2 drift = vec2(cos(direction), sin(direction) * 0.6 - 0.4) * 5.0 * uPixelScale * uShardGrow;
+  return rotated - relative + drift;
+}
+`;
+/** runs once: which shard each particle belongs to and how far it is from the next crack */
+export const CRACK_VERTEX_SHADER = /* glsl */ `#version 300 es
+precision highp float;
+precision highp int;
+
+layout(location = ${L.POSITION}) in vec2 aPosition;
+
+uniform float uCellSize;
+uniform float uSeed;
+
+out vec4 vCrack;
+out float vCellRandom;
+
+${HASH}
+
+vec2 cellRandom(vec2 cell, uint saltedSeed) {
+  uvec2 c = uvec2(ivec2(cell) + 32768);
+  uint h = hash(c.x ^ hash(c.y ^ saltedSeed));
+  return vec2(toUnit(h), toUnit(hash(h)));
+}
+
+/** voronoi cell of p: center (xy), distance to the cell border (z), random (w), in cell units */
+vec4 voronoi(vec2 p, uint salt) {
+  uint saltedSeed = hash(floatBitsToUint(uSeed) ^ salt);
+  vec2 n = floor(p);
+  vec2 f = fract(p);
+  vec2 nearestCell = vec2(0.0);
+  vec2 nearest = vec2(0.0);
+  float nearestDistance = 8.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 g = vec2(float(i), float(j));
+      vec2 r = g + cellRandom(n + g, saltedSeed) - f;
+      float d = dot(r, r);
+      if (d < nearestDistance) {
+        nearestDistance = d;
+        nearest = r;
+        nearestCell = g;
+      }
+    }
+  }
+  // exact distance to the border between the nearest and its neighbour cells
+  float border = 8.0;
+  for (int j = -2; j <= 2; j++) {
+    for (int i = -2; i <= 2; i++) {
+      vec2 g = nearestCell + vec2(float(i), float(j));
+      vec2 r = g + cellRandom(n + g, saltedSeed) - f;
+      vec2 between = r - nearest;
+      if (dot(between, between) > 0.00001) {
+        border = min(border, dot(0.5 * (nearest + r), normalize(between)));
+      }
+    }
+  }
+  uint randomSeed = hash(floatBitsToUint(uSeed) ^ (salt + 7u));
+  return vec4(p + nearest, border, cellRandom(n + nearestCell, randomSeed).x);
+}
+
+void main() {
+  vec4 coarse = voronoi(aPosition / uCellSize, 1u);
+  float fineSize = uCellSize * 0.42;
+  vec4 fine = voronoi(aPosition / fineSize, 2u);
+  vCrack = vec4(coarse.xy * uCellSize, coarse.z * uCellSize, fine.z * fineSize);
+  vCellRandom = coarse.w;
+}
+`;
+/** moves the particles, the GPU port of updateParticlesOnCpu plus the crumble modes */
+export const UPDATE_VERTEX_SHADER = /* glsl */ `#version 300 es
+precision highp float;
+precision highp int;
+
+layout(location = ${L.POSITION}) in vec2 aPosition;
+layout(location = ${L.VELOCITY}) in vec2 aVelocity;
+layout(location = ${L.ACCELERATION}) in vec2 aAcceleration;
+layout(location = ${L.ALPHA}) in float aAlpha;
+layout(location = ${L.RELEASED_AT}) in float aReleasedAt;
+layout(location = ${L.CRACK}) in vec4 aCrack;
+layout(location = ${L.CELL_RANDOM}) in float aCellRandom;
+
+uniform vec2 uSize;
+uniform float uDeltaTSec;
+uniform float uAnimationT;
+uniform float uParticleAcceleration;
+uniform float uSeed;
+uniform int uCrumble;
+uniform float uPixelScale;
+/** see vaporizingFront() */
+uniform float uFrontTime;
+uniform float uFrontRadiusPow;
+uniform float uFade;
+/** see crumbleShape(), in device pixels */
+uniform float uCoarseCrack;
+uniform float uFineCrack;
+uniform float uShardGrow;
+
+out vec2 vPosition;
+out vec2 vVelocity;
+out vec2 vAcceleration;
+out float vAlpha;
+/** 0 while attached, < 0 while a chunk falls, > 0 once it is dust */
+out float vReleasedAt;
+
+const int CHUNKS = ${CRUMBLE_MODE.chunks};
+/** part of the animation a chunk flies before it crumbles */
+const float CHUNK_LIFE = 0.12;
+/** weak, the effect canvas ends at the bottom of the element, so chunks jump up and arc */
+const float CHUNK_GRAVITY = 4.0;
+
+${IS_VISIBLE_INSIDE}
+${SIMPLEX_NOISE_3D}
+${HASH}
+${SHARD_OFFSET}
+
+/** simplex noise mapped to [0, 1] like SimplexNoise({ min: 0 }) */
+float noise01(vec3 position) {
+  return snoise(position * ${f(FLOW_FIELD.frequency)}) * 0.5 + 0.5;
+}
+
+/** random number in [0, 1] per particle, frame and salt */
+float random(uint salt) {
+  uint frame = floatBitsToUint(uAnimationT) ^ floatBitsToUint(uSeed);
+  return toUnit(hash(uint(gl_VertexID) ^ hash(frame ^ salt)));
+}
+
+vec2 dustAcceleration() {
+  return vec2(random(1u), -random(2u));
+}
+
+/** has the vaporizing front passed this position, see isBehindFront() */
+bool isBehindFront(vec2 position) {
+  float pXLength = position.x + mod(position.x, uDeltaTSec) * 0.5;
+  float pYLength = uSize.y - position.y;
+  pXLength += sin((pXLength / ${f(FRONT_FRAY.xWave)} + ${f(FRONT_FRAY.xPhase)}) * uFrontTime
+    + uSeed * ${f(FRONT_FRAY.xSeed)}) * ${f(FRONT_FRAY.xAmplitude)};
+  pYLength += cos((pYLength / ${f(FRONT_FRAY.yWave)} + ${f(FRONT_FRAY.yPhase)}) * uFrontTime
+    + uSeed * ${f(FRONT_FRAY.ySeed)}) * ${f(FRONT_FRAY.yAmplitude)};
+  return pXLength * pXLength + pYLength * pYLength > uFrontRadiusPow;
+}
+
+void main() {
+  vPosition = aPosition;
+  vVelocity = aVelocity;
+  vAcceleration = aAcceleration;
+  vAlpha = aAlpha;
+  vReleasedAt = aReleasedAt;
+
+  // only update particles that are inside view and visible
+  if (!isVisibleInside(aPosition, aAlpha, uSize)) {
+    return;
+  }
+
+  float releaseT = max(uAnimationT, 0.0001);
+
+  if (aReleasedAt == 0.0) {
+    bool inCrack = aCrack.z < uCoarseCrack || aCrack.w < uFineCrack;
+    // chunks break off as a whole, so the shard center decides
+    vec2 frontPosition = uCrumble == CHUNKS ? aCrack.xy : aPosition;
+
+    if (inCrack || isBehindFront(frontPosition)) {
+      vPosition += shardOffset(aPosition, aCrack, aCellRandom);
+      vReleasedAt = releaseT;
+      if (inCrack) {
+        // the crack crumbles to dust that trickles out gently
+        vAcceleration = dustAcceleration() * 0.3;
+      } else if (uCrumble == CHUNKS) {
+        // the whole chunk shares velocity and gravity, so it flies in one piece
+        float side = fract(aCellRandom * 13.7) - 0.5;
+        vVelocity = vec2(side * 90.0, -60.0 - aCellRandom * 70.0) * uPixelScale;
+        vAcceleration = vec2(0.0, CHUNK_GRAVITY);
+        vReleasedAt = -releaseT;
+      } else {
+        vAcceleration = dustAcceleration();
+      }
+    }
+  } else if (aReleasedAt < 0.0) {
+    // a flying chunk crumbles to dust after a while
+    if (uAnimationT + aReleasedAt > CHUNK_LIFE + aCellRandom * 0.08) {
+      vAcceleration = dustAcceleration();
+      vReleasedAt = releaseT;
+    }
+  } else {
+    // flow along the noise velocity field
+    vAcceleration += vec2(
+      noise01(vec3(aPosition.x, aPosition.y, uSeed + ${f(FLOW_FIELD.xSeedOffset)})),
+      -noise01(vec3(aPosition.x, uSeed / ${f(FLOW_FIELD.ySeedDivisor)}, aPosition.y))
+    );
+  }
+
+  vVelocity += vAcceleration * uParticleAcceleration * uDeltaTSec;
+  vPosition += vVelocity * uDeltaTSec;
+  vAlpha *= uFade;
+}
+`;
+/** transform feedback only, nothing is rasterized */
+export const FEEDBACK_FRAGMENT_SHADER = /* glsl */ `#version 300 es
+precision mediump float;
+out vec4 outColor;
+void main() {
+  outColor = vec4(0.0);
+}
+`;
+/** draws every particle as one device pixel */
+export const DRAW_VERTEX_SHADER = /* glsl */ `#version 300 es
+precision highp float;
+precision highp int;
+
+layout(location = ${L.POSITION}) in vec2 aPosition;
+layout(location = ${L.ALPHA}) in float aAlpha;
+layout(location = ${L.COLOR}) in vec4 aColor;
+layout(location = ${L.RELEASED_AT}) in float aReleasedAt;
+layout(location = ${L.CRACK}) in vec4 aCrack;
+layout(location = ${L.CELL_RANDOM}) in float aCellRandom;
+
+uniform vec2 uSize;
+uniform float uPixelScale;
+uniform float uShardGrow;
+
+out vec4 vColor;
+
+${IS_VISIBLE_INSIDE}
+${SHARD_OFFSET}
+
+void main() {
+  vec2 position = aPosition;
+  if (aReleasedAt == 0.0) {
+    // attached shards shift and tilt before they break off
+    position += shardOffset(aPosition, aCrack, aCellRandom);
+  }
+  if (!isVisibleInside(position, aAlpha, uSize)) {
+    // move outside of clip space
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    gl_PointSize = 1.0;
+    vColor = vec4(0.0);
+    return;
+  }
+  vec2 clip = (floor(position) + 0.5) / uSize * 2.0 - 1.0;
+  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);
+  gl_PointSize = 1.0;
+  float alpha = aAlpha / 255.0;
+  // premultiplied alpha
+  vColor = vec4(aColor.rgb * alpha, alpha);
+}
+`;
+export const DRAW_FRAGMENT_SHADER = /* glsl */ `#version 300 es
+precision mediump float;
+in vec4 vColor;
+out vec4 outColor;
+void main() {
+  outColor = vColor;
+}
+`;
+//# sourceMappingURL=webgl-shaders.js.map

package/esm2022/lib/webgl/webgl-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-shaders.js","sourceRoot":"","sources":["../../../../../../../libs/public/ws-thanos/src/lib/webgl/webgl-shaders.ts"],"names":[],"mappings":"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","sourcesContent":["import { MIN_PARTICLE_ALPHA } from '../particles';\nimport { FLOW_FIELD, FRONT_FRAY } from '../vaporizing-front';\nimport { WsThanosCrumble } from '../ws-thanos.options';\nimport { SIMPLEX_NOISE_3D } from './simplex-noise.glsl';\n\n/** attribute locations shared by all programs */\nexport const AttributeLocation = {\n  POSITION: 0,\n  VELOCITY: 1,\n  ACCELERATION: 2,\n  ALPHA: 3,\n  COLOR: 4,\n  RELEASED_AT: 5,\n  CRACK: 6,\n  CELL_RANDOM: 7,\n} as const;\n\n/** crumble mode as passed to the shaders */\nexport const CRUMBLE_MODE: Record<WsThanosCrumble, number> = {\n  dust: 0,\n  cracks: 1,\n  shards: 2,\n  chunks: 3,\n};\n\nexport const UPDATE_FEEDBACK_VARYINGS = [\n  'vPosition',\n  'vVelocity',\n  'vAcceleration',\n  'vAlpha',\n  'vReleasedAt',\n];\n\nexport const CRACK_FEEDBACK_VARYINGS = ['vCrack', 'vCellRandom'];\n\n/** floats per particle written by the crack program */\nexport const CRACK_LENGTH = 5;\n\nconst L = AttributeLocation;\n\n/** GLSL float literal */\nconst f = (value: number): string =>\n  Number.isInteger(value) ? value.toFixed(1) : String(value);\n\nconst IS_VISIBLE_INSIDE = /* glsl */ `\nbool isVisibleInside(vec2 position, float alpha, vec2 size) {\n  return position.x <= size.x && position.x >= 0.0 &&\n    position.y <= size.y && position.y >= 0.0 &&\n    alpha >= ${f(MIN_PARTICLE_ALPHA)};\n}\n`;\n\nconst HASH = /* glsl */ `\nuint hash(uint x) {\n  x ^= x >> 16;\n  x *= 0x7feb352du;\n  x ^= x >> 15;\n  x *= 0x846ca68bu;\n  x ^= x >> 16;\n  return x;\n}\n\nfloat toUnit(uint x) {\n  return float(x) / 4294967295.0;\n}\n`;\n\n/**\n * Shards shift and tilt around their center while uShardGrow rises.\n * aCrack: shard center (xy), distance to the next coarse (z) and fine (w) crack, in device pixels.\n */\nconst SHARD_OFFSET = /* glsl */ `\nvec2 shardOffset(vec2 position, vec4 crack, float cellRandom) {\n  if (uShardGrow == 0.0) {\n    return vec2(0.0);\n  }\n  float angle = (cellRandom - 0.5) * 0.14 * uShardGrow;\n  vec2 relative = position - crack.xy;\n  vec2 rotated = mat2(cos(angle), sin(angle), -sin(angle), cos(angle)) * relative;\n  float direction = fract(cellRandom * 7.31) * 6.2831853;\n  vec2 drift = vec2(cos(direction), sin(direction) * 0.6 - 0.4) * 5.0 * uPixelScale * uShardGrow;\n  return rotated - relative + drift;\n}\n`;\n\n/** runs once: which shard each particle belongs to and how far it is from the next crack */\nexport const CRACK_VERTEX_SHADER = /* glsl */ `#version 300 es\nprecision highp float;\nprecision highp int;\n\nlayout(location = ${L.POSITION}) in vec2 aPosition;\n\nuniform float uCellSize;\nuniform float uSeed;\n\nout vec4 vCrack;\nout float vCellRandom;\n\n${HASH}\n\nvec2 cellRandom(vec2 cell, uint saltedSeed) {\n  uvec2 c = uvec2(ivec2(cell) + 32768);\n  uint h = hash(c.x ^ hash(c.y ^ saltedSeed));\n  return vec2(toUnit(h), toUnit(hash(h)));\n}\n\n/** voronoi cell of p: center (xy), distance to the cell border (z), random (w), in cell units */\nvec4 voronoi(vec2 p, uint salt) {\n  uint saltedSeed = hash(floatBitsToUint(uSeed) ^ salt);\n  vec2 n = floor(p);\n  vec2 f = fract(p);\n  vec2 nearestCell = vec2(0.0);\n  vec2 nearest = vec2(0.0);\n  float nearestDistance = 8.0;\n  for (int j = -1; j <= 1; j++) {\n    for (int i = -1; i <= 1; i++) {\n      vec2 g = vec2(float(i), float(j));\n      vec2 r = g + cellRandom(n + g, saltedSeed) - f;\n      float d = dot(r, r);\n      if (d < nearestDistance) {\n        nearestDistance = d;\n        nearest = r;\n        nearestCell = g;\n      }\n    }\n  }\n  // exact distance to the border between the nearest and its neighbour cells\n  float border = 8.0;\n  for (int j = -2; j <= 2; j++) {\n    for (int i = -2; i <= 2; i++) {\n      vec2 g = nearestCell + vec2(float(i), float(j));\n      vec2 r = g + cellRandom(n + g, saltedSeed) - f;\n      vec2 between = r - nearest;\n      if (dot(between, between) > 0.00001) {\n        border = min(border, dot(0.5 * (nearest + r), normalize(between)));\n      }\n    }\n  }\n  uint randomSeed = hash(floatBitsToUint(uSeed) ^ (salt + 7u));\n  return vec4(p + nearest, border, cellRandom(n + nearestCell, randomSeed).x);\n}\n\nvoid main() {\n  vec4 coarse = voronoi(aPosition / uCellSize, 1u);\n  float fineSize = uCellSize * 0.42;\n  vec4 fine = voronoi(aPosition / fineSize, 2u);\n  vCrack = vec4(coarse.xy * uCellSize, coarse.z * uCellSize, fine.z * fineSize);\n  vCellRandom = coarse.w;\n}\n`;\n\n/** moves the particles, the GPU port of updateParticlesOnCpu plus the crumble modes */\nexport const UPDATE_VERTEX_SHADER = /* glsl */ `#version 300 es\nprecision highp float;\nprecision highp int;\n\nlayout(location = ${L.POSITION}) in vec2 aPosition;\nlayout(location = ${L.VELOCITY}) in vec2 aVelocity;\nlayout(location = ${L.ACCELERATION}) in vec2 aAcceleration;\nlayout(location = ${L.ALPHA}) in float aAlpha;\nlayout(location = ${L.RELEASED_AT}) in float aReleasedAt;\nlayout(location = ${L.CRACK}) in vec4 aCrack;\nlayout(location = ${L.CELL_RANDOM}) in float aCellRandom;\n\nuniform vec2 uSize;\nuniform float uDeltaTSec;\nuniform float uAnimationT;\nuniform float uParticleAcceleration;\nuniform float uSeed;\nuniform int uCrumble;\nuniform float uPixelScale;\n/** see vaporizingFront() */\nuniform float uFrontTime;\nuniform float uFrontRadiusPow;\nuniform float uFade;\n/** see crumbleShape(), in device pixels */\nuniform float uCoarseCrack;\nuniform float uFineCrack;\nuniform float uShardGrow;\n\nout vec2 vPosition;\nout vec2 vVelocity;\nout vec2 vAcceleration;\nout float vAlpha;\n/** 0 while attached, < 0 while a chunk falls, > 0 once it is dust */\nout float vReleasedAt;\n\nconst int CHUNKS = ${CRUMBLE_MODE.chunks};\n/** part of the animation a chunk flies before it crumbles */\nconst float CHUNK_LIFE = 0.12;\n/** weak, the effect canvas ends at the bottom of the element, so chunks jump up and arc */\nconst float CHUNK_GRAVITY = 4.0;\n\n${IS_VISIBLE_INSIDE}\n${SIMPLEX_NOISE_3D}\n${HASH}\n${SHARD_OFFSET}\n\n/** simplex noise mapped to [0, 1] like SimplexNoise({ min: 0 }) */\nfloat noise01(vec3 position) {\n  return snoise(position * ${f(FLOW_FIELD.frequency)}) * 0.5 + 0.5;\n}\n\n/** random number in [0, 1] per particle, frame and salt */\nfloat random(uint salt) {\n  uint frame = floatBitsToUint(uAnimationT) ^ floatBitsToUint(uSeed);\n  return toUnit(hash(uint(gl_VertexID) ^ hash(frame ^ salt)));\n}\n\nvec2 dustAcceleration() {\n  return vec2(random(1u), -random(2u));\n}\n\n/** has the vaporizing front passed this position, see isBehindFront() */\nbool isBehindFront(vec2 position) {\n  float pXLength = position.x + mod(position.x, uDeltaTSec) * 0.5;\n  float pYLength = uSize.y - position.y;\n  pXLength += sin((pXLength / ${f(FRONT_FRAY.xWave)} + ${f(FRONT_FRAY.xPhase)}) * uFrontTime\n    + uSeed * ${f(FRONT_FRAY.xSeed)}) * ${f(FRONT_FRAY.xAmplitude)};\n  pYLength += cos((pYLength / ${f(FRONT_FRAY.yWave)} + ${f(FRONT_FRAY.yPhase)}) * uFrontTime\n    + uSeed * ${f(FRONT_FRAY.ySeed)}) * ${f(FRONT_FRAY.yAmplitude)};\n  return pXLength * pXLength + pYLength * pYLength > uFrontRadiusPow;\n}\n\nvoid main() {\n  vPosition = aPosition;\n  vVelocity = aVelocity;\n  vAcceleration = aAcceleration;\n  vAlpha = aAlpha;\n  vReleasedAt = aReleasedAt;\n\n  // only update particles that are inside view and visible\n  if (!isVisibleInside(aPosition, aAlpha, uSize)) {\n    return;\n  }\n\n  float releaseT = max(uAnimationT, 0.0001);\n\n  if (aReleasedAt == 0.0) {\n    bool inCrack = aCrack.z < uCoarseCrack || aCrack.w < uFineCrack;\n    // chunks break off as a whole, so the shard center decides\n    vec2 frontPosition = uCrumble == CHUNKS ? aCrack.xy : aPosition;\n\n    if (inCrack || isBehindFront(frontPosition)) {\n      vPosition += shardOffset(aPosition, aCrack, aCellRandom);\n      vReleasedAt = releaseT;\n      if (inCrack) {\n        // the crack crumbles to dust that trickles out gently\n        vAcceleration = dustAcceleration() * 0.3;\n      } else if (uCrumble == CHUNKS) {\n        // the whole chunk shares velocity and gravity, so it flies in one piece\n        float side = fract(aCellRandom * 13.7) - 0.5;\n        vVelocity = vec2(side * 90.0, -60.0 - aCellRandom * 70.0) * uPixelScale;\n        vAcceleration = vec2(0.0, CHUNK_GRAVITY);\n        vReleasedAt = -releaseT;\n      } else {\n        vAcceleration = dustAcceleration();\n      }\n    }\n  } else if (aReleasedAt < 0.0) {\n    // a flying chunk crumbles to dust after a while\n    if (uAnimationT + aReleasedAt > CHUNK_LIFE + aCellRandom * 0.08) {\n      vAcceleration = dustAcceleration();\n      vReleasedAt = releaseT;\n    }\n  } else {\n    // flow along the noise velocity field\n    vAcceleration += vec2(\n      noise01(vec3(aPosition.x, aPosition.y, uSeed + ${f(FLOW_FIELD.xSeedOffset)})),\n      -noise01(vec3(aPosition.x, uSeed / ${f(FLOW_FIELD.ySeedDivisor)}, aPosition.y))\n    );\n  }\n\n  vVelocity += vAcceleration * uParticleAcceleration * uDeltaTSec;\n  vPosition += vVelocity * uDeltaTSec;\n  vAlpha *= uFade;\n}\n`;\n\n/** transform feedback only, nothing is rasterized */\nexport const FEEDBACK_FRAGMENT_SHADER = /* glsl */ `#version 300 es\nprecision mediump float;\nout vec4 outColor;\nvoid main() {\n  outColor = vec4(0.0);\n}\n`;\n\n/** draws every particle as one device pixel */\nexport const DRAW_VERTEX_SHADER = /* glsl */ `#version 300 es\nprecision highp float;\nprecision highp int;\n\nlayout(location = ${L.POSITION}) in vec2 aPosition;\nlayout(location = ${L.ALPHA}) in float aAlpha;\nlayout(location = ${L.COLOR}) in vec4 aColor;\nlayout(location = ${L.RELEASED_AT}) in float aReleasedAt;\nlayout(location = ${L.CRACK}) in vec4 aCrack;\nlayout(location = ${L.CELL_RANDOM}) in float aCellRandom;\n\nuniform vec2 uSize;\nuniform float uPixelScale;\nuniform float uShardGrow;\n\nout vec4 vColor;\n\n${IS_VISIBLE_INSIDE}\n${SHARD_OFFSET}\n\nvoid main() {\n  vec2 position = aPosition;\n  if (aReleasedAt == 0.0) {\n    // attached shards shift and tilt before they break off\n    position += shardOffset(aPosition, aCrack, aCellRandom);\n  }\n  if (!isVisibleInside(position, aAlpha, uSize)) {\n    // move outside of clip space\n    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n    gl_PointSize = 1.0;\n    vColor = vec4(0.0);\n    return;\n  }\n  vec2 clip = (floor(position) + 0.5) / uSize * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  gl_PointSize = 1.0;\n  float alpha = aAlpha / 255.0;\n  // premultiplied alpha\n  vColor = vec4(aColor.rgb * alpha, alpha);\n}\n`;\n\nexport const DRAW_FRAGMENT_SHADER = /* glsl */ `#version 300 es\nprecision mediump float;\nin vec4 vColor;\nout vec4 outColor;\nvoid main() {\n  outColor = vColor;\n}\n`;\n"]}

package/esm2022/lib/ws-thanos.directive.js

@@ -1,6 +1,6 @@
-import { Directive, ElementRef, Output, inject } from '@angular/core';
+import { Directive, ElementRef, Output, inject, input } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { finalize, Subject, Subscription, take, tap } from 'rxjs';
+import { finalize, Subject, take, tap } from 'rxjs';
 import { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';
 import { WsThanosService } from './ws-thanos.service';
 import * as i0 from "@angular/core";
@@ -8,8 +8,10 @@ export class WsThanosDirective {
     constructor() {
         this.wsThanosCompleteSubject = new Subject();
         this.untilDestroyed = takeUntilDestroyed();
+        /** override the provided options for this element */
+        this.wsThanosOptions = input(/* @ts-ignore */
+        ...(ngDevMode ? [undefined, { debugName: "wsThanosOptions" }] : /* istanbul ignore next */ []));
         this.wsThanosComplete = this.wsThanosCompleteSubject.asObservable();
-        this.subscriptions = new Subscription();
         this.vaporizeDomElem = inject(ElementRef);
         this.thanosService = inject(WsThanosService);
         this.thanosOptions = inject(WS_THANOS_OPTIONS_TOKEN);
@@ -24,7 +26,7 @@ export class WsThanosDirective {
      */
     vaporize$(removeElem = true) {
         const elem = this.vaporizeDomElem.nativeElement;
-        return this.thanosService.vaporize(elem).pipe(tap({
+        return this.thanosService.vaporize(elem, this.wsThanosOptions()).pipe(tap({
             error: (error) => {
                 console.error('Error vaporizing', error, {
                     elemTovaporize: elem,
@@ -53,7 +55,7 @@ export class WsThanosDirective {
         return this.wsThanosComplete.pipe(take(1));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.1", ngImport: i0, type: WsThanosDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.1", type: WsThanosDirective, isStandalone: true, selector: "[wsThanos], ws-thanos", outputs: { wsThanosComplete: "wsThanosComplete" }, exportAs: ["thanos"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.2.1", type: WsThanosDirective, isStandalone: true, selector: "[wsThanos], ws-thanos", inputs: { wsThanosOptions: { classPropertyName: "wsThanosOptions", publicName: "wsThanosOptions", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { wsThanosComplete: "wsThanosComplete" }, exportAs: ["thanos"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.1", ngImport: i0, type: WsThanosDirective, decorators: [{
             type: Directive,
@@ -63,7 +65,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.1", ngImpor
                     selector: '[wsThanos], ws-thanos',
                     exportAs: 'thanos',
                 }]
-        }], propDecorators: { wsThanosComplete: [{
+        }], propDecorators: { wsThanosOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "wsThanosOptions", required: false }] }], wsThanosComplete: [{
                 type: Output
             }] } });
 //# sourceMappingURL=ws-thanos.directive.js.map

package/esm2022/lib/ws-thanos.directive.js.map

@@ -1 +1 @@
-{"version":3,"file":"ws-thanos.directive.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/ws-thanos.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAc,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;;AAQtD,MAAM,OAAO,iBAAiB;IAN9B;QAOU,4BAAuB,GAAG,IAAI,OAAO,EAAQ,CAAC;QAC9C,mBAAc,GAAG,kBAAkB,EAAE,CAAC;QAGvC,qBAAgB,GACrB,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,CAAC;QACtC,kBAAa,GAAiB,IAAI,YAAY,EAAE,CAAC;QAExC,oBAAe,GAC9B,MAAM,CAAC,UAAU,CAAC,CAAC;QACJ,kBAAa,GAAoB,MAAM,CAAC,eAAe,CAAC,CAAC;QACzD,kBAAa,GAAoB,MAAM,CACtD,uBAAuB,CACxB,CAAC;KA2CH;IAzCC;;;;;;;OAOG;IACI,SAAS,CAAC,UAAU,GAAG,IAAI;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC;QAChD,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAC3C,GAAG,CAAC;YACF,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;gBACf,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,KAAK,EAAE;oBACvC,cAAc,EAAE,IAAI;oBACpB,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;SACF,CAAC,EACF,QAAQ,CAAC,GAAG,EAAE;YACZ,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,qBAAqB;gBACrB,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,eAAe,CAAC;gBACxC,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC;YAC3B,CAAC;YACD,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,UAAU,GAAG,IAAI;QAC/B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,SAAS,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;8GAxDU,iBAAiB;kGAAjB,iBAAiB;;2FAAjB,iBAAiB;kBAN7B,SAAS;mBAAC;oBACT,4FAA4F;oBAC5F,8DAA8D;oBAC9D,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE,QAAQ;iBACnB;;sBAKE,MAAM","sourcesContent":["import { Directive, ElementRef, Output, inject } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { finalize, Observable, Subject, Subscription, take, tap } from 'rxjs';\nimport { AnimationState } from './animation.state';\nimport { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';\nimport type { WsThanosOptions } from './ws-thanos.options';\nimport { WsThanosService } from './ws-thanos.service';\n\n@Directive({\n  // Bare prefix is the published public API of @wolsok/thanos; renaming it would be breaking.\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: '[wsThanos], ws-thanos',\n  exportAs: 'thanos',\n})\nexport class WsThanosDirective {\n  private wsThanosCompleteSubject = new Subject<void>();\n  private untilDestroyed = takeUntilDestroyed();\n\n  @Output()\n  public wsThanosComplete: Observable<void> =\n    this.wsThanosCompleteSubject.asObservable();\n  private subscriptions: Subscription = new Subscription();\n\n  private readonly vaporizeDomElem: ElementRef<HTMLElement> =\n    inject(ElementRef);\n  private readonly thanosService: WsThanosService = inject(WsThanosService);\n  private readonly thanosOptions: WsThanosOptions = inject(\n    WS_THANOS_OPTIONS_TOKEN\n  );\n\n  /**\n   *\n   * Vaporize the dom element of this directive\n   * @param removeElem remove the vaporized dom element or blend back in after a while\n   *\n   * Subscribe to the returned observable to start vaporization\n   *\n   */\n  public vaporize$(removeElem = true): Observable<AnimationState> {\n    const elem = this.vaporizeDomElem.nativeElement;\n    return this.thanosService.vaporize(elem).pipe(\n      tap({\n        error: (error) => {\n          console.error('Error vaporizing', error, {\n            elemTovaporize: elem,\n            removeElem,\n          });\n        },\n      }),\n      finalize(() => {\n        if (removeElem) {\n          elem.remove();\n        } else {\n          // make visible again\n          elem.style.transition = 'opacity 700ms';\n          elem.style.opacity = '1';\n        }\n        this.wsThanosCompleteSubject.next();\n      })\n    );\n  }\n\n  /**\n   * Vaporize the dom element of this directive\n   * @param removeElem remove the vaporized dom element or blend back in after a while\n   *\n   */\n  public vaporize(removeElem = true): Observable<void> {\n    this.vaporize$(removeElem).pipe(this.untilDestroyed).subscribe();\n    return this.wsThanosComplete.pipe(take(1));\n  }\n}\n"]}
+{"version":3,"file":"ws-thanos.directive.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/ws-thanos.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAc,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;;AAQtD,MAAM,OAAO,iBAAiB;IAN9B;QAOU,4BAAuB,GAAG,IAAI,OAAO,EAAQ,CAAC;QAC9C,mBAAc,GAAG,kBAAkB,EAAE,CAAC;QAE9C,qDAAqD;QACrC,oBAAe,GAAG,KAAK;uGAA4B,CAAC;QAG7D,qBAAgB,GACrB,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,CAAC;QAE7B,oBAAe,GAC9B,MAAM,CAAC,UAAU,CAAC,CAAC;QACJ,kBAAa,GAAoB,MAAM,CAAC,eAAe,CAAC,CAAC;QACzD,kBAAa,GAAoB,MAAM,CACtD,uBAAuB,CACxB,CAAC;KA2CH;IAzCC;;;;;;;OAOG;IACI,SAAS,CAAC,UAAU,GAAG,IAAI;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC;QAChD,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,CACnE,GAAG,CAAC;YACF,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;gBACf,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,KAAK,EAAE;oBACvC,cAAc,EAAE,IAAI;oBACpB,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;SACF,CAAC,EACF,QAAQ,CAAC,GAAG,EAAE;YACZ,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,qBAAqB;gBACrB,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,eAAe,CAAC;gBACxC,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC;YAC3B,CAAC;YACD,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,UAAU,GAAG,IAAI;QAC/B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,SAAS,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;8GA1DU,iBAAiB;kGAAjB,iBAAiB;;2FAAjB,iBAAiB;kBAN7B,SAAS;mBAAC;oBACT,4FAA4F;oBAC5F,8DAA8D;oBAC9D,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE,QAAQ;iBACnB;;sBAQE,MAAM","sourcesContent":["import { Directive, ElementRef, Output, inject, input } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { finalize, Observable, Subject, take, tap } from 'rxjs';\nimport { AnimationState } from './animation.state';\nimport { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';\nimport type { WsThanosOptions } from './ws-thanos.options';\nimport { WsThanosService } from './ws-thanos.service';\n\n@Directive({\n  // Bare prefix is the published public API of @wolsok/thanos; renaming it would be breaking.\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: '[wsThanos], ws-thanos',\n  exportAs: 'thanos',\n})\nexport class WsThanosDirective {\n  private wsThanosCompleteSubject = new Subject<void>();\n  private untilDestroyed = takeUntilDestroyed();\n\n  /** override the provided options for this element */\n  public readonly wsThanosOptions = input<Partial<WsThanosOptions>>();\n\n  @Output()\n  public wsThanosComplete: Observable<void> =\n    this.wsThanosCompleteSubject.asObservable();\n\n  private readonly vaporizeDomElem: ElementRef<HTMLElement> =\n    inject(ElementRef);\n  private readonly thanosService: WsThanosService = inject(WsThanosService);\n  private readonly thanosOptions: WsThanosOptions = inject(\n    WS_THANOS_OPTIONS_TOKEN\n  );\n\n  /**\n   *\n   * Vaporize the dom element of this directive\n   * @param removeElem remove the vaporized dom element or blend back in after a while\n   *\n   * Subscribe to the returned observable to start vaporization\n   *\n   */\n  public vaporize$(removeElem = true): Observable<AnimationState> {\n    const elem = this.vaporizeDomElem.nativeElement;\n    return this.thanosService.vaporize(elem, this.wsThanosOptions()).pipe(\n      tap({\n        error: (error) => {\n          console.error('Error vaporizing', error, {\n            elemTovaporize: elem,\n            removeElem,\n          });\n        },\n      }),\n      finalize(() => {\n        if (removeElem) {\n          elem.remove();\n        } else {\n          // make visible again\n          elem.style.transition = 'opacity 700ms';\n          elem.style.opacity = '1';\n        }\n        this.wsThanosCompleteSubject.next();\n      })\n    );\n  }\n\n  /**\n   * Vaporize the dom element of this directive\n   * @param removeElem remove the vaporized dom element or blend back in after a while\n   *\n   */\n  public vaporize(removeElem = true): Observable<void> {\n    this.vaporize$(removeElem).pipe(this.untilDestroyed).subscribe();\n    return this.wsThanosComplete.pipe(take(1));\n  }\n}\n"]}

package/esm2022/lib/ws-thanos.options.js.map

@@ -1 +1 @@
-{"version":3,"file":"ws-thanos.options.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/ws-thanos.options.ts"],"names":[],"mappings":"","sourcesContent":["export interface WsThanosOptions {\n  animationLength: number;\n  maxParticleCount: number;\n  particleAcceleration: number;\n}\n"]}
+{"version":3,"file":"ws-thanos.options.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/ws-thanos.options.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * How the element breaks apart (needs WebGL2, the canvas fallback always uses 'dust'):\n * - dust: particles blow away along the vaporizing front\n * - cracks: cracks spread through the element before it turns to dust\n * - shards: cracks split the element into shards that shift and tilt before they turn to dust\n * - chunks: whole chunks break off, jump away and then crumble to dust\n */\nexport type WsThanosCrumble = 'dust' | 'cracks' | 'shards' | 'chunks';\n\nexport interface WsThanosOptions {\n  animationLength: number;\n  maxParticleCount: number;\n  particleAcceleration: number;\n  /** play a windy, sandy sound while vaporizing */\n  sound: boolean;\n  /** volume of the snap sound between 0 and 1 */\n  soundVolume: number;\n  /** how the element breaks apart */\n  crumble: WsThanosCrumble;\n}\n"]}