OperatorNode.js 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. import TempNode from '../core/TempNode.js';
  2. import { addNodeClass } from '../core/Node.js';
  3. import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
  4. class OperatorNode extends TempNode {
  5. constructor( op, aNode, bNode, ...params ) {
  6. super();
  7. if ( params.length > 0 ) {
  8. let finalOp = new OperatorNode( op, aNode, bNode );
  9. for ( let i = 0; i < params.length - 1; i ++ ) {
  10. finalOp = new OperatorNode( op, finalOp, params[ i ] );
  11. }
  12. aNode = finalOp;
  13. bNode = params[ params.length - 1 ];
  14. }
  15. this.op = op;
  16. this.aNode = aNode;
  17. this.bNode = bNode;
  18. }
  19. getNodeType( builder, output ) {
  20. const op = this.op;
  21. const aNode = this.aNode;
  22. const bNode = this.bNode;
  23. const typeA = aNode.getNodeType( builder );
  24. const typeB = typeof bNode !== 'undefined' ? bNode.getNodeType( builder ) : null;
  25. if ( typeA === 'void' || typeB === 'void' ) {
  26. return 'void';
  27. } else if ( op === '%' ) {
  28. return typeA;
  29. } else if ( op === '~' || op === '&' || op === '|' || op === '^' || op === '>>' || op === '<<' ) {
  30. return builder.getIntegerType( typeA );
  31. } else if ( op === '!' || op === '==' || op === '&&' || op === '||' || op === '^^' ) {
  32. return 'bool';
  33. } else if ( op === '<' || op === '>' || op === '<=' || op === '>=' ) {
  34. const typeLength = output ? builder.getTypeLength( output ) : Math.max( builder.getTypeLength( typeA ), builder.getTypeLength( typeB ) );
  35. return typeLength > 1 ? `bvec${ typeLength }` : 'bool';
  36. } else {
  37. if ( typeA === 'float' && builder.isMatrix( typeB ) ) {
  38. return typeB;
  39. } else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
  40. // matrix x vector
  41. return builder.getVectorFromMatrix( typeA );
  42. } else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
  43. // vector x matrix
  44. return builder.getVectorFromMatrix( typeB );
  45. } else if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
  46. // anytype x anytype: use the greater length vector
  47. return typeB;
  48. }
  49. return typeA;
  50. }
  51. }
  52. generate( builder, output ) {
  53. const op = this.op;
  54. const aNode = this.aNode;
  55. const bNode = this.bNode;
  56. const type = this.getNodeType( builder, output );
  57. let typeA = null;
  58. let typeB = null;
  59. if ( type !== 'void' ) {
  60. typeA = aNode.getNodeType( builder );
  61. typeB = typeof bNode !== 'undefined' ? bNode.getNodeType( builder ) : null;
  62. if ( op === '<' || op === '>' || op === '<=' || op === '>=' || op === '==' ) {
  63. if ( builder.isVector( typeA ) ) {
  64. typeB = typeA;
  65. } else {
  66. typeA = typeB = 'float';
  67. }
  68. } else if ( op === '>>' || op === '<<' ) {
  69. typeA = type;
  70. typeB = builder.changeComponentType( typeB, 'uint' );
  71. } else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
  72. // matrix x vector
  73. typeB = builder.getVectorFromMatrix( typeA );
  74. } else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
  75. // vector x matrix
  76. typeA = builder.getVectorFromMatrix( typeB );
  77. } else {
  78. // anytype x anytype
  79. typeA = typeB = type;
  80. }
  81. } else {
  82. typeA = typeB = type;
  83. }
  84. const a = aNode.build( builder, typeA );
  85. const b = typeof bNode !== 'undefined' ? bNode.build( builder, typeB ) : null;
  86. const outputLength = builder.getTypeLength( output );
  87. const fnOpSnippet = builder.getFunctionOperator( op );
  88. if ( output !== 'void' ) {
  89. if ( op === '<' && outputLength > 1 ) {
  90. return builder.format( `${ builder.getMethod( 'lessThan' ) }( ${ a }, ${ b } )`, type, output );
  91. } else if ( op === '<=' && outputLength > 1 ) {
  92. return builder.format( `${ builder.getMethod( 'lessThanEqual' ) }( ${ a }, ${ b } )`, type, output );
  93. } else if ( op === '>' && outputLength > 1 ) {
  94. return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${ a }, ${ b } )`, type, output );
  95. } else if ( op === '>=' && outputLength > 1 ) {
  96. return builder.format( `${ builder.getMethod( 'greaterThanEqual' ) }( ${ a }, ${ b } )`, type, output );
  97. } else if ( op === '!' || op === '~' ) {
  98. return builder.format( `(${op}${a})`, typeA, output );
  99. } else if ( fnOpSnippet ) {
  100. return builder.format( `${ fnOpSnippet }( ${ a }, ${ b } )`, type, output );
  101. } else {
  102. return builder.format( `( ${ a } ${ op } ${ b } )`, type, output );
  103. }
  104. } else if ( typeA !== 'void' ) {
  105. if ( fnOpSnippet ) {
  106. return builder.format( `${ fnOpSnippet }( ${ a }, ${ b } )`, type, output );
  107. } else {
  108. return builder.format( `${ a } ${ op } ${ b }`, type, output );
  109. }
  110. }
  111. }
  112. serialize( data ) {
  113. super.serialize( data );
  114. data.op = this.op;
  115. }
  116. deserialize( data ) {
  117. super.deserialize( data );
  118. this.op = data.op;
  119. }
  120. }
  121. export default OperatorNode;
  122. export const add = nodeProxy( OperatorNode, '+' );
  123. export const sub = nodeProxy( OperatorNode, '-' );
  124. export const mul = nodeProxy( OperatorNode, '*' );
  125. export const div = nodeProxy( OperatorNode, '/' );
  126. export const remainder = nodeProxy( OperatorNode, '%' );
  127. export const equal = nodeProxy( OperatorNode, '==' );
  128. export const notEqual = nodeProxy( OperatorNode, '!=' );
  129. export const lessThan = nodeProxy( OperatorNode, '<' );
  130. export const greaterThan = nodeProxy( OperatorNode, '>' );
  131. export const lessThanEqual = nodeProxy( OperatorNode, '<=' );
  132. export const greaterThanEqual = nodeProxy( OperatorNode, '>=' );
  133. export const and = nodeProxy( OperatorNode, '&&' );
  134. export const or = nodeProxy( OperatorNode, '||' );
  135. export const not = nodeProxy( OperatorNode, '!' );
  136. export const xor = nodeProxy( OperatorNode, '^^' );
  137. export const bitAnd = nodeProxy( OperatorNode, '&' );
  138. export const bitNot = nodeProxy( OperatorNode, '~' );
  139. export const bitOr = nodeProxy( OperatorNode, '|' );
  140. export const bitXor = nodeProxy( OperatorNode, '^' );
  141. export const shiftLeft = nodeProxy( OperatorNode, '<<' );
  142. export const shiftRight = nodeProxy( OperatorNode, '>>' );
  143. addNodeElement( 'add', add );
  144. addNodeElement( 'sub', sub );
  145. addNodeElement( 'mul', mul );
  146. addNodeElement( 'div', div );
  147. addNodeElement( 'remainder', remainder );
  148. addNodeElement( 'equal', equal );
  149. addNodeElement( 'notEqual', notEqual );
  150. addNodeElement( 'lessThan', lessThan );
  151. addNodeElement( 'greaterThan', greaterThan );
  152. addNodeElement( 'lessThanEqual', lessThanEqual );
  153. addNodeElement( 'greaterThanEqual', greaterThanEqual );
  154. addNodeElement( 'and', and );
  155. addNodeElement( 'or', or );
  156. addNodeElement( 'not', not );
  157. addNodeElement( 'xor', xor );
  158. addNodeElement( 'bitAnd', bitAnd );
  159. addNodeElement( 'bitNot', bitNot );
  160. addNodeElement( 'bitOr', bitOr );
  161. addNodeElement( 'bitXor', bitXor );
  162. addNodeElement( 'shiftLeft', shiftLeft );
  163. addNodeElement( 'shiftRight', shiftRight );
  164. addNodeClass( 'OperatorNode', OperatorNode );