three-stdlib 2.22.7 → 2.22.9

package/dist/postprocessing/UnrealBloomPass.mjs

@@ -0,0 +1,220 @@
+import { Vector2, Color, LinearFilter, RGBAFormat, WebGLRenderTarget, UniformsUtils, ShaderMaterial, Vector3, AdditiveBlending, MeshBasicMaterial } from "three";
+import { FullScreenQuad, Pass } from "./Pass.mjs";
+import { CopyShader } from "../shaders/CopyShader.mjs";
+import { LuminosityHighPassShader } from "../shaders/LuminosityHighPassShader.mjs";
+var UnrealBloomPass = function(resolution, strength, radius, threshold) {
+  this.strength = strength !== void 0 ? strength : 1;
+  this.radius = radius;
+  this.threshold = threshold;
+  this.resolution = resolution !== void 0 ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256);
+  this.clearColor = new Color(0, 0, 0);
+  var pars = {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat
+  };
+  this.renderTargetsHorizontal = [];
+  this.renderTargetsVertical = [];
+  this.nMips = 5;
+  var resx = Math.round(this.resolution.x / 2);
+  var resy = Math.round(this.resolution.y / 2);
+  this.renderTargetBright = new WebGLRenderTarget(resx, resy, pars);
+  this.renderTargetBright.texture.name = "UnrealBloomPass.bright";
+  this.renderTargetBright.texture.generateMipmaps = false;
+  for (let i = 0; i < this.nMips; i++) {
+    var renderTargetHorizonal = new WebGLRenderTarget(resx, resy, pars);
+    renderTargetHorizonal.texture.name = "UnrealBloomPass.h" + i;
+    renderTargetHorizonal.texture.generateMipmaps = false;
+    this.renderTargetsHorizontal.push(renderTargetHorizonal);
+    var renderTargetVertical = new WebGLRenderTarget(resx, resy, pars);
+    renderTargetVertical.texture.name = "UnrealBloomPass.v" + i;
+    renderTargetVertical.texture.generateMipmaps = false;
+    this.renderTargetsVertical.push(renderTargetVertical);
+    resx = Math.round(resx / 2);
+    resy = Math.round(resy / 2);
+  }
+  if (LuminosityHighPassShader === void 0)
+    console.error("THREE.UnrealBloomPass relies on LuminosityHighPassShader");
+  var highPassShader = LuminosityHighPassShader;
+  this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms);
+  this.highPassUniforms["luminosityThreshold"].value = threshold;
+  this.highPassUniforms["smoothWidth"].value = 0.01;
+  this.materialHighPassFilter = new ShaderMaterial({
+    uniforms: this.highPassUniforms,
+    vertexShader: highPassShader.vertexShader,
+    fragmentShader: highPassShader.fragmentShader,
+    defines: {}
+  });
+  this.separableBlurMaterials = [];
+  var kernelSizeArray = [3, 5, 7, 9, 11];
+  var resx = Math.round(this.resolution.x / 2);
+  var resy = Math.round(this.resolution.y / 2);
+  for (let i = 0; i < this.nMips; i++) {
+    this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]));
+    this.separableBlurMaterials[i].uniforms["texSize"].value = new Vector2(resx, resy);
+    resx = Math.round(resx / 2);
+    resy = Math.round(resy / 2);
+  }
+  this.compositeMaterial = this.getCompositeMaterial(this.nMips);
+  this.compositeMaterial.uniforms["blurTexture1"].value = this.renderTargetsVertical[0].texture;
+  this.compositeMaterial.uniforms["blurTexture2"].value = this.renderTargetsVertical[1].texture;
+  this.compositeMaterial.uniforms["blurTexture3"].value = this.renderTargetsVertical[2].texture;
+  this.compositeMaterial.uniforms["blurTexture4"].value = this.renderTargetsVertical[3].texture;
+  this.compositeMaterial.uniforms["blurTexture5"].value = this.renderTargetsVertical[4].texture;
+  this.compositeMaterial.uniforms["bloomStrength"].value = strength;
+  this.compositeMaterial.uniforms["bloomRadius"].value = 0.1;
+  this.compositeMaterial.needsUpdate = true;
+  var bloomFactors = [1, 0.8, 0.6, 0.4, 0.2];
+  this.compositeMaterial.uniforms["bloomFactors"].value = bloomFactors;
+  this.bloomTintColors = [
+    new Vector3(1, 1, 1),
+    new Vector3(1, 1, 1),
+    new Vector3(1, 1, 1),
+    new Vector3(1, 1, 1),
+    new Vector3(1, 1, 1)
+  ];
+  this.compositeMaterial.uniforms["bloomTintColors"].value = this.bloomTintColors;
+  if (CopyShader === void 0) {
+    console.error("THREE.UnrealBloomPass relies on CopyShader");
+  }
+  var copyShader = CopyShader;
+  this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
+  this.copyUniforms["opacity"].value = 1;
+  this.materialCopy = new ShaderMaterial({
+    uniforms: this.copyUniforms,
+    vertexShader: copyShader.vertexShader,
+    fragmentShader: copyShader.fragmentShader,
+    blending: AdditiveBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true
+  });
+  this.enabled = true;
+  this.needsSwap = false;
+  this._oldClearColor = new Color();
+  this.oldClearAlpha = 1;
+  this.basic = new MeshBasicMaterial();
+  this.fsQuad = new FullScreenQuad(null);
+};
+UnrealBloomPass.prototype = Object.assign(Object.create(Pass.prototype), {
+  constructor: UnrealBloomPass,
+  dispose: function() {
+    for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
+      this.renderTargetsHorizontal[i].dispose();
+    }
+    for (let i = 0; i < this.renderTargetsVertical.length; i++) {
+      this.renderTargetsVertical[i].dispose();
+    }
+    this.renderTargetBright.dispose();
+  },
+  setSize: function(width, height) {
+    var resx = Math.round(width / 2);
+    var resy = Math.round(height / 2);
+    this.renderTargetBright.setSize(resx, resy);
+    for (let i = 0; i < this.nMips; i++) {
+      this.renderTargetsHorizontal[i].setSize(resx, resy);
+      this.renderTargetsVertical[i].setSize(resx, resy);
+      this.separableBlurMaterials[i].uniforms["texSize"].value = new Vector2(resx, resy);
+      resx = Math.round(resx / 2);
+      resy = Math.round(resy / 2);
+    }
+  },
+  render: function(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+    renderer.getClearColor(this._oldClearColor);
+    this.oldClearAlpha = renderer.getClearAlpha();
+    var oldAutoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    renderer.setClearColor(this.clearColor, 0);
+    if (maskActive)
+      renderer.state.buffers.stencil.setTest(false);
+    if (this.renderToScreen) {
+      this.fsQuad.material = this.basic;
+      this.basic.map = readBuffer.texture;
+      renderer.setRenderTarget(null);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    this.highPassUniforms["tDiffuse"].value = readBuffer.texture;
+    this.highPassUniforms["luminosityThreshold"].value = this.threshold;
+    this.fsQuad.material = this.materialHighPassFilter;
+    renderer.setRenderTarget(this.renderTargetBright);
+    renderer.clear();
+    this.fsQuad.render(renderer);
+    var inputRenderTarget = this.renderTargetBright;
+    for (let i = 0; i < this.nMips; i++) {
+      this.fsQuad.material = this.separableBlurMaterials[i];
+      this.separableBlurMaterials[i].uniforms["colorTexture"].value = inputRenderTarget.texture;
+      this.separableBlurMaterials[i].uniforms["direction"].value = UnrealBloomPass.BlurDirectionX;
+      renderer.setRenderTarget(this.renderTargetsHorizontal[i]);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+      this.separableBlurMaterials[i].uniforms["colorTexture"].value = this.renderTargetsHorizontal[i].texture;
+      this.separableBlurMaterials[i].uniforms["direction"].value = UnrealBloomPass.BlurDirectionY;
+      renderer.setRenderTarget(this.renderTargetsVertical[i]);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+      inputRenderTarget = this.renderTargetsVertical[i];
+    }
+    this.fsQuad.material = this.compositeMaterial;
+    this.compositeMaterial.uniforms["bloomStrength"].value = this.strength;
+    this.compositeMaterial.uniforms["bloomRadius"].value = this.radius;
+    this.compositeMaterial.uniforms["bloomTintColors"].value = this.bloomTintColors;
+    renderer.setRenderTarget(this.renderTargetsHorizontal[0]);
+    renderer.clear();
+    this.fsQuad.render(renderer);
+    this.fsQuad.material = this.materialCopy;
+    this.copyUniforms["tDiffuse"].value = this.renderTargetsHorizontal[0].texture;
+    if (maskActive)
+      renderer.state.buffers.stencil.setTest(true);
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(readBuffer);
+      this.fsQuad.render(renderer);
+    }
+    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha);
+    renderer.autoClear = oldAutoClear;
+  },
+  getSeperableBlurMaterial: function(kernelRadius) {
+    return new ShaderMaterial({
+      defines: {
+        KERNEL_RADIUS: kernelRadius,
+        SIGMA: kernelRadius
+      },
+      uniforms: {
+        colorTexture: { value: null },
+        texSize: { value: new Vector2(0.5, 0.5) },
+        direction: { value: new Vector2(0.5, 0.5) }
+      },
+      vertexShader: "varying vec2 vUv;\nvoid main() {\n	vUv = uv;\n	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",
+      fragmentShader: "#include <common>varying vec2 vUv;\nuniform sampler2D colorTexture;\nuniform vec2 texSize;uniform vec2 direction;\nfloat gaussianPdf(in float x, in float sigma) {	return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;}void main() {\n	vec2 invSize = 1.0 / texSize;	float fSigma = float(SIGMA);	float weightSum = gaussianPdf(0.0, fSigma);	vec3 diffuseSum = texture2D( colorTexture, vUv).rgb * weightSum;	for( int i = 1; i < KERNEL_RADIUS; i ++ ) {		float x = float(i);		float w = gaussianPdf(x, fSigma);		vec2 uvOffset = direction * invSize * x;		vec3 sample1 = texture2D( colorTexture, vUv + uvOffset).rgb;		vec3 sample2 = texture2D( colorTexture, vUv - uvOffset).rgb;		diffuseSum += (sample1 + sample2) * w;		weightSum += 2.0 * w;	}	gl_FragColor = vec4(diffuseSum/weightSum, 1.0);\n}"
+    });
+  },
+  getCompositeMaterial: function(nMips) {
+    return new ShaderMaterial({
+      defines: {
+        NUM_MIPS: nMips
+      },
+      uniforms: {
+        blurTexture1: { value: null },
+        blurTexture2: { value: null },
+        blurTexture3: { value: null },
+        blurTexture4: { value: null },
+        blurTexture5: { value: null },
+        dirtTexture: { value: null },
+        bloomStrength: { value: 1 },
+        bloomFactors: { value: null },
+        bloomTintColors: { value: null },
+        bloomRadius: { value: 0 }
+      },
+      vertexShader: "varying vec2 vUv;\nvoid main() {\n	vUv = uv;\n	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",
+      fragmentShader: "varying vec2 vUv;uniform sampler2D blurTexture1;uniform sampler2D blurTexture2;uniform sampler2D blurTexture3;uniform sampler2D blurTexture4;uniform sampler2D blurTexture5;uniform sampler2D dirtTexture;uniform float bloomStrength;uniform float bloomRadius;uniform float bloomFactors[NUM_MIPS];uniform vec3 bloomTintColors[NUM_MIPS];float lerpBloomFactor(const in float factor) { 	float mirrorFactor = 1.2 - factor;	return mix(factor, mirrorFactor, bloomRadius);}void main() {	gl_FragColor = bloomStrength * ( lerpBloomFactor(bloomFactors[0]) * vec4(bloomTintColors[0], 1.0) * texture2D(blurTexture1, vUv) + 									 lerpBloomFactor(bloomFactors[1]) * vec4(bloomTintColors[1], 1.0) * texture2D(blurTexture2, vUv) + 									 lerpBloomFactor(bloomFactors[2]) * vec4(bloomTintColors[2], 1.0) * texture2D(blurTexture3, vUv) + 									 lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) + 									 lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );}"
+    });
+  }
+});
+UnrealBloomPass.BlurDirectionX = new Vector2(1, 0);
+UnrealBloomPass.BlurDirectionY = new Vector2(0, 1);
+export {
+  UnrealBloomPass
+};

package/dist/postprocessing/WaterPass.d.ts

@@ -0,0 +1,30 @@
+import { WebGLRenderer, WebGLRenderTarget, ShaderMaterial } from 'three';
+import { Pass, FullScreenQuad } from '../postprocessing/Pass';
+/**
+ * Simple underwater shader
+ *
+ 
+ parameters:
+ tex: texture
+ time: this should increase with time passing
+ factor: to what degree will the shader distort the screen
+
+ explaination:
+ the shader is quite simple
+ it chooses a center and start from there make pixels around it to "swell" then "shrink" then "swell"...
+ this is of course nothing really similar to underwater scene
+ but you can combine several this shaders together to create the effect you need...
+ And yes, this shader could be used for something other than underwater effect, for example, magnifier effect :)
+
+ * @author vergil Wang
+ */
+declare class WaterPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    factor: number;
+    time: number;
+    uniforms: any;
+    constructor();
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+export { WaterPass };

package/dist/postprocessing/WaterPass.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+class WaterPass extends Pass.Pass {
+  constructor() {
+    super();
+    __publicField(this, "material");
+    __publicField(this, "fsQuad");
+    __publicField(this, "factor");
+    __publicField(this, "time");
+    __publicField(this, "uniforms");
+    this.uniforms = THREE.UniformsUtils.clone({
+      tex: { value: null },
+      time: { value: 0 },
+      factor: { value: 0 },
+      resolution: { value: new THREE.Vector2(64, 64) }
+    });
+    this.material = new THREE.ShaderMaterial({
+      uniforms: this.uniforms,
+      vertexShader: `
+      varying vec2 vUv;
+      void main(){  
+        vUv = uv; 
+        vec4 modelViewPosition = modelViewMatrix * vec4(position, 1.0);
+        gl_Position = projectionMatrix * modelViewPosition;
+      }`,
+      fragmentShader: `
+      uniform float time;
+      uniform float factor;
+      uniform vec2 resolution;
+      uniform sampler2D tex;
+      varying vec2 vUv;
+      void main() {  
+        vec2 uv1 = vUv;
+        vec2 uv = gl_FragCoord.xy/resolution.xy;
+        float frequency = 6.0 * factor;
+        float amplitude = 0.015 * factor;
+        float x = uv1.y * frequency + time * .7; 
+        float y = uv1.x * frequency + time * .3;
+        uv1.x += cos(x+y) * amplitude * cos(y);
+        uv1.y += sin(x-y) * amplitude * cos(y);
+        vec4 rgba = texture2D(tex, uv1);
+        gl_FragColor = rgba;
+      }`
+    });
+    this.fsQuad = new Pass.FullScreenQuad(this.material);
+    this.factor = 0;
+    this.time = 0;
+  }
+  render(renderer, writeBuffer, readBuffer) {
+    this.uniforms["tex"].value = readBuffer.texture;
+    this.uniforms["time"].value = this.time;
+    this.uniforms["factor"].value = this.factor;
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(writeBuffer);
+      if (this.clear)
+        renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+  }
+}
+exports.WaterPass = WaterPass;

package/dist/postprocessing/WaterPass.mjs

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { UniformsUtils, Vector2, ShaderMaterial } from "three";
+import { Pass, FullScreenQuad } from "./Pass.mjs";
+class WaterPass extends Pass {
+  constructor() {
+    super();
+    __publicField(this, "material");
+    __publicField(this, "fsQuad");
+    __publicField(this, "factor");
+    __publicField(this, "time");
+    __publicField(this, "uniforms");
+    this.uniforms = UniformsUtils.clone({
+      tex: { value: null },
+      time: { value: 0 },
+      factor: { value: 0 },
+      resolution: { value: new Vector2(64, 64) }
+    });
+    this.material = new ShaderMaterial({
+      uniforms: this.uniforms,
+      vertexShader: `
+      varying vec2 vUv;
+      void main(){  
+        vUv = uv; 
+        vec4 modelViewPosition = modelViewMatrix * vec4(position, 1.0);
+        gl_Position = projectionMatrix * modelViewPosition;
+      }`,
+      fragmentShader: `
+      uniform float time;
+      uniform float factor;
+      uniform vec2 resolution;
+      uniform sampler2D tex;
+      varying vec2 vUv;
+      void main() {  
+        vec2 uv1 = vUv;
+        vec2 uv = gl_FragCoord.xy/resolution.xy;
+        float frequency = 6.0 * factor;
+        float amplitude = 0.015 * factor;
+        float x = uv1.y * frequency + time * .7; 
+        float y = uv1.x * frequency + time * .3;
+        uv1.x += cos(x+y) * amplitude * cos(y);
+        uv1.y += sin(x-y) * amplitude * cos(y);
+        vec4 rgba = texture2D(tex, uv1);
+        gl_FragColor = rgba;
+      }`
+    });
+    this.fsQuad = new FullScreenQuad(this.material);
+    this.factor = 0;
+    this.time = 0;
+  }
+  render(renderer, writeBuffer, readBuffer) {
+    this.uniforms["tex"].value = readBuffer.texture;
+    this.uniforms["time"].value = this.time;
+    this.uniforms["factor"].value = this.factor;
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(writeBuffer);
+      if (this.clear)
+        renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+  }
+}
+export {
+  WaterPass
+};

package/dist/renderers/CSS2DRenderer.d.ts

@@ -0,0 +1,22 @@
+import { Object3D, Scene, Camera } from 'three'
+
+export class CSS2DObject extends Object3D {
+  constructor(element: HTMLElement)
+  element: HTMLElement
+
+  onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+  onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+}
+
+export type CSS2DParameters = {
+  element?: HTMLElement
+}
+
+export class CSS2DRenderer {
+  constructor(parameters?: CSS2DParameters)
+  domElement: HTMLElement
+
+  getSize(): { width: number; height: number }
+  setSize(width: number, height: number): void
+  render(scene: Scene, camera: Camera): void
+}

package/dist/renderers/CSS2DRenderer.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class CSS2DObject extends THREE.Object3D {
+  constructor(element = document.createElement("div")) {
+    super();
+    this.isCSS2DObject = true;
+    this.element = element;
+    this.element.style.position = "absolute";
+    this.element.style.userSelect = "none";
+    this.element.setAttribute("draggable", false);
+    this.addEventListener("removed", function() {
+      this.traverse(function(object) {
+        if (object.element instanceof Element && object.element.parentNode !== null) {
+          object.element.parentNode.removeChild(object.element);
+        }
+      });
+    });
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.element = source.element.cloneNode(true);
+    return this;
+  }
+}
+const _vector = /* @__PURE__ */ new THREE.Vector3();
+const _viewMatrix = /* @__PURE__ */ new THREE.Matrix4();
+const _viewProjectionMatrix = /* @__PURE__ */ new THREE.Matrix4();
+const _a = /* @__PURE__ */ new THREE.Vector3();
+const _b = /* @__PURE__ */ new THREE.Vector3();
+class CSS2DRenderer {
+  constructor(parameters = {}) {
+    const _this = this;
+    let _width, _height;
+    let _widthHalf, _heightHalf;
+    const cache = {
+      objects: /* @__PURE__ */ new WeakMap()
+    };
+    const domElement = parameters.element !== void 0 ? parameters.element : document.createElement("div");
+    domElement.style.overflow = "hidden";
+    this.domElement = domElement;
+    this.getSize = function() {
+      return {
+        width: _width,
+        height: _height
+      };
+    };
+    this.render = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true || scene.autoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && (camera.matrixWorldAutoUpdate == null || camera.matrixWorldAutoUpdate === true)) {
+        camera.updateMatrixWorld();
+      }
+      _viewMatrix.copy(camera.matrixWorldInverse);
+      _viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);
+      renderObject(scene, scene, camera);
+      zOrder(scene);
+    };
+    this.setSize = function(width, height) {
+      _width = width;
+      _height = height;
+      _widthHalf = _width / 2;
+      _heightHalf = _height / 2;
+      domElement.style.width = width + "px";
+      domElement.style.height = height + "px";
+    };
+    function renderObject(object, scene, camera) {
+      if (object.isCSS2DObject) {
+        _vector.setFromMatrixPosition(object.matrixWorld);
+        _vector.applyMatrix4(_viewProjectionMatrix);
+        const visible = object.visible === true && _vector.z >= -1 && _vector.z <= 1 && object.layers.test(camera.layers) === true;
+        object.element.style.display = visible === true ? "" : "none";
+        if (visible === true) {
+          object.onBeforeRender(_this, scene, camera);
+          const element = object.element;
+          element.style.transform = "translate(-50%,-50%) translate(" + (_vector.x * _widthHalf + _widthHalf) + "px," + (-_vector.y * _heightHalf + _heightHalf) + "px)";
+          if (element.parentNode !== domElement) {
+            domElement.appendChild(element);
+          }
+          object.onAfterRender(_this, scene, camera);
+        }
+        const objectData = {
+          distanceToCameraSquared: getDistanceToSquared(camera, object)
+        };
+        cache.objects.set(object, objectData);
+      }
+      for (let i = 0, l = object.children.length; i < l; i++) {
+        renderObject(object.children[i], scene, camera);
+      }
+    }
+    function getDistanceToSquared(object1, object2) {
+      _a.setFromMatrixPosition(object1.matrixWorld);
+      _b.setFromMatrixPosition(object2.matrixWorld);
+      return _a.distanceToSquared(_b);
+    }
+    function filterAndFlatten(scene) {
+      const result = [];
+      scene.traverse(function(object) {
+        if (object.isCSS2DObject)
+          result.push(object);
+      });
+      return result;
+    }
+    function zOrder(scene) {
+      const sorted = filterAndFlatten(scene).sort(function(a, b) {
+        if (a.renderOrder !== b.renderOrder) {
+          return b.renderOrder - a.renderOrder;
+        }
+        const distanceA = cache.objects.get(a).distanceToCameraSquared;
+        const distanceB = cache.objects.get(b).distanceToCameraSquared;
+        return distanceA - distanceB;
+      });
+      const zMax = sorted.length;
+      for (let i = 0, l = sorted.length; i < l; i++) {
+        sorted[i].element.style.zIndex = zMax - i;
+      }
+    }
+  }
+}
+exports.CSS2DObject = CSS2DObject;
+exports.CSS2DRenderer = CSS2DRenderer;

package/dist/renderers/CSS2DRenderer.mjs

@@ -0,0 +1,121 @@
+import { Object3D, Vector3, Matrix4 } from "three";
+class CSS2DObject extends Object3D {
+  constructor(element = document.createElement("div")) {
+    super();
+    this.isCSS2DObject = true;
+    this.element = element;
+    this.element.style.position = "absolute";
+    this.element.style.userSelect = "none";
+    this.element.setAttribute("draggable", false);
+    this.addEventListener("removed", function() {
+      this.traverse(function(object) {
+        if (object.element instanceof Element && object.element.parentNode !== null) {
+          object.element.parentNode.removeChild(object.element);
+        }
+      });
+    });
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.element = source.element.cloneNode(true);
+    return this;
+  }
+}
+const _vector = /* @__PURE__ */ new Vector3();
+const _viewMatrix = /* @__PURE__ */ new Matrix4();
+const _viewProjectionMatrix = /* @__PURE__ */ new Matrix4();
+const _a = /* @__PURE__ */ new Vector3();
+const _b = /* @__PURE__ */ new Vector3();
+class CSS2DRenderer {
+  constructor(parameters = {}) {
+    const _this = this;
+    let _width, _height;
+    let _widthHalf, _heightHalf;
+    const cache = {
+      objects: /* @__PURE__ */ new WeakMap()
+    };
+    const domElement = parameters.element !== void 0 ? parameters.element : document.createElement("div");
+    domElement.style.overflow = "hidden";
+    this.domElement = domElement;
+    this.getSize = function() {
+      return {
+        width: _width,
+        height: _height
+      };
+    };
+    this.render = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true || scene.autoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && (camera.matrixWorldAutoUpdate == null || camera.matrixWorldAutoUpdate === true)) {
+        camera.updateMatrixWorld();
+      }
+      _viewMatrix.copy(camera.matrixWorldInverse);
+      _viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);
+      renderObject(scene, scene, camera);
+      zOrder(scene);
+    };
+    this.setSize = function(width, height) {
+      _width = width;
+      _height = height;
+      _widthHalf = _width / 2;
+      _heightHalf = _height / 2;
+      domElement.style.width = width + "px";
+      domElement.style.height = height + "px";
+    };
+    function renderObject(object, scene, camera) {
+      if (object.isCSS2DObject) {
+        _vector.setFromMatrixPosition(object.matrixWorld);
+        _vector.applyMatrix4(_viewProjectionMatrix);
+        const visible = object.visible === true && _vector.z >= -1 && _vector.z <= 1 && object.layers.test(camera.layers) === true;
+        object.element.style.display = visible === true ? "" : "none";
+        if (visible === true) {
+          object.onBeforeRender(_this, scene, camera);
+          const element = object.element;
+          element.style.transform = "translate(-50%,-50%) translate(" + (_vector.x * _widthHalf + _widthHalf) + "px," + (-_vector.y * _heightHalf + _heightHalf) + "px)";
+          if (element.parentNode !== domElement) {
+            domElement.appendChild(element);
+          }
+          object.onAfterRender(_this, scene, camera);
+        }
+        const objectData = {
+          distanceToCameraSquared: getDistanceToSquared(camera, object)
+        };
+        cache.objects.set(object, objectData);
+      }
+      for (let i = 0, l = object.children.length; i < l; i++) {
+        renderObject(object.children[i], scene, camera);
+      }
+    }
+    function getDistanceToSquared(object1, object2) {
+      _a.setFromMatrixPosition(object1.matrixWorld);
+      _b.setFromMatrixPosition(object2.matrixWorld);
+      return _a.distanceToSquared(_b);
+    }
+    function filterAndFlatten(scene) {
+      const result = [];
+      scene.traverse(function(object) {
+        if (object.isCSS2DObject)
+          result.push(object);
+      });
+      return result;
+    }
+    function zOrder(scene) {
+      const sorted = filterAndFlatten(scene).sort(function(a, b) {
+        if (a.renderOrder !== b.renderOrder) {
+          return b.renderOrder - a.renderOrder;
+        }
+        const distanceA = cache.objects.get(a).distanceToCameraSquared;
+        const distanceB = cache.objects.get(b).distanceToCameraSquared;
+        return distanceA - distanceB;
+      });
+      const zMax = sorted.length;
+      for (let i = 0, l = sorted.length; i < l; i++) {
+        sorted[i].element.style.zIndex = zMax - i;
+      }
+    }
+  }
+}
+export {
+  CSS2DObject,
+  CSS2DRenderer
+};

package/dist/renderers/CSS3DRenderer.d.ts

@@ -0,0 +1,26 @@
+import { Object3D, Scene, Camera } from 'three'
+
+export class CSS3DObject extends Object3D {
+  constructor(element: HTMLElement)
+  element: HTMLElement
+
+  onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+  onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+}
+
+export class CSS3DSprite extends CSS3DObject {
+  constructor(element: HTMLElement)
+}
+
+export type CSS3DParameters = {
+  element?: HTMLElement
+}
+
+export class CSS3DRenderer {
+  constructor(parameters?: CSS3DParameters)
+  domElement: HTMLElement
+
+  getSize(): { width: number; height: number }
+  setSize(width: number, height: number): void
+  render(scene: Scene, camera: Camera): void
+}