super-three 0.154.1 → 0.156.0

package/examples/jsm/renderers/common/Pipelines.js

@@ -23,17 +23,22 @@ class Pipelines extends DataMap {
 
 	}
 
-	getForCompute( computeNode ) {
+	getForCompute( computeNode, bindings ) {
 
 		const { backend } = this;
 
 		const data = this.get( computeNode );
 
-		if ( data.pipeline === undefined ) {
+		if ( this._needsComputeUpdate( computeNode ) ) {
 
-			// release previous cache
+			const previousPipeline = data.pipeline;
 
-			const previousPipeline = this._releasePipeline( computeNode );
+			if ( previousPipeline ) {
+
+				previousPipeline.usedTimes --;
+				previousPipeline.computeProgram.usedTimes --;
+
+			}
 
 			// get shader
 
@@ -45,7 +50,7 @@ class Pipelines extends DataMap {
 
 			if ( stageCompute === undefined ) {
 
-				if ( previousPipeline ) this._releaseProgram( previousPipeline.computeShader );
+				if ( previousPipeline && previousPipeline.computeProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.computeProgram );
 
 				stageCompute = new ProgrammableStage( nodeBuilder.computeShader, 'compute' );
 				this.programs.compute.set( nodeBuilder.computeShader, stageCompute );
@@ -56,7 +61,17 @@ class Pipelines extends DataMap {
 
 			// determine compute pipeline
 
-			const pipeline = this._getComputePipeline( stageCompute );
+			const cacheKey = this._getComputeCacheKey( computeNode, stageCompute );
+
+			let pipeline = this.caches.get( cacheKey );
+
+			if ( pipeline === undefined ) {
+
+				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( computeNode );
+
+				pipeline = this._getComputePipeline( computeNode, stageCompute, cacheKey, bindings );
+
+			}
 
 			// keep track of all used times
 
@@ -65,6 +80,7 @@ class Pipelines extends DataMap {
 
 			//
 
+			data.version = computeNode.version;
 			data.pipeline = pipeline;
 
 		}
@@ -79,11 +95,17 @@ class Pipelines extends DataMap {
 
 		const data = this.get( renderObject );
 
-		if ( this._needsUpdate( renderObject ) ) {
+		if ( this._needsRenderUpdate( renderObject ) ) {
+
+			const previousPipeline = data.pipeline;
 
-			// release previous cache
+			if ( previousPipeline ) {
 
-			const previousPipeline = this._releasePipeline( renderObject );
+				previousPipeline.usedTimes --;
+				previousPipeline.vertexProgram.usedTimes --;
+				previousPipeline.fragmentProgram.usedTimes --;
+
+			}
 
 			// get shader
 
@@ -95,7 +117,7 @@ class Pipelines extends DataMap {
 
 			if ( stageVertex === undefined ) {
 
-				if ( previousPipeline ) this._releaseProgram( previousPipeline.vertexProgram );
+				if ( previousPipeline && previousPipeline.vertexProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.vertexProgram );
 
 				stageVertex = new ProgrammableStage( nodeBuilder.vertexShader, 'vertex' );
 				this.programs.vertex.set( nodeBuilder.vertexShader, stageVertex );
@@ -108,7 +130,7 @@ class Pipelines extends DataMap {
 
 			if ( stageFragment === undefined ) {
 
-				if ( previousPipeline ) this._releaseProgram( previousPipeline.fragmentShader );
+				if ( previousPipeline && previousPipeline.fragmentProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.fragmentProgram );
 
 				stageFragment = new ProgrammableStage( nodeBuilder.fragmentShader, 'fragment' );
 				this.programs.fragment.set( nodeBuilder.fragmentShader, stageFragment );
@@ -119,7 +141,21 @@ class Pipelines extends DataMap {
 
 			// determine render pipeline
 
-			const pipeline = this._getRenderPipeline( renderObject, stageVertex, stageFragment );
+			const cacheKey = this._getRenderCacheKey( renderObject, stageVertex, stageFragment );
+
+			let pipeline = this.caches.get( cacheKey );
+
+			if ( pipeline === undefined ) {
+
+				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
+
+				pipeline = this._getRenderPipeline( renderObject, stageVertex, stageFragment, cacheKey );
+
+			} else {
+
+				renderObject.pipeline = pipeline;
+
+			}
 
 			// keep track of all used times
 
@@ -139,18 +175,31 @@ class Pipelines extends DataMap {
 
 	delete( object ) {
 
-		const pipeline = this._releasePipeline( object );
+		const pipeline = this.get( object ).pipeline;
+
+		if ( pipeline ) {
+
+			// pipeline
+
+			pipeline.usedTimes --;
 
-		if ( pipeline && pipeline.usedTimes === 0 ) {
+			if ( pipeline.usedTimes === 0 ) this._releasePipeline( pipeline );
+
+			// programs
 
 			if ( pipeline.isComputePipeline ) {
 
-				this._releaseProgram( pipeline.computeProgram );
+				pipeline.computeProgram.usedTimes --;
+
+				if ( pipeline.computeProgram.usedTimes === 0 ) this._releaseProgram( pipeline.computeProgram );
 
 			} else {
 
-				this._releaseProgram( pipeline.vertexProgram );
-				this._releaseProgram( pipeline.fragmentProgram );
+				pipeline.fragmentProgram.usedTimes --;
+				pipeline.vertexProgram.usedTimes --;
+
+				if ( pipeline.vertexProgram.usedTimes === 0 ) this._releaseProgram( pipeline.vertexProgram );
+				if ( pipeline.fragmentProgram.usedTimes === 0 ) this._releaseProgram( pipeline.fragmentProgram );
 
 			}
 
@@ -173,11 +222,17 @@ class Pipelines extends DataMap {
 
 	}
 
-	_getComputePipeline( stageCompute ) {
+	updateForRender( renderObject ) {
+
+		this.getForRender( renderObject );
+
+	}
+
+	_getComputePipeline( computeNode, stageCompute, cacheKey, bindings ) {
 
 		// check for existing pipeline
 
-		const cacheKey = 'compute:' + stageCompute.id;
+		cacheKey = cacheKey || this._getComputeCacheKey( computeNode, stageCompute );
 
 		let pipeline = this.caches.get( cacheKey );
 
@@ -187,7 +242,7 @@ class Pipelines extends DataMap {
 
 			this.caches.set( cacheKey, pipeline );
 
-			this.backend.createComputePipeline( pipeline );
+			this.backend.createComputePipeline( pipeline, bindings );
 
 		}
 
@@ -195,11 +250,11 @@ class Pipelines extends DataMap {
 
 	}
 
-	_getRenderPipeline( renderObject, stageVertex, stageFragment ) {
+	_getRenderPipeline( renderObject, stageVertex, stageFragment, cacheKey ) {
 
 		// check for existing pipeline
 
-		const cacheKey = this._getRenderCacheKey( renderObject, stageVertex, stageFragment );
+		cacheKey = cacheKey || this._getRenderCacheKey( renderObject, stageVertex, stageFragment );
 
 		let pipeline = this.caches.get( cacheKey );
 
@@ -213,15 +268,15 @@ class Pipelines extends DataMap {
 
 			this.backend.createRenderPipeline( renderObject );
 
-		} else {
+		}
 
-			// assign a shared pipeline to renderObject
+		return pipeline;
 
-			renderObject.pipeline = pipeline;
+	}
 
-		}
+	_getComputeCacheKey( computeNode, stageCompute ) {
 
-		return pipeline;
+		return 'compute' + computeNode.id + stageCompute.id;
 
 	}
 
@@ -247,36 +302,30 @@ class Pipelines extends DataMap {
 
 	}
 
-	_releasePipeline( object ) {
-
-		const pipeline = this.get( object ).pipeline;
+	_releasePipeline( pipeline ) {
 
-		//this.bindings.delete( object );
+		this.caches.delete( pipeline.cacheKey );
 
-		if ( pipeline && -- pipeline.usedTimes === 0 ) {
+	}
 
-			this.caches.delete( pipeline.cacheKey );
+	_releaseProgram( program ) {
 
-		}
+		const code = program.code;
+		const stage = program.stage;
 
-		return pipeline;
+		this.programs[ stage ].delete( code );
 
 	}
 
-	_releaseProgram( program ) {
-
-		if ( -- program.usedTimes === 0 ) {
+	_needsComputeUpdate( computeNode ) {
 
-			const code = program.code;
-			const stage = program.stage;
-
-			this.programs[ stage ].delete( code );
+		const data = this.get( computeNode );
 
-		}
+		return data.pipeline === undefined || data.version !== computeNode.version;
 
 	}
 
-	_needsUpdate( renderObject ) {
+	_needsRenderUpdate( renderObject ) {
 
 		const data = this.get( renderObject );
 		const material = renderObject.material;
@@ -294,7 +343,7 @@ class Pipelines extends DataMap {
 			data.stencilWrite !== material.stencilWrite || data.stencilFunc !== material.stencilFunc ||
 			data.stencilFail !== material.stencilFail || data.stencilZFail !== material.stencilZFail || data.stencilZPass !== material.stencilZPass ||
 			data.stencilFuncMask !== material.stencilFuncMask || data.stencilWriteMask !== material.stencilWriteMask ||
-			data.side !== material.side
+			data.side !== material.side || data.alphaToCoverage !== material.alphaToCoverage
 		) {
 
 			data.material = material; data.materialVersion = material.version;
@@ -306,13 +355,13 @@ class Pipelines extends DataMap {
 			data.stencilWrite = material.stencilWrite; data.stencilFunc = material.stencilFunc;
 			data.stencilFail = material.stencilFail; data.stencilZFail = material.stencilZFail; data.stencilZPass = material.stencilZPass;
 			data.stencilFuncMask = material.stencilFuncMask; data.stencilWriteMask = material.stencilWriteMask;
-			data.side = material.side;
+			data.side = material.side; data.alphaToCoverage = material.alphaToCoverage;
 
 			needsUpdate = true;
 
 		}
 
-		return needsUpdate || data.pipeline !== undefined;
+		return needsUpdate || data.pipeline === undefined;
 
 	}
 

package/examples/jsm/renderers/common/RenderContext.js

@@ -29,6 +29,7 @@ class RenderContext {
 		this.texture = null;
 		this.depthTexture = null;
 		this.activeCubeFace = 0;
+		this.sampleCount = 1;
 
 	}
 

package/examples/jsm/renderers/common/RenderContexts.js

@@ -5,31 +5,67 @@ class RenderContexts {
 
 	constructor() {
 
-		this.renderStates = new ChainMap();
+		this.chainMaps = {};
 
 	}
 
-	get( scene, camera ) {
+	get( scene, camera, renderTarget = null ) {
 
 		const chainKey = [ scene, camera ];
 
-		let renderState = this.renderStates.get( chainKey );
+		let attachmentState;
+
+		if ( renderTarget === null ) {
+
+			attachmentState = 'default';
+
+		} else {
+
+			let format, count;
+
+			if ( renderTarget.isWebGLMultipleRenderTargets ) {
+
+				format = renderTarget.texture[ 0 ].format;
+				count = renderTarget.texture.length;
+
+			} else {
+
+				format = renderTarget.texture.format;
+				count = 1;
+
+			}
+
+			attachmentState = `${count}:${format}:${renderTarget.samples}:${renderTarget.depthBuffer}:${renderTarget.stencilBuffer}`;
+
+		}
+
+		const chainMap = this.getChainMap( attachmentState );
+
+		let renderState = chainMap.get( chainKey );
 
 		if ( renderState === undefined ) {
 
 			renderState = new RenderContext();
 
-			this.renderStates.set( chainKey, renderState );
+			chainMap.set( chainKey, renderState );
 
 		}
 
+		if ( renderTarget !== null ) renderState.sampleCount = renderTarget.samples === 0 ? 1 : renderTarget.samples;
+
 		return renderState;
 
 	}
 
+	getChainMap( attachmentState ) {
+
+		return this.chainMaps[ attachmentState ] || ( this.chainMaps[ attachmentState ] = new ChainMap() );
+
+	}
+
 	dispose() {
 
-		this.renderStates = new ChainMap();
+		this.chainMaps = {};
 
 	}
 

package/examples/jsm/renderers/common/RenderList.js

@@ -1,4 +1,4 @@
-import { lights } from '../../nodes/Nodes.js';
+import { LightsNode } from '../../nodes/Nodes.js';
 
 function painterSortStable( a, b ) {
 
@@ -58,12 +58,14 @@ class RenderList {
 		this.opaque = [];
 		this.transparent = [];
 
-		this.lightsNode = lights( [] );
+		this.lightsNode = new LightsNode( [] );
 		this.lightsArray = [];
 
+		this.occlusionQueryCount = 0;
+
 	}
 
-	init() {
+	begin() {
 
 		this.renderItemsIndex = 0;
 
@@ -71,6 +73,8 @@ class RenderList {
 		this.transparent.length = 0;
 		this.lightsArray.length = 0;
 
+		this.occlusionQueryCount = 0;
+
 		return this;
 
 	}
@@ -117,6 +121,8 @@ class RenderList {
 
 		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group );
 
+		if ( object.occlusionTest === true ) this.occlusionQueryCount ++;
+
 		( material.transparent === true ? this.transparent : this.opaque ).push( renderItem );
 
 	}
@@ -166,7 +172,9 @@ class RenderList {
 			renderItem.object = null;
 			renderItem.geometry = null;
 			renderItem.material = null;
-			renderItem.program = null;
+			renderItem.groupOrder = null;
+			renderItem.renderOrder = null;
+			renderItem.z = null;
 			renderItem.group = null;
 
 		}

package/examples/jsm/renderers/common/RenderObject.js

@@ -2,7 +2,7 @@ let id = 0;
 
 export default class RenderObject {
 
-	constructor( nodes, geometries, renderer, object, material, scene, camera, lightsNode ) {
+	constructor( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext ) {
 
 		this._nodes = nodes;
 		this._geometries = geometries;
@@ -15,18 +15,23 @@ export default class RenderObject {
 		this.scene = scene;
 		this.camera = camera;
 		this.lightsNode = lightsNode;
+		this.context = renderContext;
 
 		this.geometry = object.geometry;
 
 		this.attributes = null;
-		this.context = null;
 		this.pipeline = null;
+		this.vertexBuffers = null;
 
+		this._nodeBuilder = null;
+		this._bindings = null;
 		this._materialVersion = - 1;
 		this._materialCacheKey = '';
 
 		this.onDispose = null;
 
+		this.isRenderObject = true;
+
 		this.onMaterialDispose = () => {
 
 			this.dispose();
@@ -39,13 +44,13 @@ export default class RenderObject {
 
 	getNodeBuilder() {
 
-		return this._nodes.getForRender( this );
+		return this._nodeBuilder || ( this._nodeBuilder = this._nodes.getForRender( this ) );
 
 	}
 
 	getBindings() {
 
-		return this.getNodeBuilder().getBindings();
+		return this._bindings || ( this._bindings = this.getNodeBuilder().createBindings() );
 
 	}
 
@@ -57,7 +62,7 @@ export default class RenderObject {
 
 	getChainArray() {
 
-		return [ this.object, this.material, this.scene, this.camera, this.lightsNode ];
+		return [ this.object, this.material, this.context, this.lightsNode ];
 
 	}
 
@@ -69,19 +74,34 @@ export default class RenderObject {
 		const geometry = this.geometry;
 
 		const attributes = [];
+		const vertexBuffers = new Set();
 
 		for ( const nodeAttribute of nodeAttributes ) {
 
-			attributes.push( nodeAttribute.node && nodeAttribute.node.attribute ? nodeAttribute.node.attribute : geometry.getAttribute( nodeAttribute.name ) );
+			const attribute = nodeAttribute.node && nodeAttribute.node.attribute ? nodeAttribute.node.attribute : geometry.getAttribute( nodeAttribute.name );
+
+			attributes.push( attribute );
+
+			const bufferAttribute = attribute.isInterleavedBufferAttribute ? attribute.data : attribute;
+			vertexBuffers.add( bufferAttribute );
 
 		}
 
 		this.attributes = attributes;
+		this.vertexBuffers = Array.from( vertexBuffers.values() );
 
 		return attributes;
 
 	}
 
+	getVertexBuffers() {
+
+		if ( this.vertexBuffers === null ) this.getAttributes();
+
+		return this.vertexBuffers;
+
+	}
+
 	getCacheKey() {
 
 		const { material, scene, lightsNode } = this;

package/examples/jsm/renderers/common/RenderObjects.js

@@ -4,12 +4,13 @@ import RenderObject from './RenderObject.js';
 
 class RenderObjects {
 
-	constructor( renderer, nodes, geometries, pipelines, info ) {
+	constructor( renderer, nodes, geometries, pipelines, bindings, info ) {
 
 		this.renderer = renderer;
 		this.nodes = nodes;
 		this.geometries = geometries;
 		this.pipelines = pipelines;
+		this.bindings = bindings;
 		this.info = info;
 
 		this.chainMaps = {};
@@ -17,16 +18,16 @@ class RenderObjects {
 
 	}
 
-	get( object, material, scene, camera, lightsNode, passId ) {
+	get( object, material, scene, camera, lightsNode, renderContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
-		const chainArray = [ object, material, scene, camera, lightsNode ];
+		const chainArray = [ object, material, renderContext, lightsNode ];
 
 		let renderObject = chainMap.get( chainArray );
 
 		if ( renderObject === undefined ) {
 
-			renderObject = this.createRenderObject( this.nodes, this.geometries, this.renderer, object, material, scene, camera, lightsNode, passId );
+			renderObject = this.createRenderObject( this.nodes, this.geometries, this.renderer, object, material, scene, camera, lightsNode, renderContext, passId );
 
 			chainMap.set( chainArray, renderObject );
 
@@ -39,7 +40,7 @@ class RenderObjects {
 
 				renderObject.dispose();
 
-				renderObject = this.get( object, material, scene, camera, lightsNode );
+				renderObject = this.get( object, material, scene, camera, lightsNode, renderContext, passId );
 
 			}
 
@@ -62,11 +63,12 @@ class RenderObjects {
 
 	}
 
-	createRenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, passId ) {
+	createRenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
 		const dataMap = this.dataMap;
-		const renderObject = new RenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode );
+
+		const renderObject = new RenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext );
 
 		const data = dataMap.get( renderObject );
 		data.cacheKey = renderObject.getCacheKey();
@@ -76,6 +78,7 @@ class RenderObjects {
 			dataMap.delete( renderObject );
 
 			this.pipelines.delete( renderObject );
+			this.bindings.delete( renderObject );
 			this.nodes.delete( renderObject );
 
 			chainMap.delete( renderObject.getChainArray() );