Nodes.js 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493
  1. import DataMap from '../DataMap.js';
  2. import ChainMap from '../ChainMap.js';
  3. import NodeBuilderState from './NodeBuilderState.js';
  4. import { NoToneMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from 'three';
  5. import { NodeFrame, objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, toneMapping, equirectUV, viewportBottomLeft, normalWorld } 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.toneMappingNode = this.getToneMappingNode();
  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 = nodeBuilder;
  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. );
  109. }
  110. getEnvironmentNode( scene ) {
  111. return scene.environmentNode || this.get( scene ).environmentNode || null;
  112. }
  113. getBackgroundNode( scene ) {
  114. return scene.backgroundNode || this.get( scene ).backgroundNode || null;
  115. }
  116. getFogNode( scene ) {
  117. return scene.fogNode || this.get( scene ).fogNode || null;
  118. }
  119. getToneMappingNode() {
  120. if ( this.isToneMappingState === false ) return null;
  121. return this.renderer.toneMappingNode || this.get( this.renderer ).toneMappingNode || null;
  122. }
  123. getCacheKey( scene, lightsNode ) {
  124. const chain = [ scene, lightsNode ];
  125. const callId = this.renderer.info.calls;
  126. let cacheKeyData = this.callHashCache.get( chain );
  127. if ( cacheKeyData === undefined || cacheKeyData.callId !== callId ) {
  128. const environmentNode = this.getEnvironmentNode( scene );
  129. const fogNode = this.getFogNode( scene );
  130. const toneMappingNode = this.getToneMappingNode();
  131. const cacheKey = [];
  132. if ( lightsNode ) cacheKey.push( lightsNode.getCacheKey() );
  133. if ( environmentNode ) cacheKey.push( environmentNode.getCacheKey() );
  134. if ( fogNode ) cacheKey.push( fogNode.getCacheKey() );
  135. if ( toneMappingNode ) cacheKey.push( toneMappingNode.getCacheKey() );
  136. cacheKeyData = {
  137. callId,
  138. cacheKey: cacheKey.join( ',' )
  139. };
  140. this.callHashCache.set( chain, cacheKeyData );
  141. }
  142. return cacheKeyData.cacheKey;
  143. }
  144. updateScene( scene ) {
  145. this.updateEnvironment( scene );
  146. this.updateFog( scene );
  147. this.updateBackground( scene );
  148. this.updateToneMapping();
  149. }
  150. get isToneMappingState() {
  151. const renderer = this.renderer;
  152. const renderTarget = renderer.getRenderTarget();
  153. return renderTarget && renderTarget.isCubeRenderTarget ? false : true;
  154. }
  155. updateToneMapping() {
  156. const renderer = this.renderer;
  157. const rendererData = this.get( renderer );
  158. const rendererToneMapping = renderer.toneMapping;
  159. if ( this.isToneMappingState && rendererToneMapping !== NoToneMapping ) {
  160. if ( rendererData.toneMapping !== rendererToneMapping ) {
  161. const rendererToneMappingNode = rendererData.rendererToneMappingNode || toneMapping( rendererToneMapping, reference( 'toneMappingExposure', 'float', renderer ) );
  162. rendererToneMappingNode.toneMapping = rendererToneMapping;
  163. rendererData.rendererToneMappingNode = rendererToneMappingNode;
  164. rendererData.toneMappingNode = rendererToneMappingNode;
  165. rendererData.toneMapping = rendererToneMapping;
  166. }
  167. } else {
  168. // Don't delete rendererData.rendererToneMappingNode
  169. delete rendererData.toneMappingNode;
  170. delete rendererData.toneMapping;
  171. }
  172. }
  173. updateBackground( scene ) {
  174. const sceneData = this.get( scene );
  175. const background = scene.background;
  176. if ( background ) {
  177. if ( sceneData.background !== background ) {
  178. let backgroundNode = null;
  179. if ( background.isCubeTexture === true ) {
  180. backgroundNode = cubeTexture( background, normalWorld );
  181. } else if ( background.isTexture === true ) {
  182. let nodeUV = null;
  183. if ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) {
  184. nodeUV = equirectUV();
  185. } else {
  186. nodeUV = viewportBottomLeft;
  187. }
  188. backgroundNode = texture( background, nodeUV ).setUpdateMatrix( true );
  189. } else if ( background.isColor !== true ) {
  190. console.error( 'WebGPUNodes: Unsupported background configuration.', background );
  191. }
  192. sceneData.backgroundNode = backgroundNode;
  193. sceneData.background = background;
  194. }
  195. } else if ( sceneData.backgroundNode ) {
  196. delete sceneData.backgroundNode;
  197. delete sceneData.background;
  198. }
  199. }
  200. updateFog( scene ) {
  201. const sceneData = this.get( scene );
  202. const fog = scene.fog;
  203. if ( fog ) {
  204. if ( sceneData.fog !== fog ) {
  205. let fogNode = null;
  206. if ( fog.isFogExp2 ) {
  207. fogNode = densityFog( reference( 'color', 'color', fog ), reference( 'density', 'float', fog ) );
  208. } else if ( fog.isFog ) {
  209. fogNode = rangeFog( reference( 'color', 'color', fog ), reference( 'near', 'float', fog ), reference( 'far', 'float', fog ) );
  210. } else {
  211. console.error( 'WebGPUNodes: Unsupported fog configuration.', fog );
  212. }
  213. sceneData.fogNode = fogNode;
  214. sceneData.fog = fog;
  215. }
  216. } else {
  217. delete sceneData.fogNode;
  218. delete sceneData.fog;
  219. }
  220. }
  221. updateEnvironment( scene ) {
  222. const sceneData = this.get( scene );
  223. const environment = scene.environment;
  224. if ( environment ) {
  225. if ( sceneData.environment !== environment ) {
  226. let environmentNode = null;
  227. if ( environment.isCubeTexture === true ) {
  228. environmentNode = cubeTexture( environment );
  229. } else if ( environment.isTexture === true ) {
  230. environmentNode = texture( environment );
  231. } else {
  232. console.error( 'Nodes: Unsupported environment configuration.', environment );
  233. }
  234. sceneData.environmentNode = environmentNode;
  235. sceneData.environment = environment;
  236. }
  237. } else if ( sceneData.environmentNode ) {
  238. delete sceneData.environmentNode;
  239. delete sceneData.environment;
  240. }
  241. }
  242. getNodeFrame( renderer = this.renderer, scene = null, object = null, camera = null, material = null ) {
  243. const nodeFrame = this.nodeFrame;
  244. nodeFrame.renderer = renderer;
  245. nodeFrame.scene = scene;
  246. nodeFrame.object = object;
  247. nodeFrame.camera = camera;
  248. nodeFrame.material = material;
  249. return nodeFrame;
  250. }
  251. getNodeFrameForRender( renderObject ) {
  252. return this.getNodeFrame( renderObject.renderer, renderObject.scene, renderObject.object, renderObject.camera, renderObject.material );
  253. }
  254. updateBefore( renderObject ) {
  255. const nodeFrame = this.getNodeFrameForRender( renderObject );
  256. const nodeBuilder = renderObject.getNodeBuilderState();
  257. for ( const node of nodeBuilder.updateBeforeNodes ) {
  258. nodeFrame.updateBeforeNode( node );
  259. }
  260. }
  261. updateForCompute( computeNode ) {
  262. const nodeFrame = this.getNodeFrame();
  263. const nodeBuilder = this.getForCompute( computeNode );
  264. for ( const node of nodeBuilder.updateNodes ) {
  265. nodeFrame.updateNode( node );
  266. }
  267. }
  268. updateForRender( renderObject ) {
  269. const nodeFrame = this.getNodeFrameForRender( renderObject );
  270. const nodeBuilder = renderObject.getNodeBuilderState();
  271. for ( const node of nodeBuilder.updateNodes ) {
  272. nodeFrame.updateNode( node );
  273. }
  274. }
  275. dispose() {
  276. super.dispose();
  277. this.nodeFrame = new NodeFrame();
  278. this.nodeBuilderCache = new Map();
  279. }
  280. }
  281. export default Nodes;