Nodes.js 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  1. import DataMap from '../DataMap.js';
  2. import ChainMap from '../ChainMap.js';
  3. import NodeBuilderState from './NodeBuilderState.js';
  4. import { EquirectangularReflectionMapping, EquirectangularRefractionMapping, NoToneMapping, SRGBColorSpace } from 'three';
  5. import { NodeFrame, vec4, objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, viewportBottomLeft, normalWorld, pmremTexture, viewportTopLeft } from '../../../nodes/Nodes.js';
  6. class Nodes extends DataMap {
  7. constructor( renderer, backend ) {
  8. super();
  9. this.renderer = renderer;
  10. this.backend = backend;
  11. this.nodeFrame = new NodeFrame();
  12. this.nodeBuilderCache = new Map();
  13. this.callHashCache = new ChainMap();
  14. this.groupsData = new ChainMap();
  15. }
  16. updateGroup( nodeUniformsGroup ) {
  17. const groupNode = nodeUniformsGroup.groupNode;
  18. const name = groupNode.name;
  19. // objectGroup is every updated
  20. if ( name === objectGroup.name ) return true;
  21. // renderGroup is updated once per render/compute call
  22. if ( name === renderGroup.name ) {
  23. const uniformsGroupData = this.get( nodeUniformsGroup );
  24. const renderId = this.nodeFrame.renderId;
  25. if ( uniformsGroupData.renderId !== renderId ) {
  26. uniformsGroupData.renderId = renderId;
  27. return true;
  28. }
  29. return false;
  30. }
  31. // frameGroup is updated once per frame
  32. if ( name === frameGroup.name ) {
  33. const uniformsGroupData = this.get( nodeUniformsGroup );
  34. const frameId = this.nodeFrame.frameId;
  35. if ( uniformsGroupData.frameId !== frameId ) {
  36. uniformsGroupData.frameId = frameId;
  37. return true;
  38. }
  39. return false;
  40. }
  41. // other groups are updated just when groupNode.needsUpdate is true
  42. const groupChain = [ groupNode, nodeUniformsGroup ];
  43. let groupData = this.groupsData.get( groupChain );
  44. if ( groupData === undefined ) this.groupsData.set( groupChain, groupData = {} );
  45. if ( groupData.version !== groupNode.version ) {
  46. groupData.version = groupNode.version;
  47. return true;
  48. }
  49. return false;
  50. }
  51. getForRenderCacheKey( renderObject ) {
  52. return renderObject.initialCacheKey;
  53. }
  54. getForRender( renderObject ) {
  55. const renderObjectData = this.get( renderObject );
  56. let nodeBuilderState = renderObjectData.nodeBuilderState;
  57. if ( nodeBuilderState === undefined ) {
  58. const { nodeBuilderCache } = this;
  59. const cacheKey = this.getForRenderCacheKey( renderObject );
  60. nodeBuilderState = nodeBuilderCache.get( cacheKey );
  61. if ( nodeBuilderState === undefined ) {
  62. const nodeBuilder = this.backend.createNodeBuilder( renderObject.object, this.renderer, renderObject.scene );
  63. nodeBuilder.material = renderObject.material;
  64. nodeBuilder.context.material = renderObject.material;
  65. nodeBuilder.lightsNode = renderObject.lightsNode;
  66. nodeBuilder.environmentNode = this.getEnvironmentNode( renderObject.scene );
  67. nodeBuilder.fogNode = this.getFogNode( renderObject.scene );
  68. nodeBuilder.clippingContext = renderObject.clippingContext;
  69. nodeBuilder.build();
  70. nodeBuilderState = this._createNodeBuilderState( nodeBuilder );
  71. nodeBuilderCache.set( cacheKey, nodeBuilderState );
  72. }
  73. nodeBuilderState.usedTimes ++;
  74. renderObjectData.nodeBuilderState = nodeBuilderState;
  75. }
  76. return nodeBuilderState;
  77. }
  78. delete( object ) {
  79. if ( object.isRenderObject ) {
  80. const nodeBuilderState = this.get( object ).nodeBuilderState;
  81. nodeBuilderState.usedTimes --;
  82. if ( nodeBuilderState.usedTimes === 0 ) {
  83. this.nodeBuilderCache.delete( this.getForRenderCacheKey( object ) );
  84. }
  85. }
  86. return super.delete( object );
  87. }
  88. getForCompute( computeNode ) {
  89. const computeData = this.get( computeNode );
  90. let nodeBuilderState = computeData.nodeBuilderState;
  91. if ( nodeBuilderState === undefined ) {
  92. const nodeBuilder = this.backend.createNodeBuilder( computeNode, this.renderer );
  93. nodeBuilder.build();
  94. nodeBuilderState = this._createNodeBuilderState( nodeBuilder );
  95. computeData.nodeBuilderState = nodeBuilderState;
  96. }
  97. return nodeBuilderState;
  98. }
  99. _createNodeBuilderState( nodeBuilder ) {
  100. return new NodeBuilderState(
  101. nodeBuilder.vertexShader,
  102. nodeBuilder.fragmentShader,
  103. nodeBuilder.computeShader,
  104. nodeBuilder.getAttributesArray(),
  105. nodeBuilder.getBindings(),
  106. nodeBuilder.updateNodes,
  107. nodeBuilder.updateBeforeNodes,
  108. nodeBuilder.transforms
  109. );
  110. }
  111. getEnvironmentNode( scene ) {
  112. return scene.environmentNode || this.get( scene ).environmentNode || null;
  113. }
  114. getBackgroundNode( scene ) {
  115. return scene.backgroundNode || this.get( scene ).backgroundNode || null;
  116. }
  117. getFogNode( scene ) {
  118. return scene.fogNode || this.get( scene ).fogNode || null;
  119. }
  120. getCacheKey( scene, lightsNode ) {
  121. const chain = [ scene, lightsNode ];
  122. const callId = this.renderer.info.calls;
  123. let cacheKeyData = this.callHashCache.get( chain );
  124. if ( cacheKeyData === undefined || cacheKeyData.callId !== callId ) {
  125. const environmentNode = this.getEnvironmentNode( scene );
  126. const fogNode = this.getFogNode( scene );
  127. const cacheKey = [];
  128. if ( lightsNode ) cacheKey.push( lightsNode.getCacheKey() );
  129. if ( environmentNode ) cacheKey.push( environmentNode.getCacheKey() );
  130. if ( fogNode ) cacheKey.push( fogNode.getCacheKey() );
  131. cacheKeyData = {
  132. callId,
  133. cacheKey: cacheKey.join( ',' )
  134. };
  135. this.callHashCache.set( chain, cacheKeyData );
  136. }
  137. return cacheKeyData.cacheKey;
  138. }
  139. updateScene( scene ) {
  140. this.updateEnvironment( scene );
  141. this.updateFog( scene );
  142. this.updateBackground( scene );
  143. }
  144. get isToneMappingState() {
  145. return this.renderer.getRenderTarget() ? false : true;
  146. }
  147. updateBackground( scene ) {
  148. const sceneData = this.get( scene );
  149. const background = scene.background;
  150. if ( background ) {
  151. if ( sceneData.background !== background ) {
  152. let backgroundNode = null;
  153. if ( background.isCubeTexture === true || ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) ) {
  154. backgroundNode = pmremTexture( background, normalWorld );
  155. } else if ( background.isTexture === true ) {
  156. backgroundNode = texture( background, viewportBottomLeft ).setUpdateMatrix( true );
  157. } else if ( background.isColor !== true ) {
  158. console.error( 'WebGPUNodes: Unsupported background configuration.', background );
  159. }
  160. sceneData.backgroundNode = backgroundNode;
  161. sceneData.background = background;
  162. }
  163. } else if ( sceneData.backgroundNode ) {
  164. delete sceneData.backgroundNode;
  165. delete sceneData.background;
  166. }
  167. }
  168. updateFog( scene ) {
  169. const sceneData = this.get( scene );
  170. const fog = scene.fog;
  171. if ( fog ) {
  172. if ( sceneData.fog !== fog ) {
  173. let fogNode = null;
  174. if ( fog.isFogExp2 ) {
  175. fogNode = densityFog( reference( 'color', 'color', fog ), reference( 'density', 'float', fog ) );
  176. } else if ( fog.isFog ) {
  177. fogNode = rangeFog( reference( 'color', 'color', fog ), reference( 'near', 'float', fog ), reference( 'far', 'float', fog ) );
  178. } else {
  179. console.error( 'WebGPUNodes: Unsupported fog configuration.', fog );
  180. }
  181. sceneData.fogNode = fogNode;
  182. sceneData.fog = fog;
  183. }
  184. } else {
  185. delete sceneData.fogNode;
  186. delete sceneData.fog;
  187. }
  188. }
  189. updateEnvironment( scene ) {
  190. const sceneData = this.get( scene );
  191. const environment = scene.environment;
  192. if ( environment ) {
  193. if ( sceneData.environment !== environment ) {
  194. let environmentNode = null;
  195. if ( environment.isCubeTexture === true ) {
  196. environmentNode = cubeTexture( environment );
  197. } else if ( environment.isTexture === true ) {
  198. environmentNode = texture( environment );
  199. } else {
  200. console.error( 'Nodes: Unsupported environment configuration.', environment );
  201. }
  202. sceneData.environmentNode = environmentNode;
  203. sceneData.environment = environment;
  204. }
  205. } else if ( sceneData.environmentNode ) {
  206. delete sceneData.environmentNode;
  207. delete sceneData.environment;
  208. }
  209. }
  210. getNodeFrame( renderer = this.renderer, scene = null, object = null, camera = null, material = null ) {
  211. const nodeFrame = this.nodeFrame;
  212. nodeFrame.renderer = renderer;
  213. nodeFrame.scene = scene;
  214. nodeFrame.object = object;
  215. nodeFrame.camera = camera;
  216. nodeFrame.material = material;
  217. return nodeFrame;
  218. }
  219. getNodeFrameForRender( renderObject ) {
  220. return this.getNodeFrame( renderObject.renderer, renderObject.scene, renderObject.object, renderObject.camera, renderObject.material );
  221. }
  222. getOutputNode( outputTexture ) {
  223. let output = texture( outputTexture, viewportTopLeft );
  224. if ( this.isToneMappingState ) {
  225. if ( this.renderer.toneMappingNode ) {
  226. output = vec4( this.renderer.toneMappingNode.context( { color: output.rgb } ), output.a );
  227. } else if ( this.renderer.toneMapping !== NoToneMapping ) {
  228. output = output.toneMapping( this.renderer.toneMapping );
  229. }
  230. }
  231. if ( this.renderer.currentColorSpace === SRGBColorSpace ) {
  232. output = output.linearToColorSpace( this.renderer.currentColorSpace );
  233. }
  234. return output;
  235. }
  236. updateBefore( renderObject ) {
  237. const nodeFrame = this.getNodeFrameForRender( renderObject );
  238. const nodeBuilder = renderObject.getNodeBuilderState();
  239. for ( const node of nodeBuilder.updateBeforeNodes ) {
  240. nodeFrame.updateBeforeNode( node );
  241. }
  242. }
  243. updateForCompute( computeNode ) {
  244. const nodeFrame = this.getNodeFrame();
  245. const nodeBuilder = this.getForCompute( computeNode );
  246. for ( const node of nodeBuilder.updateNodes ) {
  247. nodeFrame.updateNode( node );
  248. }
  249. }
  250. updateForRender( renderObject ) {
  251. const nodeFrame = this.getNodeFrameForRender( renderObject );
  252. const nodeBuilder = renderObject.getNodeBuilderState();
  253. for ( const node of nodeBuilder.updateNodes ) {
  254. nodeFrame.updateNode( node );
  255. }
  256. }
  257. dispose() {
  258. super.dispose();
  259. this.nodeFrame = new NodeFrame();
  260. this.nodeBuilderCache = new Map();
  261. }
  262. }
  263. export default Nodes;