Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/flo-bit/shapecraft. flo-bit.dev/shapecraft
Something went wrong. Try again.
8.1 kB · 329 lines
JavaScript
at commit da69385e
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330import Node from '../core/Node.js';import TextureNode from '../accessors/TextureNode.js';import { nodeObject } from '../tsl/TSLBase.js';import { NodeUpdateType } from '../core/constants.js';import { screenUV } from '../display/ScreenNode.js';
import { HalfFloatType, LinearMipMapLinearFilter, WebGPUCoordinateSystem } from '../../constants.js';import { Plane } from '../../math/Plane.js';import { Object3D } from '../../core/Object3D.js';import { Vector2 } from '../../math/Vector2.js';import { Vector3 } from '../../math/Vector3.js';import { Vector4 } from '../../math/Vector4.js';import { Matrix4 } from '../../math/Matrix4.js';import { RenderTarget } from '../../core/RenderTarget.js';import { DepthTexture } from '../../textures/DepthTexture.js';
const _reflectorPlane = new Plane();const _normal = new Vector3();const _reflectorWorldPosition = new Vector3();const _cameraWorldPosition = new Vector3();const _rotationMatrix = new Matrix4();const _lookAtPosition = new Vector3( 0, 0, - 1 );const clipPlane = new Vector4();
const _view = new Vector3();const _target = new Vector3();const _q = new Vector4();
const _size = new Vector2();
const _defaultRT = new RenderTarget();const _defaultUV = screenUV.flipX();
_defaultRT.depthTexture = new DepthTexture( 1, 1 );
let _inReflector = false;
class ReflectorNode extends TextureNode {
static get type() {
return 'ReflectorNode';
}
constructor( parameters = {} ) {
super( parameters.defaultTexture || _defaultRT.texture, _defaultUV );
this._reflectorBaseNode = parameters.reflector || new ReflectorBaseNode( this, parameters ); this._depthNode = null;
this.setUpdateMatrix( false );
}
get reflector() {
return this._reflectorBaseNode;
}
get target() {
return this._reflectorBaseNode.target;
}
getDepthNode() {
if ( this._depthNode === null ) {
if ( this._reflectorBaseNode.depth !== true ) {
throw new Error( 'THREE.ReflectorNode: Depth node can only be requested when the reflector is created with { depth: true }. ' );
}
this._depthNode = nodeObject( new ReflectorNode( { defaultTexture: _defaultRT.depthTexture, reflector: this._reflectorBaseNode } ) );
}
return this._depthNode;
}
setup( builder ) {
// ignore if used in post-processing if ( ! builder.object.isQuadMesh ) this._reflectorBaseNode.build( builder );
return super.setup( builder );
}
clone() {
const texture = new this.constructor( this.reflectorNode ); texture._reflectorBaseNode = this._reflectorBaseNode;
return texture;
}
}
class ReflectorBaseNode extends Node {
static get type() {
return 'ReflectorBaseNode';
}
constructor( textureNode, parameters = {} ) {
super();
const { target = new Object3D(), resolution = 1, generateMipmaps = false, bounces = true, depth = false } = parameters;
//
this.textureNode = textureNode;
this.target = target; this.resolution = resolution; this.generateMipmaps = generateMipmaps; this.bounces = bounces; this.depth = depth;
this.updateBeforeType = bounces ? NodeUpdateType.RENDER : NodeUpdateType.FRAME;
this.virtualCameras = new WeakMap(); this.renderTargets = new WeakMap();
}
_updateResolution( renderTarget, renderer ) {
const resolution = this.resolution;
renderer.getDrawingBufferSize( _size );
renderTarget.setSize( Math.round( _size.width * resolution ), Math.round( _size.height * resolution ) );
}
setup( builder ) {
this._updateResolution( _defaultRT, builder.renderer );
return super.setup( builder );
}
getVirtualCamera( camera ) {
let virtualCamera = this.virtualCameras.get( camera );
if ( virtualCamera === undefined ) {
virtualCamera = camera.clone();
this.virtualCameras.set( camera, virtualCamera );
}
return virtualCamera;
}
getRenderTarget( camera ) {
let renderTarget = this.renderTargets.get( camera );
if ( renderTarget === undefined ) {
renderTarget = new RenderTarget( 0, 0, { type: HalfFloatType } );
if ( this.generateMipmaps === true ) {
renderTarget.texture.minFilter = LinearMipMapLinearFilter; renderTarget.texture.generateMipmaps = true;
}
if ( this.depth === true ) {
renderTarget.depthTexture = new DepthTexture();
}
this.renderTargets.set( camera, renderTarget );
}
return renderTarget;
}
updateBefore( frame ) {
if ( this.bounces === false && _inReflector ) return;
_inReflector = true;
const { scene, camera, renderer, material } = frame; const { target } = this;
const virtualCamera = this.getVirtualCamera( camera ); const renderTarget = this.getRenderTarget( virtualCamera );
renderer.getDrawingBufferSize( _size );
this._updateResolution( renderTarget, renderer );
//
_reflectorWorldPosition.setFromMatrixPosition( target.matrixWorld ); _cameraWorldPosition.setFromMatrixPosition( camera.matrixWorld );
_rotationMatrix.extractRotation( target.matrixWorld );
_normal.set( 0, 0, 1 ); _normal.applyMatrix4( _rotationMatrix );
_view.subVectors( _reflectorWorldPosition, _cameraWorldPosition );
// Avoid rendering when reflector is facing away
if ( _view.dot( _normal ) > 0 ) return;
_view.reflect( _normal ).negate(); _view.add( _reflectorWorldPosition );
_rotationMatrix.extractRotation( camera.matrixWorld );
_lookAtPosition.set( 0, 0, - 1 ); _lookAtPosition.applyMatrix4( _rotationMatrix ); _lookAtPosition.add( _cameraWorldPosition );
_target.subVectors( _reflectorWorldPosition, _lookAtPosition ); _target.reflect( _normal ).negate(); _target.add( _reflectorWorldPosition );
//
virtualCamera.coordinateSystem = camera.coordinateSystem; virtualCamera.position.copy( _view ); virtualCamera.up.set( 0, 1, 0 ); virtualCamera.up.applyMatrix4( _rotationMatrix ); virtualCamera.up.reflect( _normal ); virtualCamera.lookAt( _target );
virtualCamera.near = camera.near; virtualCamera.far = camera.far;
virtualCamera.updateMatrixWorld(); virtualCamera.projectionMatrix.copy( camera.projectionMatrix );
// Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf _reflectorPlane.setFromNormalAndCoplanarPoint( _normal, _reflectorWorldPosition ); _reflectorPlane.applyMatrix4( virtualCamera.matrixWorldInverse );
clipPlane.set( _reflectorPlane.normal.x, _reflectorPlane.normal.y, _reflectorPlane.normal.z, _reflectorPlane.constant );
const projectionMatrix = virtualCamera.projectionMatrix;
_q.x = ( Math.sign( clipPlane.x ) + projectionMatrix.elements[ 8 ] ) / projectionMatrix.elements[ 0 ]; _q.y = ( Math.sign( clipPlane.y ) + projectionMatrix.elements[ 9 ] ) / projectionMatrix.elements[ 5 ]; _q.z = - 1.0; _q.w = ( 1.0 + projectionMatrix.elements[ 10 ] ) / projectionMatrix.elements[ 14 ];
// Calculate the scaled plane vector clipPlane.multiplyScalar( 1.0 / clipPlane.dot( _q ) );
const clipBias = 0;
// Replacing the third row of the projection matrix projectionMatrix.elements[ 2 ] = clipPlane.x; projectionMatrix.elements[ 6 ] = clipPlane.y; projectionMatrix.elements[ 10 ] = ( renderer.coordinateSystem === WebGPUCoordinateSystem ) ? ( clipPlane.z - clipBias ) : ( clipPlane.z + 1.0 - clipBias ); projectionMatrix.elements[ 14 ] = clipPlane.w;
//
this.textureNode.value = renderTarget.texture;
if ( this.depth === true ) {
this.textureNode.getDepthNode().value = renderTarget.depthTexture;
}
material.visible = false;
const currentRenderTarget = renderer.getRenderTarget(); const currentMRT = renderer.getMRT();
renderer.setMRT( null ); renderer.setRenderTarget( renderTarget );
renderer.render( scene, virtualCamera );
renderer.setMRT( currentMRT ); renderer.setRenderTarget( currentRenderTarget );
material.visible = true;
_inReflector = false;
}
}
export const reflector = ( parameters ) => nodeObject( new ReflectorNode( parameters ) );
export default ReflectorNode;