Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/flo-bit/shapecraft. flo-bit.dev/shapecraft
Something went wrong. Try again.
12 kB · 424 lines
JavaScript
at commit da69385e
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425import { FrontSide, BackSide, DoubleSide, NearestFilter, PCFShadowMap, VSMShadowMap, RGBADepthPacking, NoBlending } from '../../constants.js';import { WebGLRenderTarget } from '../WebGLRenderTarget.js';import { MeshDepthMaterial } from '../../materials/MeshDepthMaterial.js';import { MeshDistanceMaterial } from '../../materials/MeshDistanceMaterial.js';import { ShaderMaterial } from '../../materials/ShaderMaterial.js';import { BufferAttribute } from '../../core/BufferAttribute.js';import { BufferGeometry } from '../../core/BufferGeometry.js';import { Mesh } from '../../objects/Mesh.js';import { Vector4 } from '../../math/Vector4.js';import { Vector2 } from '../../math/Vector2.js';import { Frustum } from '../../math/Frustum.js';
import * as vsm from '../shaders/ShaderLib/vsm.glsl.js';
function WebGLShadowMap( renderer, objects, capabilities ) {
let _frustum = new Frustum();
const _shadowMapSize = new Vector2(), _viewportSize = new Vector2(),
_viewport = new Vector4(),
_depthMaterial = new MeshDepthMaterial( { depthPacking: RGBADepthPacking } ), _distanceMaterial = new MeshDistanceMaterial(),
_materialCache = {},
_maxTextureSize = capabilities.maxTextureSize;
const shadowSide = { [ FrontSide ]: BackSide, [ BackSide ]: FrontSide, [ DoubleSide ]: DoubleSide };
const shadowMaterialVertical = new ShaderMaterial( { defines: { VSM_SAMPLES: 8 }, uniforms: { shadow_pass: { value: null }, resolution: { value: new Vector2() }, radius: { value: 4.0 } },
vertexShader: vsm.vertex, fragmentShader: vsm.fragment
} );
const shadowMaterialHorizontal = shadowMaterialVertical.clone(); shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;
const fullScreenTri = new BufferGeometry(); fullScreenTri.setAttribute( 'position', new BufferAttribute( new Float32Array( [ - 1, - 1, 0.5, 3, - 1, 0.5, - 1, 3, 0.5 ] ), 3 ) );
const fullScreenMesh = new Mesh( fullScreenTri, shadowMaterialVertical );
const scope = this;
this.enabled = false;
this.autoUpdate = true; this.needsUpdate = false;
this.type = PCFShadowMap; let _previousType = this.type;
this.render = function ( lights, scene, camera ) {
if ( scope.enabled === false ) return; if ( scope.autoUpdate === false && scope.needsUpdate === false ) return;
if ( lights.length === 0 ) return;
const currentRenderTarget = renderer.getRenderTarget(); const activeCubeFace = renderer.getActiveCubeFace(); const activeMipmapLevel = renderer.getActiveMipmapLevel();
const _state = renderer.state;
// Set GL state for depth map. _state.setBlending( NoBlending ); _state.buffers.color.setClear( 1, 1, 1, 1 ); _state.buffers.depth.setTest( true ); _state.setScissorTest( false );
// check for shadow map type changes
const toVSM = ( _previousType !== VSMShadowMap && this.type === VSMShadowMap ); const fromVSM = ( _previousType === VSMShadowMap && this.type !== VSMShadowMap );
// render depth map
for ( let i = 0, il = lights.length; i < il; i ++ ) {
const light = lights[ i ]; const shadow = light.shadow;
if ( shadow === undefined ) {
console.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' ); continue;
}
if ( shadow.autoUpdate === false && shadow.needsUpdate === false ) continue;
_shadowMapSize.copy( shadow.mapSize );
const shadowFrameExtents = shadow.getFrameExtents();
_shadowMapSize.multiply( shadowFrameExtents );
_viewportSize.copy( shadow.mapSize );
if ( _shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize ) {
if ( _shadowMapSize.x > _maxTextureSize ) {
_viewportSize.x = Math.floor( _maxTextureSize / shadowFrameExtents.x ); _shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x; shadow.mapSize.x = _viewportSize.x;
}
if ( _shadowMapSize.y > _maxTextureSize ) {
_viewportSize.y = Math.floor( _maxTextureSize / shadowFrameExtents.y ); _shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y; shadow.mapSize.y = _viewportSize.y;
}
}
if ( shadow.map === null || toVSM === true || fromVSM === true ) {
const pars = ( this.type !== VSMShadowMap ) ? { minFilter: NearestFilter, magFilter: NearestFilter } : {};
if ( shadow.map !== null ) {
shadow.map.dispose();
}
shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars ); shadow.map.texture.name = light.name + '.shadowMap';
shadow.camera.updateProjectionMatrix();
}
renderer.setRenderTarget( shadow.map ); renderer.clear();
const viewportCount = shadow.getViewportCount();
for ( let vp = 0; vp < viewportCount; vp ++ ) {
const viewport = shadow.getViewport( vp );
_viewport.set( _viewportSize.x * viewport.x, _viewportSize.y * viewport.y, _viewportSize.x * viewport.z, _viewportSize.y * viewport.w );
_state.viewport( _viewport );
shadow.updateMatrices( light, vp );
_frustum = shadow.getFrustum();
renderObject( scene, camera, shadow.camera, light, this.type );
}
// do blur pass for VSM
if ( shadow.isPointLightShadow !== true && this.type === VSMShadowMap ) {
VSMPass( shadow, camera );
}
shadow.needsUpdate = false;
}
_previousType = this.type;
scope.needsUpdate = false;
renderer.setRenderTarget( currentRenderTarget, activeCubeFace, activeMipmapLevel );
};
function VSMPass( shadow, camera ) {
const geometry = objects.update( fullScreenMesh );
if ( shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples ) {
shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples; shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
shadowMaterialVertical.needsUpdate = true; shadowMaterialHorizontal.needsUpdate = true;
}
if ( shadow.mapPass === null ) {
shadow.mapPass = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y );
}
// vertical pass
shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture; shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize; shadowMaterialVertical.uniforms.radius.value = shadow.radius; renderer.setRenderTarget( shadow.mapPass ); renderer.clear(); renderer.renderBufferDirect( camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null );
// horizontal pass
shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture; shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize; shadowMaterialHorizontal.uniforms.radius.value = shadow.radius; renderer.setRenderTarget( shadow.map ); renderer.clear(); renderer.renderBufferDirect( camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null );
}
function getDepthMaterial( object, material, light, type ) {
let result = null;
const customMaterial = ( light.isPointLight === true ) ? object.customDistanceMaterial : object.customDepthMaterial;
if ( customMaterial !== undefined ) {
result = customMaterial;
} else {
result = ( light.isPointLight === true ) ? _distanceMaterial : _depthMaterial;
if ( ( renderer.localClippingEnabled && material.clipShadows === true && Array.isArray( material.clippingPlanes ) && material.clippingPlanes.length !== 0 ) || ( material.displacementMap && material.displacementScale !== 0 ) || ( material.alphaMap && material.alphaTest > 0 ) || ( material.map && material.alphaTest > 0 ) ) {
// in this case we need a unique material instance reflecting the // appropriate state
const keyA = result.uuid, keyB = material.uuid;
let materialsForVariant = _materialCache[ keyA ];
if ( materialsForVariant === undefined ) {
materialsForVariant = {}; _materialCache[ keyA ] = materialsForVariant;
}
let cachedMaterial = materialsForVariant[ keyB ];
if ( cachedMaterial === undefined ) {
cachedMaterial = result.clone(); materialsForVariant[ keyB ] = cachedMaterial; material.addEventListener( 'dispose', onMaterialDispose );
}
result = cachedMaterial;
}
}
result.visible = material.visible; result.wireframe = material.wireframe;
if ( type === VSMShadowMap ) {
result.side = ( material.shadowSide !== null ) ? material.shadowSide : material.side;
} else {
result.side = ( material.shadowSide !== null ) ? material.shadowSide : shadowSide[ material.side ];
}
result.alphaMap = material.alphaMap; result.alphaTest = material.alphaTest; result.map = material.map;
result.clipShadows = material.clipShadows; result.clippingPlanes = material.clippingPlanes; result.clipIntersection = material.clipIntersection;
result.displacementMap = material.displacementMap; result.displacementScale = material.displacementScale; result.displacementBias = material.displacementBias;
result.wireframeLinewidth = material.wireframeLinewidth; result.linewidth = material.linewidth;
if ( light.isPointLight === true && result.isMeshDistanceMaterial === true ) {
const materialProperties = renderer.properties.get( result ); materialProperties.light = light;
}
return result;
}
function renderObject( object, camera, shadowCamera, light, type ) {
if ( object.visible === false ) return;
const visible = object.layers.test( camera.layers );
if ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {
if ( ( object.castShadow || ( object.receiveShadow && type === VSMShadowMap ) ) && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {
object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );
const geometry = objects.update( object ); const material = object.material;
if ( Array.isArray( material ) ) {
const groups = geometry.groups;
for ( let k = 0, kl = groups.length; k < kl; k ++ ) {
const group = groups[ k ]; const groupMaterial = material[ group.materialIndex ];
if ( groupMaterial && groupMaterial.visible ) {
const depthMaterial = getDepthMaterial( object, groupMaterial, light, type );
object.onBeforeShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial, group );
renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );
object.onAfterShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial, group );
}
}
} else if ( material.visible ) {
const depthMaterial = getDepthMaterial( object, material, light, type );
object.onBeforeShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial, null );
renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );
object.onAfterShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial, null );
}
}
}
const children = object.children;
for ( let i = 0, l = children.length; i < l; i ++ ) {
renderObject( children[ i ], camera, shadowCamera, light, type );
}
}
function onMaterialDispose( event ) {
const material = event.target;
material.removeEventListener( 'dispose', onMaterialDispose );
// make sure to remove the unique distance/depth materials used for shadow map rendering
for ( const id in _materialCache ) {
const cache = _materialCache[ id ];
const uuid = event.target.uuid;
if ( uuid in cache ) {
const shadowMaterial = cache[ uuid ]; shadowMaterial.dispose(); delete cache[ uuid ];
}
}
}
}
export { WebGLShadowMap };