BumpMapNode.js 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167
  1. import { TempNode } from '../core/TempNode.js';
  2. import { FloatNode } from '../inputs/FloatNode.js';
  3. import { FunctionNode } from '../core/FunctionNode.js';
  4. import { NormalNode } from '../accessors/NormalNode.js';
  5. import { PositionNode } from '../accessors/PositionNode.js';
  6. class BumpMapNode extends TempNode {
  7. constructor( value, scale ) {
  8. super( 'v3' );
  9. this.value = value;
  10. this.scale = scale || new FloatNode( 1 );
  11. this.toNormalMap = false;
  12. }
  13. generate( builder, output ) {
  14. if ( builder.isShader( 'fragment' ) ) {
  15. if ( this.toNormalMap ) {
  16. const bumpToNormal = builder.include( BumpMapNode.Nodes.bumpToNormal );
  17. return builder.format( bumpToNormal + '( ' + this.value.build( builder, 'sampler2D' ) + ', ' +
  18. this.value.uv.build( builder, 'v2' ) + ', ' +
  19. this.scale.build( builder, 'f' ) + ' )', this.getType( builder ), output );
  20. } else {
  21. const derivativeHeight = builder.include( BumpMapNode.Nodes.dHdxy_fwd ),
  22. perturbNormalArb = builder.include( BumpMapNode.Nodes.perturbNormalArb );
  23. this.normal = this.normal || new NormalNode();
  24. this.position = this.position || new PositionNode( PositionNode.VIEW );
  25. const derivativeHeightCode = derivativeHeight + '( ' + this.value.build( builder, 'sampler2D' ) + ', ' +
  26. this.value.uv.build( builder, 'v2' ) + ', ' +
  27. this.scale.build( builder, 'f' ) + ' )';
  28. return builder.format( perturbNormalArb + '( -' + this.position.build( builder, 'v3' ) + ', ' +
  29. this.normal.build( builder, 'v3' ) + ', ' +
  30. derivativeHeightCode + ' )', this.getType( builder ), output );
  31. }
  32. } else {
  33. console.warn( 'THREE.BumpMapNode is not compatible with ' + builder.shader + ' shader.' );
  34. return builder.format( 'vec3( 0.0 )', this.getType( builder ), output );
  35. }
  36. }
  37. copy( source ) {
  38. super.copy( source );
  39. this.value = source.value;
  40. this.scale = source.scale;
  41. return this;
  42. }
  43. toJSON( meta ) {
  44. let data = this.getJSONNode( meta );
  45. if ( ! data ) {
  46. data = this.createJSONNode( meta );
  47. data.value = this.value.toJSON( meta ).uuid;
  48. data.scale = this.scale.toJSON( meta ).uuid;
  49. }
  50. return data;
  51. }
  52. }
  53. BumpMapNode.Nodes = ( function () {
  54. const dHdxy_fwd = new FunctionNode( [
  55. // Bump Mapping Unparametrized Surfaces on the GPU by Morten S. Mikkelsen
  56. // http://api.unrealengine.com/attachments/Engine/Rendering/LightingAndShadows/BumpMappingWithoutTangentSpace/mm_sfgrad_bump.pdf
  57. // Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)
  58. 'vec2 dHdxy_fwd( sampler2D bumpMap, vec2 vUv, float bumpScale ) {',
  59. // Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
  60. ' vec2 dSTdx = dFdx( vUv );',
  61. ' vec2 dSTdy = dFdy( vUv );',
  62. ' float Hll = bumpScale * texture2D( bumpMap, vUv ).x;',
  63. ' float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;',
  64. ' float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;',
  65. ' return vec2( dBx, dBy );',
  66. '}'
  67. ].join( '\n' ), null, { derivatives: true } );
  68. const perturbNormalArb = new FunctionNode( [
  69. 'vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {',
  70. // Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
  71. ' vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );',
  72. ' vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );',
  73. ' vec3 vN = surf_norm;', // normalized
  74. ' vec3 R1 = cross( vSigmaY, vN );',
  75. ' vec3 R2 = cross( vN, vSigmaX );',
  76. ' float fDet = dot( vSigmaX, R1 );',
  77. ' fDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );',
  78. ' vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );',
  79. ' return normalize( abs( fDet ) * surf_norm - vGrad );',
  80. '}'
  81. ].join( '\n' ), [ dHdxy_fwd ], { derivatives: true } );
  82. const bumpToNormal = new FunctionNode( [
  83. 'vec3 bumpToNormal( sampler2D bumpMap, vec2 uv, float scale ) {',
  84. ' vec2 dSTdx = dFdx( uv );',
  85. ' vec2 dSTdy = dFdy( uv );',
  86. ' float Hll = texture2D( bumpMap, uv ).x;',
  87. ' float dBx = texture2D( bumpMap, uv + dSTdx ).x - Hll;',
  88. ' float dBy = texture2D( bumpMap, uv + dSTdy ).x - Hll;',
  89. ' return vec3( .5 - ( dBx * scale ), .5 - ( dBy * scale ), 1.0 );',
  90. '}'
  91. ].join( '\n' ), null, { derivatives: true } );
  92. return {
  93. dHdxy_fwd: dHdxy_fwd,
  94. perturbNormalArb: perturbNormalArb,
  95. bumpToNormal: bumpToNormal
  96. };
  97. } )();
  98. BumpMapNode.prototype.nodeType = 'BumpMap';
  99. BumpMapNode.prototype.hashProperties = [ 'toNormalMap' ];
  100. export { BumpMapNode };