three-stuff 1.0.0

package/fpscontrols.js

@@ -0,0 +1,148 @@
+import * as THREE from 'three';
+import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
+
+export class FpsControls {
+    constructor(camera, domElement, weaponModel = null) {
+        this.camera = camera;
+        this.controls = new PointerLockControls(camera, domElement);
+        this.domElement = domElement;
+
+        // --- Physics Config ---
+        this.acceleration = 100.0;
+        this.friction = 10.0;
+        this.gravity = 30.0;
+        this.jumpForce = 12.0;
+        this.playerHeight = 1.6;
+        this.playerRadius = 0.6; // Width of the player (keep this larger than your move speed)
+
+        this.jump = false;
+        this.allobj = false;
+        this.collidableObjects = [];
+
+        // --- Internal State ---
+        this.velocity = new THREE.Vector3();
+        this.move = { forward: false, backward: false, left: false, right: false, sprint: false };
+        this.canJump = false;
+        this.prevTime = performance.now();
+
+        // --- Raycasters ---
+        this.raycaster = new THREE.Raycaster();
+        
+        this.initUI();
+        this.initListeners();
+    }
+
+    set sensitivity(val) { this.controls.pointerSpeed = val / 50; }
+
+    initUI() {
+        const dot = document.createElement('div');
+        dot.style.cssText = `position:fixed;top:50%;left:50%;width:4px;height:4px;background:white;border-radius:50%;transform:translate(-50%,-50%);pointer-events:none;z-index:1000;mix-blend-mode:difference;`;
+        document.body.appendChild(dot);
+    }
+
+    initListeners() {
+        this.domElement.addEventListener('click', () => this.controls.lock());
+        window.addEventListener('keydown', (e) => this.updateKey(e.code, true));
+        window.addEventListener('keyup', (e) => this.updateKey(e.code, false));
+    }
+
+    addobj(...objs) { this.collidableObjects.push(...objs); }
+
+    updateKey(code, isPressed) {
+        switch (code) {
+            case 'KeyW': this.move.forward = isPressed; break;
+            case 'KeyS': this.move.backward = isPressed; break;
+            case 'KeyA': this.move.left = isPressed; break;
+            case 'KeyD': this.move.right = isPressed; break;
+            case 'ShiftLeft': this.move.sprint = isPressed; break;
+            case 'Space': 
+                if (isPressed && this.jump && this.canJump) {
+                    this.velocity.y = this.jumpForce;
+                    this.canJump = false;
+                }
+                break;
+        }
+    }
+
+    update() {
+        if (!this.controls.isLocked) return;
+
+        const time = performance.now();
+        const delta = Math.min((time - this.prevTime) / 1000, 0.05);
+        this.prevTime = time;
+
+        const targets = this.allobj && this.camera.parent ? this.camera.parent.children : this.collidableObjects;
+
+        // 1. Physics Calculations
+        this.velocity.x -= this.velocity.x * this.friction * delta;
+        this.velocity.z -= this.velocity.z * this.friction * delta;
+        this.velocity.y -= this.gravity * delta;
+
+        const multiplier = this.move.sprint ? 2.0 : 1.0;
+        const accel = this.acceleration * multiplier * delta;
+
+        if (this.move.forward) this.velocity.z += accel;
+        if (this.move.backward) this.velocity.z -= accel;
+        if (this.move.left) this.velocity.x -= accel;
+        if (this.move.right) this.velocity.x += accel;
+
+        // 2. HORIZONTAL COLLISION (Wall Checking)
+        // We create a vector of where we WANT to go
+        const moveVector = new THREE.Vector3();
+        moveVector.x = this.velocity.x * delta;
+        moveVector.z = this.velocity.z * delta;
+
+        if (moveVector.length() > 0) {
+            // Get movement direction in world space
+            const worldDir = new THREE.Vector3(moveVector.x, 0, -moveVector.z).applyQuaternion(this.camera.quaternion);
+            worldDir.y = 0; // Keep check horizontal
+            worldDir.normalize();
+
+            // Cast a ray from "hip height" so we don't trip over the floor we are standing on
+            const rayOrigin = this.camera.position.clone();
+            rayOrigin.y -= 0.5; 
+
+            this.raycaster.set(rayOrigin, worldDir);
+            this.raycaster.far = this.playerRadius; 
+
+            const wallHits = this.raycaster.intersectObjects(targets, true);
+
+            if (wallHits.length > 0) {
+                // We hit a wall! Stop horizontal velocity
+                this.velocity.x = 0;
+                this.velocity.z = 0;
+            } else {
+                // Path clear, apply horizontal movement
+                this.controls.moveRight(moveVector.x);
+                this.controls.moveForward(moveVector.z);
+            }
+        }
+
+        // 3. VERTICAL COLLISION (Floor/Gravity)
+        this.camera.position.y += this.velocity.y * delta;
+
+        this.raycaster.set(this.camera.position, new THREE.Vector3(0, -1, 0));
+        this.raycaster.far = this.playerHeight;
+        
+        const floorHits = this.raycaster.intersectObjects(targets, true);
+
+        if (floorHits.length > 0) {
+            const hit = floorHits[0];
+            // Only snap to floor if we are actually falling ONTO it, 
+            // not if the floor is magically above our heads.
+            if (this.velocity.y <= 0) {
+                this.camera.position.y = hit.point.y + this.playerHeight;
+                this.velocity.y = 0;
+                this.canJump = true;
+            }
+        } else {
+            this.canJump = false;
+            // Basic ground plane at 0
+            if (this.camera.position.y < this.playerHeight) {
+                this.camera.position.y = this.playerHeight;
+                this.velocity.y = 0;
+                this.canJump = true;
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "three-stuff",
+  "version": "1.0.0",
+  "description": "this is ibaads files of modules that he made with easy acces to things like fps controls, physics, and shadows without having to write complicated stuff",
+  "main": "fpscontrols.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/physics.js

@@ -0,0 +1,57 @@
+import * as CANNON from 'cannon-es';
+import * as THREE from 'three';
+
+export class PhysicsEngine {
+    constructor() {
+        this.world = new CANNON.World();
+        this.world.gravity.set(0, -9.82, 0);
+        this.meshMap = new Map();
+    }
+
+    update(scene) {
+        this.world.step(1 / 60);
+
+        scene.traverse((obj) => {
+            if (obj.isMesh && (obj.dynamic === true || obj.static === true)) {
+                if (!this.meshMap.has(obj)) {
+                    this._addBody(obj);
+                }
+                
+                if (obj.dynamic) {
+                    const body = this.meshMap.get(obj);
+                    obj.position.copy(body.position);
+                    obj.quaternion.copy(body.quaternion);
+                }
+            }
+        });
+    }
+
+    _addBody(mesh) {
+        // Measure the geometry
+        mesh.geometry.computeBoundingBox();
+        const size = new THREE.Vector3();
+        mesh.geometry.boundingBox.getSize(size);
+
+        // --- THE FIX IS HERE ---
+        // We ensure no dimension is 0. If it's a plane, we give it 0.1 thickness.
+        const hitBoxSize = new CANNON.Vec3(
+            Math.max(size.x * mesh.scale.x, 0.1) / 2,
+            Math.max(size.y * mesh.scale.y, 0.1) / 2,
+            Math.max(size.z * mesh.scale.z, 0.1) / 2
+        );
+        
+        const shape = new CANNON.Box(hitBoxSize);
+
+        const body = new CANNON.Body({
+            mass: mesh.dynamic ? (mesh.mass || 1) : 0,
+            shape: shape
+        });
+
+        // Sync initial state
+        body.position.copy(mesh.position);
+        body.quaternion.copy(mesh.quaternion);
+
+        this.world.addBody(body);
+        this.meshMap.set(mesh, body);
+    }
+}

package/shadowinit.js

@@ -0,0 +1,262 @@
+// ShadowInit.js
+import * as THREE from 'https://esm.sh/three@0.160.0';
+import { EffectComposer } from 'https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/postprocessing/EffectComposer.js/+esm';
+import { RenderPass } from 'https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/postprocessing/RenderPass.js/+esm';
+import { SSAOPass } from 'https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/postprocessing/SSAOPass.js/+esm';
+import { UnrealBloomPass } from 'https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/postprocessing/UnrealBloomPass.js/+esm';
+import { SSRPass } from 'https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/postprocessing/SSRPass.js/+esm';
+
+export class ShadowInit {
+  constructor() {
+    this.scene = null;
+    this.renderer = null;
+    this.camera = null;
+
+    this.emissiveLights = new Map();
+    this.reflectionCameras = new Map();
+
+    this._patched = false;
+    this._raytracing = false;
+
+    // Composer and passes for hybrid RTX-like mode
+    this.composer = null;
+    this.renderPass = null;
+    this.ssaoPass = null;
+    this.ssrPass = null;
+    this.bloomPass = null;
+  }
+
+  /* ------------------------ ATTACH ------------------------ */
+  attach(scene, renderer, camera) {
+    this.scene = scene;
+    this.renderer = renderer;
+    this.camera = camera;
+
+    this._enableRasterMode();       // <-- set default shadows
+    this._addSunLight();            // default directional light
+
+    if (!this._patched) {
+      this._patchSceneAdd();        // auto-detect new meshes
+      this._patched = true;
+    }
+
+    // Process all existing meshes in the scene
+    scene.traverse(obj => this._processObject(obj));
+  }
+
+  /* ------------------------ RASTER MODE ------------------------ */
+  _enableRasterMode() {
+    if (!this.renderer) return;
+
+    this.renderer.shadowMap.enabled = true;
+    this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    this.renderer.physicallyCorrectLights = true;
+    this.renderer.outputColorSpace = THREE.SRGBColorSpace;
+    this.renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    this.renderer.toneMappingExposure = 1.25;
+  }
+
+  /* ------------------------ PATCH SCENE.ADD ------------------------ */
+  _patchSceneAdd() {
+    const originalAdd = this.scene.add.bind(this.scene);
+    this.scene.add = (...objects) => {
+      objects.forEach(obj => this._processObject(obj));
+      originalAdd(...objects);
+    };
+  }
+
+  /* ------------------------ PROCESS OBJECT ------------------------ */
+  _processObject(obj) {
+    if (!obj || obj.__shadowEngineProcessed) return;
+
+    if (obj.isMesh) {
+      obj.castShadow = true;
+      obj.receiveShadow = true;
+
+      if (!obj.shadows) obj.shadows = {};
+
+      // eLight property
+      Object.defineProperty(obj.shadows, "eLight", {
+        set: v => this._applyEmissiveLight(obj, v)
+      });
+
+      // reflective property
+      Object.defineProperty(obj.shadows, "reflective", {
+        set: v => this._applyReflection(obj, v)
+      });
+
+      // helper to update reflection
+      obj.shadows.updateReflection = () => this._updateReflection(obj);
+    }
+
+    obj.__shadowEngineProcessed = true;
+
+    if (obj.children) obj.children.forEach(c => this._processObject(c));
+  }
+
+  /* ------------------------ DEFAULT SUN ------------------------ */
+  _addSunLight() {
+    const sun = new THREE.DirectionalLight(0xffffff, 1.2);
+    sun.position.set(15, 25, 15);
+    sun.castShadow = true;
+    sun.shadow.mapSize.set(2048, 2048);
+    sun.shadow.camera.near = 1;
+    sun.shadow.camera.far = 150;
+    sun.shadow.camera.left = -40;
+    sun.shadow.camera.right = 40;
+    sun.shadow.camera.top = 40;
+    sun.shadow.camera.bottom = -40;
+    sun.shadow.bias = -0.0002;
+
+    this.scene.add(sun);
+    this.scene.add(sun.target);
+  }
+
+  /* ------------------------ EMISSIVE LIGHT ------------------------ */
+  _applyEmissiveLight(mesh, value) {
+    if (!Array.isArray(value)) return;
+
+    const baseIntensity = value[0] ?? 1;
+    const color = new THREE.Color(value[1] ?? 0xffffff).convertSRGBToLinear();
+
+    // remove old lights
+    if (this.emissiveLights.has(mesh)) {
+      this.emissiveLights.get(mesh).forEach(l => mesh.remove(l));
+    }
+
+    // compute mesh size
+    const box = new THREE.Box3().setFromObject(mesh);
+    const size = box.getSize(new THREE.Vector3());
+    const area = size.x * size.y + size.y * size.z + size.x * size.z;
+    const intensity = baseIntensity * area * 0.15;
+
+    const lights = [];
+
+    // area-light approximation
+    const offsets = [
+      [0.5, 0, 0], [-0.5, 0, 0],
+      [0, 0.5, 0], [0, -0.5, 0],
+      [0, 0, 0.5], [0, 0, -0.5]
+    ];
+
+    for (const o of offsets) {
+      const light = new THREE.PointLight(color, intensity / offsets.length);
+      light.castShadow = true;
+      light.shadow.mapSize.set(1024, 1024);
+      light.shadow.bias = -0.00025;
+      light.distance = Math.max(size.x, size.y, size.z) * 8;
+      light.position.set(o[0]*size.x, o[1]*size.y, o[2]*size.z);
+      mesh.add(light);
+      lights.push(light);
+    }
+
+    // fake bounce light
+    const bounce = new THREE.PointLight(color, intensity * 0.25);
+    bounce.castShadow = false;
+    bounce.distance = Math.max(size.x, size.y, size.z) * 12;
+    bounce.position.set(0, -size.y*0.6, 0);
+    mesh.add(bounce);
+    lights.push(bounce);
+
+    if (mesh.material?.isMeshStandardMaterial) {
+      mesh.material.emissive = color.clone();
+      mesh.material.emissiveIntensity = baseIntensity;
+      mesh.material.needsUpdate = true;
+    }
+
+    this.emissiveLights.set(mesh, lights);
+  }
+
+  /* ------------------------ REFLECTION ------------------------ */
+  _applyReflection(mesh, strength = 0.5) {
+    strength = THREE.MathUtils.clamp(strength, 0, 1);
+    if (!mesh.material?.isMeshStandardMaterial) return;
+
+    let cam = this.reflectionCameras.get(mesh);
+    if (!cam) {
+      cam = new THREE.CubeCamera(0.1, 1500, 256);
+      this.scene.add(cam);
+      this.reflectionCameras.set(mesh, cam);
+    }
+
+    mesh.material.envMap = cam.renderTarget.texture;
+    mesh.material.metalness = strength;
+    mesh.material.roughness = 1 - strength*0.9;
+    mesh.material.needsUpdate = true;
+
+    this._updateReflection(mesh);
+  }
+
+  _updateReflection(mesh) {
+    const cam = this.reflectionCameras.get(mesh);
+    if (!cam) return;
+    mesh.visible = false;
+    cam.position.copy(mesh.getWorldPosition(new THREE.Vector3()));
+    cam.update(this.renderer, this.scene);
+    mesh.visible = true;
+  }
+
+  /* ------------------------ HYBRID RTX-LIKE PIPELINE ------------------------ */
+  set raytracing(val) {
+    this._raytracing = val;
+
+    if (!this.renderer || !this.camera) return;
+
+    if (val) this._enableHybridPipeline();
+    else this._disableHybridPipeline();
+  }
+
+  get raytracing() { return this._raytracing; }
+
+  _enableHybridPipeline() {
+    if (!this.renderer || !this.camera) return;
+
+    if (!this.composer) {
+      this.composer = new EffectComposer(this.renderer);
+      this.renderPass = new RenderPass(this.scene, this.camera);
+      this.composer.addPass(this.renderPass);
+
+      this.ssaoPass = new SSAOPass(this.scene, this.camera, window.innerWidth, window.innerHeight);
+      this.ssaoPass.kernelRadius = 8;
+      this.composer.addPass(this.ssaoPass);
+
+      this.ssrPass = new SSRPass({
+        renderer: this.renderer,
+        scene: this.scene,
+        camera: this.camera,
+        width: window.innerWidth,
+        height: window.innerHeight,
+        groundReflector: null,
+        selects: []
+      });
+      this.composer.addPass(this.ssrPass);
+
+      this.bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 0.6, 0.4, 0.85);
+      this.composer.addPass(this.bloomPass);
+    }
+
+    this.renderer.shadowMap.enabled = false;
+  }
+
+  _disableHybridPipeline() {
+    if (this.composer) {
+      this.composer.passes = [];
+      this.composer = null;
+    }
+    this._enableRasterMode();
+  }
+
+  /* ------------------------ RENDER ------------------------ */
+  render() {
+    if (this._raytracing && this.composer) {
+      if (this.renderer.domElement.parentElement) this.composer.render();
+    } else {
+      if (this.renderer && this.scene && this.camera) this.renderer.render(this.scene, this.camera);
+    }
+  }
+
+  /* ------------------------ OPTIONAL: VOLMETRICS ------------------------ */
+  enableVolumetrics(color = 0x0a0a0a, density = 0.02) {
+    this.scene.fog = new THREE.FogExp2(color, density);
+  }
+}