Dies ist das Repository meines kleinen Portfolios.
Im Hintergrund läuft eine Planetensimulation, geschrieben in JavaScript und Three.js.
Die zu sehenden Texturen stammen von:
https://www.solarsystemscope.com/textures/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
494 lines
16 KiB
494 lines
16 KiB
( function () { |
|
|
|
class SSRrPass extends THREE.Pass { |
|
|
|
constructor( { |
|
renderer, |
|
scene, |
|
camera, |
|
width, |
|
height, |
|
selects |
|
} ) { |
|
|
|
super(); |
|
this.width = width !== undefined ? width : 512; |
|
this.height = height !== undefined ? height : 512; |
|
this.clear = true; |
|
this.renderer = renderer; |
|
this.scene = scene; |
|
this.camera = camera; |
|
this.output = 0; // this.output = 1; |
|
|
|
this.ior = THREE.SSRrShader.uniforms.ior.value; |
|
this.maxDistance = THREE.SSRrShader.uniforms.maxDistance.value; |
|
this.surfDist = THREE.SSRrShader.uniforms.surfDist.value; |
|
this.tempColor = new THREE.Color(); |
|
this.selects = selects; |
|
this._specular = THREE.SSRrShader.defines.SPECULAR; |
|
Object.defineProperty( this, 'specular', { |
|
get() { |
|
|
|
return this._specular; |
|
|
|
}, |
|
|
|
set( val ) { |
|
|
|
if ( this._specular === val ) return; |
|
this._specular = val; |
|
this.ssrrMaterial.defines.SPECULAR = val; |
|
this.ssrrMaterial.needsUpdate = true; |
|
|
|
} |
|
|
|
} ); |
|
this._fillHole = THREE.SSRrShader.defines.FILL_HOLE; |
|
Object.defineProperty( this, 'fillHole', { |
|
get() { |
|
|
|
return this._fillHole; |
|
|
|
}, |
|
|
|
set( val ) { |
|
|
|
if ( this._fillHole === val ) return; |
|
this._fillHole = val; |
|
this.ssrrMaterial.defines.FILL_HOLE = val; |
|
this.ssrrMaterial.needsUpdate = true; |
|
|
|
} |
|
|
|
} ); |
|
this._infiniteThick = THREE.SSRrShader.defines.INFINITE_THICK; |
|
Object.defineProperty( this, 'infiniteThick', { |
|
get() { |
|
|
|
return this._infiniteThick; |
|
|
|
}, |
|
|
|
set( val ) { |
|
|
|
if ( this._infiniteThick === val ) return; |
|
this._infiniteThick = val; |
|
this.ssrrMaterial.defines.INFINITE_THICK = val; |
|
this.ssrrMaterial.needsUpdate = true; |
|
|
|
} |
|
|
|
} ); // beauty render target with depth buffer |
|
|
|
const depthTexture = new THREE.DepthTexture(); |
|
depthTexture.type = THREE.UnsignedShortType; |
|
depthTexture.minFilter = THREE.NearestFilter; |
|
depthTexture.magFilter = THREE.NearestFilter; |
|
this.beautyRenderTarget = new THREE.WebGLRenderTarget( this.width, this.height, { |
|
minFilter: THREE.NearestFilter, |
|
magFilter: THREE.NearestFilter, |
|
format: THREE.RGBAFormat, |
|
depthTexture: depthTexture, |
|
depthBuffer: true |
|
} ); |
|
this.specularRenderTarget = new THREE.WebGLRenderTarget( this.width, this.height, { |
|
// TODO: Can merge with refractiveRenderTarget? |
|
minFilter: THREE.NearestFilter, |
|
magFilter: THREE.NearestFilter, |
|
format: THREE.RGBAFormat |
|
} ); // normalSelects render target |
|
|
|
const depthTextureSelects = new THREE.DepthTexture(); |
|
depthTextureSelects.type = THREE.UnsignedShortType; |
|
depthTextureSelects.minFilter = THREE.NearestFilter; |
|
depthTextureSelects.magFilter = THREE.NearestFilter; |
|
this.normalSelectsRenderTarget = new THREE.WebGLRenderTarget( this.width, this.height, { |
|
minFilter: THREE.NearestFilter, |
|
magFilter: THREE.NearestFilter, |
|
format: THREE.RGBAFormat, |
|
type: THREE.HalfFloatType, |
|
depthTexture: depthTextureSelects, |
|
depthBuffer: true |
|
} ); // refractive render target |
|
|
|
this.refractiveRenderTarget = new THREE.WebGLRenderTarget( this.width, this.height, { |
|
minFilter: THREE.NearestFilter, |
|
magFilter: THREE.NearestFilter, |
|
format: THREE.RGBAFormat |
|
} ); // ssrr render target |
|
|
|
this.ssrrRenderTarget = new THREE.WebGLRenderTarget( this.width, this.height, { |
|
minFilter: THREE.NearestFilter, |
|
magFilter: THREE.NearestFilter, |
|
format: THREE.RGBAFormat |
|
} ); // ssrr material |
|
|
|
if ( THREE.SSRrShader === undefined ) { |
|
|
|
console.error( 'THREE.SSRrPass: The pass relies on THREE.SSRrShader.' ); |
|
|
|
} |
|
|
|
this.ssrrMaterial = new THREE.ShaderMaterial( { |
|
defines: Object.assign( {}, THREE.SSRrShader.defines, { |
|
MAX_STEP: Math.sqrt( this.width * this.width + this.height * this.height ) |
|
} ), |
|
uniforms: THREE.UniformsUtils.clone( THREE.SSRrShader.uniforms ), |
|
vertexShader: THREE.SSRrShader.vertexShader, |
|
fragmentShader: THREE.SSRrShader.fragmentShader, |
|
blending: THREE.NoBlending |
|
} ); |
|
this.ssrrMaterial.uniforms[ 'tDiffuse' ].value = this.beautyRenderTarget.texture; |
|
this.ssrrMaterial.uniforms[ 'tSpecular' ].value = this.specularRenderTarget.texture; |
|
this.ssrrMaterial.uniforms[ 'tNormalSelects' ].value = this.normalSelectsRenderTarget.texture; |
|
this.ssrrMaterial.needsUpdate = true; |
|
this.ssrrMaterial.uniforms[ 'tRefractive' ].value = this.refractiveRenderTarget.texture; |
|
this.ssrrMaterial.uniforms[ 'tDepth' ].value = this.beautyRenderTarget.depthTexture; |
|
this.ssrrMaterial.uniforms[ 'tDepthSelects' ].value = this.normalSelectsRenderTarget.depthTexture; |
|
this.ssrrMaterial.uniforms[ 'cameraNear' ].value = this.camera.near; |
|
this.ssrrMaterial.uniforms[ 'cameraFar' ].value = this.camera.far; |
|
this.ssrrMaterial.uniforms[ 'resolution' ].value.set( this.width, this.height ); |
|
this.ssrrMaterial.uniforms[ 'cameraProjectionMatrix' ].value.copy( this.camera.projectionMatrix ); |
|
this.ssrrMaterial.uniforms[ 'cameraInverseProjectionMatrix' ].value.copy( this.camera.projectionMatrixInverse ); // normal material |
|
|
|
this.normalMaterial = new THREE.MeshNormalMaterial(); |
|
this.normalMaterial.blending = THREE.NoBlending; // refractiveOn material |
|
|
|
this.refractiveOnMaterial = new THREE.MeshBasicMaterial( { |
|
color: 'white' |
|
} ); // refractiveOff material |
|
|
|
this.refractiveOffMaterial = new THREE.MeshBasicMaterial( { |
|
color: 'black' |
|
} ); // specular material |
|
|
|
this.specularMaterial = new THREE.MeshStandardMaterial( { |
|
color: 'black', |
|
metalness: 0, |
|
roughness: .2 |
|
} ); // material for rendering the depth |
|
|
|
this.depthRenderMaterial = new THREE.ShaderMaterial( { |
|
defines: Object.assign( {}, THREE.SSRrDepthShader.defines ), |
|
uniforms: THREE.UniformsUtils.clone( THREE.SSRrDepthShader.uniforms ), |
|
vertexShader: THREE.SSRrDepthShader.vertexShader, |
|
fragmentShader: THREE.SSRrDepthShader.fragmentShader, |
|
blending: THREE.NoBlending |
|
} ); |
|
this.depthRenderMaterial.uniforms[ 'tDepth' ].value = this.beautyRenderTarget.depthTexture; |
|
this.depthRenderMaterial.uniforms[ 'cameraNear' ].value = this.camera.near; |
|
this.depthRenderMaterial.uniforms[ 'cameraFar' ].value = this.camera.far; // material for rendering the content of a render target |
|
|
|
this.copyMaterial = new THREE.ShaderMaterial( { |
|
uniforms: THREE.UniformsUtils.clone( THREE.CopyShader.uniforms ), |
|
vertexShader: THREE.CopyShader.vertexShader, |
|
fragmentShader: THREE.CopyShader.fragmentShader, |
|
transparent: true, |
|
depthTest: false, |
|
depthWrite: false, |
|
blendSrc: THREE.SrcAlphaFactor, |
|
blendDst: THREE.OneMinusSrcAlphaFactor, |
|
blendEquation: THREE.AddEquation, |
|
blendSrcAlpha: THREE.SrcAlphaFactor, |
|
blendDstAlpha: THREE.OneMinusSrcAlphaFactor, |
|
blendEquationAlpha: THREE.AddEquation // premultipliedAlpha:true, |
|
|
|
} ); |
|
this.fsQuad = new THREE.FullScreenQuad( null ); |
|
this.originalClearColor = new THREE.Color(); |
|
|
|
} |
|
|
|
dispose() { |
|
|
|
// dispose render targets |
|
this.beautyRenderTarget.dispose(); |
|
this.specularRenderTarget.dispose(); |
|
this.normalSelectsRenderTarget.dispose(); |
|
this.refractiveRenderTarget.dispose(); |
|
this.ssrrRenderTarget.dispose(); // dispose materials |
|
|
|
this.normalMaterial.dispose(); |
|
this.refractiveOnMaterial.dispose(); |
|
this.refractiveOffMaterial.dispose(); |
|
this.copyMaterial.dispose(); |
|
this.depthRenderMaterial.dispose(); // dipsose full screen quad |
|
|
|
this.fsQuad.dispose(); |
|
|
|
} |
|
|
|
render( renderer, writeBuffer |
|
/*, readBuffer, deltaTime, maskActive */ |
|
) { |
|
|
|
// render beauty and depth |
|
renderer.setRenderTarget( this.beautyRenderTarget ); |
|
renderer.clear(); |
|
this.scene.children.forEach( child => { |
|
|
|
if ( this.selects.includes( child ) ) { |
|
|
|
child.visible = false; |
|
|
|
} else { |
|
|
|
child.visible = true; |
|
|
|
} |
|
|
|
} ); |
|
renderer.render( this.scene, this.camera ); |
|
renderer.setRenderTarget( this.specularRenderTarget ); |
|
renderer.clear(); |
|
this.scene.children.forEach( child => { |
|
|
|
if ( this.selects.includes( child ) ) { |
|
|
|
child.visible = true; |
|
child._SSRrPassBackupMaterial = child.material; |
|
child.material = this.specularMaterial; |
|
|
|
} else if ( ! child.isLight ) { |
|
|
|
child.visible = false; |
|
|
|
} |
|
|
|
} ); |
|
renderer.render( this.scene, this.camera ); |
|
this.scene.children.forEach( child => { |
|
|
|
if ( this.selects.includes( child ) ) { |
|
|
|
child.material = child._SSRrPassBackupMaterial; |
|
|
|
} |
|
|
|
} ); // render normalSelectss |
|
|
|
this.scene.children.forEach( child => { |
|
|
|
if ( this.selects.includes( child ) ) { |
|
|
|
child.visible = true; |
|
|
|
} else { |
|
|
|
child.visible = false; |
|
|
|
} |
|
|
|
} ); |
|
this.renderOverride( renderer, this.normalMaterial, this.normalSelectsRenderTarget, 0, 0 ); |
|
this.renderRefractive( renderer, this.refractiveOnMaterial, this.refractiveRenderTarget, 0, 0 ); // render SSRr |
|
|
|
this.ssrrMaterial.uniforms[ 'ior' ].value = this.ior; |
|
this.ssrrMaterial.uniforms[ 'maxDistance' ].value = this.maxDistance; |
|
this.ssrrMaterial.uniforms[ 'surfDist' ].value = this.surfDist; |
|
this.ssrrMaterial.uniforms[ 'tSpecular' ].value = this.specularRenderTarget.texture; |
|
this.renderPass( renderer, this.ssrrMaterial, this.ssrrRenderTarget ); // output result to screen |
|
|
|
switch ( this.output ) { |
|
|
|
case SSRrPass.OUTPUT.Default: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.beautyRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.ssrrRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NormalBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.SSRr: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.ssrrRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.Beauty: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.beautyRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.Depth: |
|
this.depthRenderMaterial.uniforms[ 'tDepth' ].value = this.beautyRenderTarget.depthTexture; |
|
this.renderPass( renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.DepthSelects: |
|
this.depthRenderMaterial.uniforms[ 'tDepth' ].value = this.normalSelectsRenderTarget.depthTexture; |
|
this.renderPass( renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.NormalSelects: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.normalSelectsRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.Refractive: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.refractiveRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
case SSRrPass.OUTPUT.Specular: |
|
this.copyMaterial.uniforms[ 'tDiffuse' ].value = this.specularRenderTarget.texture; |
|
this.copyMaterial.blending = THREE.NoBlending; |
|
this.renderPass( renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer ); |
|
break; |
|
|
|
default: |
|
console.warn( 'THREE.SSRrPass: Unknown output type.' ); |
|
|
|
} |
|
|
|
} |
|
|
|
renderPass( renderer, passMaterial, renderTarget, clearColor, clearAlpha ) { |
|
|
|
// save original state |
|
this.originalClearColor.copy( renderer.getClearColor( this.tempColor ) ); |
|
const originalClearAlpha = renderer.getClearAlpha( this.tempColor ); |
|
const originalAutoClear = renderer.autoClear; |
|
renderer.setRenderTarget( renderTarget ); // setup pass state |
|
|
|
renderer.autoClear = false; |
|
|
|
if ( clearColor !== undefined && clearColor !== null ) { |
|
|
|
renderer.setClearColor( clearColor ); |
|
renderer.setClearAlpha( clearAlpha || 0.0 ); |
|
renderer.clear(); |
|
|
|
} |
|
|
|
this.fsQuad.material = passMaterial; |
|
this.fsQuad.render( renderer ); // restore original state |
|
|
|
renderer.autoClear = originalAutoClear; |
|
renderer.setClearColor( this.originalClearColor ); |
|
renderer.setClearAlpha( originalClearAlpha ); |
|
|
|
} |
|
|
|
renderOverride( renderer, overrideMaterial, renderTarget, clearColor, clearAlpha ) { |
|
|
|
this.originalClearColor.copy( renderer.getClearColor( this.tempColor ) ); |
|
const originalClearAlpha = renderer.getClearAlpha( this.tempColor ); |
|
const originalAutoClear = renderer.autoClear; |
|
renderer.setRenderTarget( renderTarget ); |
|
renderer.autoClear = false; |
|
clearColor = overrideMaterial.clearColor || clearColor; |
|
clearAlpha = overrideMaterial.clearAlpha || clearAlpha; |
|
|
|
if ( clearColor !== undefined && clearColor !== null ) { |
|
|
|
renderer.setClearColor( clearColor ); |
|
renderer.setClearAlpha( clearAlpha || 0.0 ); |
|
renderer.clear(); |
|
|
|
} |
|
|
|
this.scene.overrideMaterial = overrideMaterial; |
|
renderer.render( this.scene, this.camera ); |
|
this.scene.overrideMaterial = null; // restore original state |
|
|
|
renderer.autoClear = originalAutoClear; |
|
renderer.setClearColor( this.originalClearColor ); |
|
renderer.setClearAlpha( originalClearAlpha ); |
|
|
|
} |
|
|
|
renderRefractive( renderer, overrideMaterial, renderTarget, clearColor, clearAlpha ) { |
|
|
|
this.originalClearColor.copy( renderer.getClearColor( this.tempColor ) ); |
|
const originalClearAlpha = renderer.getClearAlpha( this.tempColor ); |
|
const originalAutoClear = renderer.autoClear; |
|
renderer.setRenderTarget( renderTarget ); |
|
renderer.autoClear = false; |
|
clearColor = overrideMaterial.clearColor || clearColor; |
|
clearAlpha = overrideMaterial.clearAlpha || clearAlpha; |
|
|
|
if ( clearColor !== undefined && clearColor !== null ) { |
|
|
|
renderer.setClearColor( clearColor ); |
|
renderer.setClearAlpha( clearAlpha || 0.0 ); |
|
renderer.clear(); |
|
|
|
} |
|
|
|
this.scene.children.forEach( child => { |
|
|
|
child.visible = true; |
|
|
|
} ); |
|
this.scene.traverse( child => { |
|
|
|
child._SSRrPassBackupMaterial = child.material; |
|
|
|
if ( this.selects.includes( child ) ) { |
|
|
|
child.material = this.refractiveOnMaterial; |
|
|
|
} else { |
|
|
|
child.material = this.refractiveOffMaterial; |
|
|
|
} |
|
|
|
} ); |
|
this.scene._SSRrPassBackupBackground = this.scene.background; |
|
this.scene.background = null; |
|
this.scene._SSRrPassBackupFog = this.scene.fog; |
|
this.scene.fog = null; |
|
renderer.render( this.scene, this.camera ); |
|
this.scene.fog = this.scene._SSRrPassBackupFog; |
|
this.scene.background = this.scene._SSRrPassBackupBackground; |
|
this.scene.traverse( child => { |
|
|
|
child.material = child._SSRrPassBackupMaterial; |
|
|
|
} ); // restore original state |
|
|
|
renderer.autoClear = originalAutoClear; |
|
renderer.setClearColor( this.originalClearColor ); |
|
renderer.setClearAlpha( originalClearAlpha ); |
|
|
|
} |
|
|
|
setSize( width, height ) { |
|
|
|
this.width = width; |
|
this.height = height; |
|
this.ssrrMaterial.defines.MAX_STEP = Math.sqrt( width * width + height * height ); |
|
this.ssrrMaterial.needsUpdate = true; |
|
this.beautyRenderTarget.setSize( width, height ); |
|
this.specularRenderTarget.setSize( width, height ); |
|
this.ssrrRenderTarget.setSize( width, height ); |
|
this.normalSelectsRenderTarget.setSize( width, height ); |
|
this.refractiveRenderTarget.setSize( width, height ); |
|
this.ssrrMaterial.uniforms[ 'resolution' ].value.set( width, height ); |
|
this.ssrrMaterial.uniforms[ 'cameraProjectionMatrix' ].value.copy( this.camera.projectionMatrix ); |
|
this.ssrrMaterial.uniforms[ 'cameraInverseProjectionMatrix' ].value.copy( this.camera.projectionMatrixInverse ); |
|
|
|
} |
|
|
|
} |
|
|
|
SSRrPass.OUTPUT = { |
|
'Default': 0, |
|
'SSRr': 1, |
|
'Beauty': 3, |
|
'Depth': 4, |
|
'DepthSelects': 9, |
|
'NormalSelects': 5, |
|
'Refractive': 7, |
|
'Specular': 8 |
|
}; |
|
|
|
THREE.SSRrPass = SSRrPass; |
|
|
|
} )();
|
|
|