npm - mudra-skills - Versions diffs - 1.0.0 - Mend

mudra-skills 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (149) hide show

package/skills/mudra-master/mudra-xr/assets/demos/splash.html ADDED Viewed

@@ -0,0 +1,519 @@
+<!doctype html>
+<!-- reference: demos/splash -->
+<html lang="en">
+  <head>
+    <title>Splash</title>
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0, user-scalable=no"
+    />
+<link type="text/css" rel="stylesheet" href="https://xrblocks.github.io/css/xr.css" />
+    <script>
+      window.litDisableBundleWarning = true;
+    </script>
+    <script type="importmap">
+      {
+        "imports": {
+          "@dimforge/rapier3d-simd-compat": "https://cdn.jsdelivr.net/npm/@dimforge/rapier3d-simd-compat@0.19.2/rapier.mjs",
+          "three": "https://cdn.jsdelivr.net/npm/three@0.182.0/build/three.module.js",
+          "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.182.0/examples/jsm/",
+          "troika-three-text": "https://cdn.jsdelivr.net/gh/protectwise/troika@028b81cf308f0f22e5aa8e78196be56ec1997af5/packages/troika-three-text/src/index.js",
+          "troika-three-utils": "https://cdn.jsdelivr.net/gh/protectwise/troika@v0.52.4/packages/troika-three-utils/src/index.js",
+          "troika-worker-utils": "https://cdn.jsdelivr.net/gh/protectwise/troika@v0.52.4/packages/troika-worker-utils/src/index.js",
+          "bidi-js": "https://esm.sh/bidi-js@%5E1.0.2?target=es2022",
+          "webgl-sdf-generator": "https://esm.sh/webgl-sdf-generator@1.1.1/es2022/webgl-sdf-generator.mjs",
+          "lit": "https://cdn.jsdelivr.net/gh/lit/dist@3/core/lit-core.min.js",
+          "lit/": "https://esm.run/lit@3/",
+          "xrblocks": "https://cdn.jsdelivr.net/npm/xrblocks@0.11.0/build/xrblocks.js",
+          "xrblocks/addons/": "https://cdn.jsdelivr.net/npm/xrblocks@0.11.0/build/addons/"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <div
+      class="background-image"
+      style="background-image: url('textures/background.webp')"
+    ></div>
+    <script type="module">
+import 'xrblocks/addons/simulator/SimulatorAddons.js';
+import RAPIER from '@dimforge/rapier3d-simd-compat';
+import * as THREE from 'three';
+import * as xb from 'xrblocks';
+import {palette} from 'xrblocks/addons/utils/Palette.js';
+import {SimpleDecalGeometry} from 'xrblocks/addons/objects/SimpleDecalGeometry.js';
+// --- BallShooter inlined (from ballpit) ---
+class BallShooter extends xb.Script {
+  constructor({
+    numBalls = 100,
+    radius = 0.08,
+    palette: pal = null,
+    liveDuration = 3000,
+    deflateDuration = 200,
+    distanceThreshold = 0.25,
+    distanceFadeout = 0.25,
+  }) {
+    super();
+    this.liveDuration = liveDuration;
+    this.deflateDuration = deflateDuration;
+    this.distanceThreshold = distanceThreshold;
+    this.distanceFadeout = distanceFadeout;
+    const geometry = new THREE.IcosahedronGeometry(radius, 3);
+    this.spheres = [];
+    for (let i = 0; i < numBalls; ++i) {
+      const material = new THREE.MeshLambertMaterial({transparent: true});
+      const sphere = new THREE.Mesh(geometry, material);
+      sphere.castShadow = true;
+      sphere.receiveShadow = true;
+      this.spheres.push(sphere);
+    }
+    for (let i = 0; i < this.spheres.length; i++) {
+      this.spheres[i].position.set(Math.random() * 2 - 2, Math.random() * 2, Math.random() * 2 - 2);
+      if (pal != null) this.spheres[i].material.color.copy(pal.getRandomLiteGColor());
+    }
+    const now = performance.now();
+    this.spawnTimes = [];
+    for (let i = 0; i < numBalls; ++i) this.spawnTimes[i] = now;
+    this.nextBall = 0;
+    this.rigidBodies = [];
+    this.colliders = [];
+    this.colliderHandleToIndex = new Map();
+    this.viewSpacePosition = new THREE.Vector3();
+    this.clipSpacePosition = new THREE.Vector3();
+    this.projectedPosition = new THREE.Vector3();
+    this.clipFromWorld = new THREE.Matrix4();
+  }
+  initPhysics(physics) {
+    this.setupPhysics({
+      RAPIER: physics.RAPIER,
+      blendedWorld: physics.blendedWorld,
+      colliderActiveEvents: physics.RAPIER.ActiveEvents.CONTACT_FORCE_EVENTS,
+    });
+  }
+  setupPhysics({RAPIER, blendedWorld, colliderActiveEvents = 0, continuousCollisionDetection = false}) {
+    this.RAPIER = RAPIER;
+    this.blendedWorld = blendedWorld;
+    this.colliderActiveEvents = colliderActiveEvents;
+    this.continuousCollisionDetection = continuousCollisionDetection;
+  }
+  spawnBallAt(position, velocity = new THREE.Vector3(), now = performance.now()) {
+    const ball = this.spheres[this.nextBall];
+    ball.position.copy(position);
+    ball.scale.setScalar(1.0);
+    ball.opacity = 1.0;
+    this._createRigidBody(this.nextBall, position, velocity, ball.geometry.parameters.radius);
+    this.spawnTimes[this.nextBall] = now;
+    this.nextBall = (this.nextBall + 1) % this.spheres.length;
+    this.add(ball);
+  }
+  _createRigidBody(index, position, velocity, radius) {
+    if (this.rigidBodies[index] != null) this.blendedWorld.removeRigidBody(this.rigidBodies[index]);
+    const desc = this.RAPIER.RigidBodyDesc.dynamic().setTranslation(position.x, position.y, position.z).setLinvel(velocity.x, velocity.y, velocity.z).setCcdEnabled(this.continuousCollisionDetection);
+    const body = this.blendedWorld.createRigidBody(desc);
+    const shape = this.RAPIER.ColliderDesc.ball(radius).setActiveEvents(this.colliderActiveEvents);
+    const collider = this.blendedWorld.createCollider(shape, body);
+    this.colliderHandleToIndex.set(collider.handle, index);
+    this.rigidBodies[index] = body;
+    this.colliders[index] = collider;
+  }
+  physicsStep(now = performance.now()) {
+    for (let i = 0; i < this.spheres.length; i++) {
+      const sphere = this.spheres[i];
+      const body = this.rigidBodies[i];
+      let spawnTime = this.spawnTimes[i];
+      if (this.isBallActive(i) && body != null) {
+        let ballVisibility = 1.0;
+        const position = sphere.position.copy(body.translation());
+        const viewMatrix = xb.depth?.enabled ? xb.depth.depthViewMatrices[0] : xb.core.camera.matrixWorldInverse;
+        const projectionMatrix = xb.depth?.enabled ? xb.depth.depthProjectionMatrices[0] : xb.core.camera.projectionMatrix;
+        const viewSpacePosition = this.viewSpacePosition.copy(position).applyMatrix4(viewMatrix);
+        const clipSpacePosition = this.clipSpacePosition.copy(viewSpacePosition).applyMatrix4(projectionMatrix);
+        const ballIsInView = -1.0 <= clipSpacePosition.x && clipSpacePosition.x <= 1.0 && -1.0 <= clipSpacePosition.y && clipSpacePosition.y <= 1.0;
+        if (ballIsInView && xb.depth.enabled) {
+          const projectedPosition = xb.depth.getProjectedDepthViewPositionFromWorldPosition(position, this.projectedPosition);
+          const distanceBehindDepth = Math.max(projectedPosition.z - viewSpacePosition.z, 0.0);
+          if (distanceBehindDepth > this.distanceThreshold) {
+            const deflateAmount = Math.max((distanceBehindDepth - this.distanceThreshold) / this.distanceFadeout, 1.0);
+            spawnTime = Math.min(spawnTime, now - this.liveDuration - this.deflateDuration * deflateAmount);
+          }
+        }
+        if (now - spawnTime > this.liveDuration) {
+          const timeSinceDeflateStarted = now - spawnTime - this.liveDuration;
+          const deflateAmount = Math.min(1, timeSinceDeflateStarted / this.deflateDuration);
+          ballVisibility = 1.0 - deflateAmount;
+        }
+        sphere.material.opacity = ballVisibility;
+        if (ballVisibility < 0.001) { this.removeBall(i); }
+        else { sphere.position.copy(body.translation()); sphere.quaternion.copy(body.rotation()); }
+      }
+    }
+  }
+  getIndexForColliderHandle(handle) { return this.colliderHandleToIndex.get(handle); }
+  removeBall(index) {
+    const ball = this.spheres[index];
+    ball.material.opacity = 0.0;
+    ball.scale.setScalar(0);
+    const body = this.rigidBodies[index];
+    if (body != null) { this.blendedWorld.removeRigidBody(body); this.rigidBodies[index] = null; this.colliders[index] = null; }
+    this.remove(ball);
+  }
+  isBallActive(index) { return this.spheres[index].parent == this; }
+}
+// --- PaintSplash inlined ---
+const ASSETS_PATH = 'https://cdn.jsdelivr.net/gh/xrblocks/assets@main/';
+const kFadeoutMs = 2000;
+const textureLoader = new THREE.TextureLoader();
+const decalDiffuse = textureLoader.load(
+  './paintball_assets/decal-diffuse1.webp'
+);
+decalDiffuse.colorSpace = THREE.SRGBColorSpace;
+const decalNormal = textureLoader.load('./paintball_assets/decal-normal1.webp');
+let paintshotAudioBuffer;
+const audioLoader = new THREE.AudioLoader();
+audioLoader.load(
+  ASSETS_PATH + 'musicLibrary/PaintOneShot1.opus',
+  function (buffer) {
+    paintshotAudioBuffer = buffer;
+  }
+);
+class PaintSplash extends THREE.Object3D {
+  constructor(listener, color) {
+    super();
+    if (listener != null) {
+      this.sound = new THREE.PositionalAudio(listener);
+    }
+    this.color = color;
+    this.enableSound = true;
+    this.splashList = [];
+  }
+  splatFromIntersection(intersection, scale) {
+    const objectRotation = new THREE.Quaternion();
+    intersection.object.getWorldQuaternion(objectRotation);
+    const normal = intersection.normal.clone().applyQuaternion(objectRotation);
+    const originalNormal = new THREE.Vector3(0, 0, 1);
+    const angle = originalNormal.angleTo(normal);
+    originalNormal.cross(normal).normalize();
+    const randomRotation = new THREE.Quaternion().setFromAxisAngle(
+      normal,
+      Math.random() * Math.PI * 2
+    );
+    const rotateFacingNormal = new THREE.Quaternion()
+      .setFromAxisAngle(originalNormal, angle)
+      .premultiply(randomRotation);
+    this.splatOnMesh(
+      intersection.object,
+      intersection.point,
+      rotateFacingNormal,
+      scale
+    );
+  }
+  splatOnMesh(mesh, position, orientation, scale) {
+    const material = new THREE.MeshPhongMaterial({
+      color: this.color,
+      specular: 0x555555,
+      map: decalDiffuse,
+      normalMap: decalNormal,
+      normalScale: new THREE.Vector2(1, 1),
+      shininess: 30,
+      transparent: true,
+      depthTest: true,
+      polygonOffset: true,
+      polygonOffsetFactor: 0,
+      alphaTest: 0.5,
+      opacity: 1.0,
+      side: THREE.FrontSide,
+    });
+    const scaleVector3 = new THREE.Vector3(scale, scale, scale);
+    const geometry = new SimpleDecalGeometry(
+      mesh,
+      position,
+      orientation,
+      scaleVector3
+    );
+    geometry.computeVertexNormals();
+    this.decalMesh = new THREE.Mesh(geometry, material);
+    this.decalMesh.createdTime = performance.now();
+    this.add(this.decalMesh);
+    if (
+      this.enableSound &&
+      this.sound != null &&
+      paintshotAudioBuffer != null
+    ) {
+      this.sound.setBuffer(paintshotAudioBuffer);
+      this.sound.setRefDistance(10);
+      this.sound.play();
+    }
+  }
+  update() {
+    const currentTime = performance.now();
+    this.children.forEach((child) => {
+      if (child instanceof THREE.Mesh && child.createdTime !== undefined) {
+        const timeElapsed = currentTime - child.createdTime;
+        if (timeElapsed > kFadeoutMs) {
+          const timeSinceFadeStart = timeElapsed - kFadeoutMs;
+          if (timeSinceFadeStart <= kFadeoutMs) {
+            const newOpacity = 1.0 - timeSinceFadeStart / kFadeoutMs;
+            child.material.opacity = Math.max(0.0, newOpacity);
+            child.material.transparent = true;
+          } else {
+            this.remove(child);
+          }
+        }
+      }
+    });
+  }
+  dispose() {
+    if (this.decalMesh) {
+      this.decalMesh.geometry.dispose();
+      this.decalMesh.material.dispose();
+    }
+  }
+}
+// --- SplashScript inlined ---
+const kLightX = xb.getUrlParamFloat('lightX', 0);
+const kLightY = xb.getUrlParamFloat('lightY', 500);
+const kLightZ = xb.getUrlParamFloat('lightZ', -10);
+const kBallsPerSecond = xb.getUrlParamFloat('ballsPerSecond', 10);
+const kVelocityScale = xb.getUrlParamInt('velocityScale', 1.0);
+const kBallRadius = xb.getUrlParamFloat('ballRadius', 0.04);
+class SplashScript extends xb.Script {
+  constructor() {
+    super();
+    this.ballShooter = new BallShooter({
+      numBalls: 100,
+      radius: kBallRadius,
+      palette: palette,
+    });
+    this.add(this.ballShooter);
+    this.lastBallTime = new Map();
+    this.raycaster = new THREE.Raycaster();
+    this.paintballs = [];
+    this.listener = new THREE.AudioListener();
+    this.pointer = new THREE.Vector2();
+    this.velocity = new THREE.Vector3();
+  }
+  init() {
+    this.addLights();
+    xb.core.input.addReticles();
+    xb.showReticleOnDepthMesh(true);
+    xb.core.camera.add(this.listener);
+  }
+  initPhysics(xrPhysics) {
+    this.physics = xrPhysics;
+    this.ballShooter.setupPhysics({
+      RAPIER: xrPhysics.RAPIER,
+      blendedWorld: xrPhysics.blendedWorld,
+      colliderActiveEvents: xrPhysics.RAPIER.ActiveEvents.CONTACT_FORCE_EVENTS,
+      continuousCollisionDetection: true,
+    });
+  }
+  generateDecalAtIntersection(intersection) {
+    const paintball = new PaintSplash(
+      this.listener,
+      palette.getRandomLiteGColor()
+    );
+    const scaleMultiplier = 0.4;
+    if (xb.core.depth.depthData.length > 0) {
+      xb.core.depth.depthMesh.updateFullResolutionGeometry(
+        xb.core.depth.depthData[0]
+      );
+    }
+    paintball.splatFromIntersection(
+      intersection /*scale=*/,
+      xb.lerp(scaleMultiplier * 0.3, scaleMultiplier * 0.5, Math.random())
+    );
+    this.add(paintball);
+    this.paintballs.push(paintball);
+  }
+  generateDecalFromCollision(position, direction, color) {
+    const paintball = new PaintSplash(this.listener, color);
+    const orientation = new THREE.Quaternion().setFromUnitVectors(
+      new THREE.Vector3(0.0, 0.0, -1.0),
+      direction
+    );
+    const scaleMultiplier = 0.4;
+    const scale = xb.lerp(
+      scaleMultiplier * 0.3,
+      scaleMultiplier * 0.5,
+      Math.random()
+    );
+    if (xb.core.depth.cpuDepthData.length > 0) {
+      xb.core.depth.depthMesh.updateFullResolutionGeometry(
+        xb.core.depth.cpuDepthData[0]
+      );
+    } else if (xb.core.depth.gpuDepthData.length > 0) {
+      xb.core.depth.depthMesh.updateFullResolutionGeometry(
+        xb.core.depth.depthMesh.convertGPUToGPU(xb.core.depth.gpuDepthData[0])
+      );
+    }
+    paintball.splatOnMesh(
+      xb.core.depth.depthMesh,
+      position,
+      orientation,
+      scale
+    );
+    this.add(paintball);
+    this.paintballs.push(paintball);
+  }
+  controllerUpdate(controller) {
+    const now = performance.now();
+    if (!this.lastBallTime.has(controller)) {
+      this.lastBallTime.set(controller, -99);
+    }
+    if (
+      controller.userData.selected &&
+      now - this.lastBallTime.get(controller) >= 1000 / kBallsPerSecond
+    ) {
+      const newPosition = new THREE.Vector3(0.0, 0.0, -0.1)
+        .applyQuaternion(controller.quaternion)
+        .add(controller.position);
+      this.velocity
+        .set(0, 0, -5.0 * kVelocityScale)
+        .applyQuaternion(controller.quaternion);
+      this.ballShooter.spawnBallAt(newPosition, this.velocity);
+      this.lastBallTime.set(controller, now);
+    }
+  }
+  update() {
+    for (let controller of xb.core.input.controllers) {
+      this.controllerUpdate(controller);
+    }
+    for (let paintball of this.paintballs) {
+      paintball.update();
+    }
+  }
+  physicsStep() {
+    const contactPoint = new THREE.Vector3();
+    const forceDirection = new THREE.Vector3();
+    const ballShooter = this.ballShooter;
+    this.physics.eventQueue.drainContactForceEvents((event) => {
+      const handle1 = event.collider1();
+      const handle2 = event.collider2();
+      const depthMeshCollider =
+        xb.core.depth.depthMesh.getColliderFromHandle(handle1) ||
+        xb.core.depth.depthMesh.getColliderFromHandle(handle2);
+      const ballIndex =
+        ballShooter.getIndexForColliderHandle(handle1) ||
+        ballShooter.getIndexForColliderHandle(handle2);
+      let generatedDecal = false;
+      if (
+        depthMeshCollider &&
+        ballIndex != null &&
+        ballShooter.isBallActive(ballIndex)
+      ) {
+        const ball = ballShooter.spheres[ballIndex];
+        this.physics.blendedWorld.contactPair(
+          depthMeshCollider,
+          ballShooter.colliders[ballIndex],
+          (manifold, flipped) => {
+            if (!generatedDecal && manifold.numSolverContacts() > 0) {
+              contactPoint.copy(manifold.solverContactPoint(0));
+              forceDirection.copy(event.maxForceDirection());
+              this.generateDecalFromCollision(
+                contactPoint,
+                forceDirection,
+                ball.material.color
+              );
+              generatedDecal = true;
+            }
+          }
+        );
+        ballShooter.removeBall(ballIndex);
+      }
+    });
+    ballShooter.physicsStep();
+  }
+  addLights() {
+    this.add(new THREE.HemisphereLight(0xbbbbbb, 0x888888, 3));
+    const light = new THREE.DirectionalLight(0xffffff, 2);
+    light.position.set(kLightX, kLightY, kLightZ);
+    light.castShadow = true;
+    light.shadow.mapSize.width = 2048;
+    light.shadow.mapSize.height = 2048;
+    this.add(light);
+  }
+  onPointerUp(event) {
+    this.mouseReticle.setPressed(false);
+  }
+}
+const depthMeshColliderUpdateFps = xb.getUrlParamFloat(
+  'depthMeshColliderUpdateFps',
+  30
+);
+const splashScript = new SplashScript();
+let options = new xb.Options();
+options.simulator.instructions.enabled = false;
+options.depth = new xb.DepthOptions(xb.xrDepthMeshPhysicsOptions);
+options.depth.depthMesh.colliderUpdateFps = depthMeshColliderUpdateFps;
+options.xrButton = {
+  ...options.xrButton,
+  startText: '<i id="xrlogo"></i> MAKE A MESS',
+  endText: '<i id="xrlogo"></i> MISSION COMPLETE',
+};
+options.physics.RAPIER = RAPIER;
+options.physics.useEventQueue = true;
+async function start() {
+  xb.add(splashScript);
+  await xb.init(options);
+}
+document.addEventListener('DOMContentLoaded', function () {
+  start();
+});
+</script>
+  </body>
+</html>