playing with render targets

src/nodes/Nodes.js

@@ -135,6 +135,7 @@ export { default as FilmNode, film } from './display/FilmNode.js';
 export { default as Lut3DNode, lut3D } from './display/Lut3DNode.js';
 export { default as RenderOutputNode, renderOutput } from './display/RenderOutputNode.js';
 export { default as PixelationNode, pixelation } from './display/PixelationNode.js';
+export { default as PixelationPassNode, pixelationPass } from './display/PixelationPassNode.js'
 
 export { default as PassNode, pass, texturePass, depthPass, normalPass } from './display/PassNode.js';
 

src/nodes/display/PassNode.js

@@ -15,7 +15,7 @@ import MeshNormalNodeMaterial from '../materials/MeshNormalNodeMaterial.js';
 
 const _size = new Vector2();
 
-class PassTextureNode extends TextureNode {
+export class PassTextureNode extends TextureNode {
 
 	constructor( passNode, texture ) {
 
@@ -70,11 +70,11 @@ class PassNode extends TempNode {
 
 		if ( this.scope === PassNode.NORMAL ) {
 
-			const target = new RenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
-			renderTarget.texture.name = 'PostProcessingNormal';
-			this.normalRenderTarget = target;
+			const normalTarget = new RenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
+			normalTarget.texture.name = 'PostProcessingNormal';
+			this.normalRenderTarget = normalTarget;
 
-			this._normalTextureNode = nodeObject( new PassTextureNode( this, target.texture ) );
+			this._normalTextureNode = nodeObject( new PassTextureNode( this, normalTarget.texture ) );
 
 		}
 

src/nodes/display/PixelationNode.js

@@ -141,7 +141,7 @@ class PixelationNode extends TempNode {
 
 }
 
-export const pixelation = ( node, depthNode, normalNode, pixelSize, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) => nodeObject( new PixelationNode( nodeObject( node ).toTexture(), nodeObject( depthNode ).toTexture(), nodeObject( normalNode ).toTexture(), nodeObject( pixelSize ), normalEdgeStrength, depthEdgeStrength ) );
+export const pixelation = ( node, depthNode, normalNode, pixelSize = 4, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) => nodeObject( new PixelationNode( nodeObject( node ).toTexture(), nodeObject( depthNode ).toTexture(), nodeObject( normalNode ).toTexture(), pixelSize, normalEdgeStrength, depthEdgeStrength ) );
 
 addNodeElement( 'pixelation', pixelation );
 

src/nodes/display/PixelationPassNode.js

@@ -0,0 +1,90 @@
+import { nodeObject } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { NodeUpdateType } from '../core/constants.js';
+import PassNode from './PassNode.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { HalfFloatType/*, FloatType*/ } from '../../constants.js';
+import { PassTextureNode } from './PassNode.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { MeshNormalNodeMaterial } from '../Nodes.js';
+
+const _size = new Vector2();
+
+class PixelationPassNode extends PassNode {
+
+	constructor( scene, camera, pixelSize, normalEdgeStrength, depthEdgeStrength ) {
+
+		super( 'normal', scene, camera );
+
+		this.pixelSize = pixelSize;
+		this.normalEdgeStrength = normalEdgeStrength;
+		this.depthEdgeStrength = depthEdgeStrength;
+
+		this.updateBeforeType = NodeUpdateType.FRAME;
+
+		this.isPixelationPassNode = true;
+
+	}
+
+	updateBefore( frame ) {
+
+		const { renderer } = frame;
+		const { scene, camera } = this;
+
+		this._pixelRatio = renderer.getPixelRatio();
+
+		const size = renderer.getSize( _size );
+		const pixelSize = this.pixelSize.value ? this.pixelSize.value : this.pixelSize;
+
+		this.setSize( pixelSize >= 1 ? size.width / pixelSize : size.width, pixelSize >= 1 ? size.height / pixelSize : size.height );
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		this._cameraNear.value = camera.near;
+		this._cameraFar.value = camera.far;
+
+		renderer.setRenderTarget( this.renderTarget );
+		console.log(this.renderTarget)
+
+		renderer.render( scene, camera );
+
+		renderer.setRenderTarget( this.normalRenderTarget );
+		const oldMaterial = scene.overrideMaterial;
+		scene.overrideMaterial = new MeshNormalNodeMaterial();
+		renderer.render( scene, camera );
+		scene.overrideMaterial = oldMaterial;
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+	}
+
+	setSize( width, height ) {
+
+		super.setSize( width, height );
+		this.normalRenderTarget.setSize( width * this._pixelRatio, height * this._pixelRatio );
+
+	}
+
+	setup() {
+
+		const pass = super.getTextureDepthNode();
+		console.log( this.normalEdgeStrength )
+		return pass.pixelation( this._depthTextureNode, this._normalTextureNode, this.pixelSize, this.normalEdgeStrength, this.depthEdgeStrength );
+
+	}
+
+	dispose() {
+
+		super.dispose();
+		this.normalRenderTarget.dispose();
+
+
+	}
+
+}
+
+export default PixelationPassNode;
+
+export const pixelationPass = ( scene, camera, pixelSize, normalEdgeStrength, depthEdgeStrength ) => nodeObject( new PixelationPassNode( scene, camera, pixelSize, normalEdgeStrength, depthEdgeStrength ) );
+
+addNodeClass( 'PixelationPassNode', PixelationPassNode );