/src/aerys/minko/render/shader/compiler/graph/nodes/vertex/Instruction.as

https://bitbucket.org/HopeSky/mars_nd2d · ActionScript · 257 lines · 211 code · 40 blank · 6 comment · 29 complexity · 8862d2b914d5f71c95579601b1433cae MD5 · raw file 

    

  1. package aerys.minko.render.shader.compiler.graph.nodes.vertex
    2. 

  2. {
    3. 

  3. 	import aerys.minko.render.shader.compiler.CRC32;
    4. 

  4. 	import aerys.minko.render.shader.compiler.InstructionFlag;
    5. 

  5. 	import aerys.minko.render.shader.compiler.graph.nodes.AbstractNode;
    6. 

  6. 	import aerys.minko.render.shader.compiler.register.Components;
    7. 

  7. 	
    8. 

  8. 	import flash.utils.Dictionary;
    9. 

  9. 

  10. 	/**
    11. 

  11. 	 * @private
    12. 

  12. 	 * @author Romain Gilliotte
    13. 

  13. 	 */
    14. 

  14. 	public class Instruction extends AbstractNode
    15. 

  15. 	{
    16. 

  16. 		public static const MOV : uint = 0x00;
    17. 

  17. 		public static const ADD : uint = 0x01;
    18. 

  18. 		public static const SUB : uint = 0x02;
    19. 

  19. 		public static const MUL : uint = 0x03;
    20. 

  20. 		public static const DIV : uint = 0x04;
    21. 

  21. 		public static const RCP : uint = 0x05;
    22. 

  22. 		public static const MIN : uint = 0x06;
    23. 

  23. 		public static const MAX : uint = 0x07;
    24. 

  24. 		public static const FRC : uint = 0x08;
    25. 

  25. 		public static const SQT : uint = 0x09;
    26. 

  26. 		public static const RSQ : uint = 0x0a;
    27. 

  27. 		public static const POW : uint = 0x0b;
    28. 

  28. 		public static const LOG : uint = 0x0c;
    29. 

  29. 		public static const EXP : uint = 0x0d;
    30. 

  30. 		public static const NRM : uint = 0x0e;
    31. 

  31. 		public static const SIN : uint = 0x0f;
    32. 

  32. 		public static const COS : uint = 0x10;
    33. 

  33. 		public static const CRS : uint = 0x11;
    34. 

  34. 		public static const DP3 : uint = 0x12;
    35. 

  35. 		public static const DP4 : uint = 0x13;
    36. 

  36. 		public static const ABS : uint = 0x14;
    37. 

  37. 		public static const NEG : uint = 0x15;
    38. 

  38. 		public static const SAT : uint = 0x16;
    39. 

  39. 		public static const M33 : uint = 0x17;
    40. 

  40. 		public static const M44 : uint = 0x18;
    41. 

  41. 		public static const M34 : uint = 0x19;
    42. 

  42. 		public static const KIL	: uint = 0x27;
    43. 

  43. 		public static const TEX : uint = 0x28;
    44. 

  44. 		public static const SGE : uint = 0x29;
    45. 

  45. 		public static const SLT : uint = 0x2a;
    46. 

  46. 		public static const SEQ : uint = 0x2c;
    47. 

  47. 		public static const SNE : uint = 0x2d;
    48. 

  48. 		
    49. 

  49. 		public static const MUL_MAT33 : uint = 0x100;
    50. 

  50. 		public static const MUL_MAT44 : uint = 0x101;
    51. 

  51. 		
    52. 

  52. 		public static const NAME : Dictionary = new Dictionary();
    53. 

  53. 		{
    54. 

  54. 			NAME[MOV] = 'mov';		NAME[ADD] = 'add';		NAME[SUB] = 'sub';
    55. 

  55. 			NAME[MUL] = 'mul';		NAME[DIV] = 'div';		NAME[RCP] = 'rcp';
    56. 

  56. 			NAME[MIN] = 'min';		NAME[MAX] = 'max';		NAME[FRC] = 'frc';
    57. 

  57. 			NAME[SQT] = 'sqt';		NAME[RSQ] = 'rsq';		NAME[POW] = 'pow';
    58. 

  58. 			NAME[LOG] = 'log';		NAME[EXP] = 'exp';		NAME[NRM] = 'nrm';
    59. 

  59. 			NAME[SIN] = 'sin';		NAME[COS] = 'cos';		NAME[CRS] = 'crs';
    60. 

  60. 			NAME[DP3] = 'dp3';		NAME[DP4] = 'dp4';		NAME[ABS] = 'abs';
    61. 

  61. 			NAME[NEG] = 'neg';		NAME[SAT] = 'sat';		NAME[M33] = 'm33';
    62. 

  62. 			NAME[M44] = 'm44';		NAME[M34] = 'm34';		NAME[TEX] = 'tex';
    63. 

  63. 			NAME[KIL] = 'kil';		NAME[SGE] = 'sge';		NAME[SLT] = 'slt';
    64. 

  64. 			NAME[SEQ] = 'seq';		NAME[SNE] = 'sne';
    65. 

  65. 			
    66. 

  66. 			NAME[MUL_MAT33] = 'mulMat33';
    67. 

  67. 			NAME[MUL_MAT44] = 'mulMat44';
    68. 

  68. 		}
    69. 

  69. 		
    70. 

  70. 		private static const FLAGS : Dictionary = new Dictionary();
    71. 

  71. 		{
    72. 

  72. 			FLAGS[MOV] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE | InstructionFlag.LINEAR;
    73. 

  73. 			FLAGS[ADD] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE | InstructionFlag.LINEAR;
    74. 

  74. 			FLAGS[SUB] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.LINEAR;
    75. 

  75. 			FLAGS[MUL] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE | InstructionFlag.LINEAR;
    76. 

  76. 			FLAGS[DIV] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.LINEAR;
    77. 

  77. 			FLAGS[RCP] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE | InstructionFlag.LINEAR;
    78. 

  78. 			FLAGS[MIN] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE;
    79. 

  79. 			FLAGS[MAX] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE;
    80. 

  80. 			FLAGS[FRC] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    81. 

  81. 			FLAGS[SQT] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    82. 

  82. 			FLAGS[RSQ] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    83. 

  83. 			FLAGS[POW] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE;
    84. 

  84. 			FLAGS[LOG] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    85. 

  85. 			FLAGS[EXP] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    86. 

  86. 			FLAGS[NRM] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.SINGLE;
    87. 

  87. 			FLAGS[SIN] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    88. 

  88. 			FLAGS[COS] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    89. 

  89. 			FLAGS[CRS] = InstructionFlag.AVAILABLE_ALL;
    90. 

  90. 			FLAGS[DP3] = InstructionFlag.AVAILABLE_ALL;
    91. 

  91. 			FLAGS[DP4] = InstructionFlag.AVAILABLE_ALL;
    92. 

  92. 			FLAGS[ABS] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    93. 

  93. 			FLAGS[NEG] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE | InstructionFlag.LINEAR;
    94. 

  94. 			FLAGS[SAT] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.SINGLE;
    95. 

  95. 			FLAGS[M33] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.SPECIAL_MATRIX | InstructionFlag.LINEAR;
    96. 

  96. 			FLAGS[M44] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.SPECIAL_MATRIX | InstructionFlag.LINEAR;
    97. 

  97. 			FLAGS[M34] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.SPECIAL_MATRIX | InstructionFlag.LINEAR;
    98. 

  98. 			FLAGS[KIL] = InstructionFlag.AVAILABLE_FS | InstructionFlag.SINGLE;
    99. 

  99. 			FLAGS[TEX] = InstructionFlag.AVAILABLE_FS;
    100. 

  100. 			FLAGS[SGE] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE;
    101. 

  101. 			FLAGS[SLT] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE;
    102. 

  102. 			FLAGS[SEQ] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE;
    103. 

  103. 			FLAGS[SNE] = InstructionFlag.AVAILABLE_ALL | InstructionFlag.COMPONENT_WISE | InstructionFlag.COMMUTATIVE;
    104. 

  104. 			
    105. 

  105. 			FLAGS[MUL_MAT33] = InstructionFlag.AVAILABLE_CPU | InstructionFlag.ASSOCIATIVE;
    106. 

  106. 			FLAGS[MUL_MAT44] = InstructionFlag.AVAILABLE_CPU | InstructionFlag.ASSOCIATIVE;
    107. 

  107. 		}
    108. 

  108. 		
    109. 

  109. 		private var _id : uint;
    110. 

  110. 		
    111. 

  111. 		public function get id()			: uint		{ return _id;		}
    112. 

  112. 		public function get name()			: String	{ return NAME[_id];	}
    113. 

  113. 		
    114. 

  114. 		public function get argument1()		: AbstractNode	{ return getArgumentAt(0);	}
    115. 

  115. 		public function get argument2() 	: AbstractNode 	{ return getArgumentAt(1);	}
    116. 

  116. 		public function get component1()	: uint			{ return getComponentAt(0);	}
    117. 

  117. 		public function get component2()	: uint			{ return getComponentAt(1);	}
    118. 

  118. 		
    119. 

  119. 		public function set argument1(v : AbstractNode) : void { setArgumentAt(0, v);	}
    120. 

  120. 		public function set argument2(v : AbstractNode) : void { setArgumentAt(1, v);	}
    121. 

  121. 		public function set component1(v : uint) 		: void { setComponentAt(0, v);	}
    122. 

  122. 		public function set component2(v : uint) 		: void { setComponentAt(1, v);	}
    123. 

  123. 		
    124. 

  124. 		public function get isAssociative() : Boolean
    125. 

  125. 		{
    126. 

  126. 			return (FLAGS[_id] & InstructionFlag.ASSOCIATIVE) != 0;
    127. 

  127. 		}
    128. 

  128. 		
    129. 

  129. 		public function get isComponentWise() : Boolean
    130. 

  130. 		{
    131. 

  131. 			return (FLAGS[_id] & InstructionFlag.COMPONENT_WISE) != 0;
    132. 

  132. 		}
    133. 

  133. 		
    134. 

  134. 		public function get isSingle() : Boolean
    135. 

  135. 		{
    136. 

  136. 			return (FLAGS[_id] & InstructionFlag.SINGLE) != 0;
    137. 

  137. 		}
    138. 

  138. 		
    139. 

  139. 		public function get isLinear() : Boolean
    140. 

  140. 		{
    141. 

  141. 			return (FLAGS[_id] & InstructionFlag.LINEAR) != 0;
    142. 

  142. 		}
    143. 

  143. 		
    144. 

  144. 		public function isCommutative() : Boolean
    145. 

  145. 		{
    146. 

  146. 			return (FLAGS[_id] & InstructionFlag.COMMUTATIVE) != 0;
    147. 

  147. 		}
    148. 

  148. 

  149. 		public function Instruction(id			: uint,
    150. 

  150. 									argument1	: AbstractNode,
    151. 

  151. 									argument2	: AbstractNode = null)
    152. 

  152. 		{
    153. 

  153. 			_id = id;
    154. 

  154. 			
    155. 

  155. 			var component1 : uint = id == MUL_MAT33 || id == MUL_MAT44 ? 
    156. 

  156. 				Components.createContinuous(0, 0, 4, 4) :
    157. 

  157. 				Components.createContinuous(0, 0, argument1.size, argument1.size)
    158. 

  158. 			
    159. 

  159. 			var arguments	: Vector.<AbstractNode>	= new <AbstractNode>[argument1];
    160. 

  160. 			var components	: Vector.<uint>			= new <uint>[component1];
    161. 

  161. 			
    162. 

  162. 			if (!isSingle)
    163. 

  163. 			{
    164. 

  164. 				var component2 : uint;
    165. 

  165. 				
    166. 

  166. 				if ((FLAGS[id] & InstructionFlag.SPECIAL_MATRIX) != 0)
    167. 

  167. 					component2	= Components.createContinuous(0, 0, 4, 4);
    168. 

  168. 				else if (id != TEX && id != MUL_MAT33 && id != MUL_MAT44)
    169. 

  169. 					component2	= Components.createContinuous(0, 0, argument2.size, argument2.size);
    170. 

  170. 				
    171. 

  171. 				arguments.push(argument2);
    172. 

  172. 				components.push(component2);
    173. 

  173. 			}
    174. 

  174. 			
    175. 

  175. 			arguments.fixed = components.fixed = true;
    176. 

  176. 			
    177. 

  177. 			super(arguments, components);
    178. 

  178. 		}
    179. 

  179. 		
    180. 

  180. 		override protected function computeHash() : uint
    181. 

  181. 		{
    182. 

  182. 			// commutative operations invert the arguments when computing the hash if arg1.crc > arg2.crc
    183. 

  183. 			// that way, mul(a, b).hash == mul(b, a).hash
    184. 

  184. 			
    185. 

  185. 			var hashLeft  : String = argument1.hash.toString(16) + '_' + component1.toString(16);
    186. 

  186. 			
    187. 

  187. 			if ((FLAGS[_id] & InstructionFlag.SINGLE) != 0)
    188. 

  188. 				return CRC32.computeForString(hashLeft);
    189. 

  189. 			
    190. 

  190. 			else
    191. 

  191. 			{
    192. 

  192. 				var hashRight : String = argument2.hash.toString(16) + '_' + component2.toString(16);
    193. 

  193. 				
    194. 

  194. 				if ((FLAGS[_id] & InstructionFlag.COMMUTATIVE) != 0 && argument1.hash > argument2.hash)
    195. 

  195. 					return CRC32.computeForString(hashRight + hashLeft);
    196. 

  196. 				else
    197. 

  197. 					return CRC32.computeForString(hashLeft + hashRight);
    198. 

  198. 			}
    199. 

  199. 		}
    200. 

  200. 		
    201. 

  201. 		override protected function computeSize() : uint
    202. 

  202. 		{
    203. 

  203. 			switch (_id)
    204. 

  204. 			{
    205. 

  205. 				case DP3: case DP4:	return 1;
    206. 

  206. 				case M33: case M34: case NRM: case CRS: return 3;
    207. 

  207. 				case TEX: case M44: return 4;
    208. 

  208. 				
    209. 

  209. 				default:
    210. 

  210. 					var nodeSize : uint;
    211. 

  211. 					nodeSize = Components.getMaxWriteOffset(component1) 
    212. 

  212. 								- Components.getMinWriteOffset(component1) + 1;
    213. 

  213. 					
    214. 

  214. 					if (nodeSize > 4)
    215. 

  215. 						throw new Error();
    216. 

  216. 								
    217. 

  217. 					if (!isSingle)
    218. 

  218. 						nodeSize = Math.max(nodeSize, 
    219. 

  219. 							Components.getMaxWriteOffset(component2) 
    220. 

  220. 							- Components.getMinWriteOffset(component2) + 1
    221. 

  221. 						);
    222. 

  222. 					
    223. 

  223. 					if (nodeSize < 1)
    224. 

  224. 						throw new Error();
    225. 

  225. 					
    226. 

  226. 					if (nodeSize > 4)
    227. 

  227. 						throw new Error();
    228. 

  228. 					
    229. 

  229. 					return nodeSize;
    230. 

  230. 			}
    231. 

  231. 		}
    232. 

  232. 		
    233. 

  233. 		override public function toString() : String
    234. 

  234. 		{
    235. 

  235. 			return name;
    236. 

  236. 		}
    237. 

  237. 		
    238. 

  238. 		override public function clone() : AbstractNode
    239. 

  239. 		{
    240. 

  240. 			var clone : Instruction;
    241. 

  241. 			if (isSingle)
    242. 

  242. 			{
    243. 

  243. 				clone = new Instruction(_id, argument1);
    244. 

  244. 				clone.component1 = component1;
    245. 

  245. 			}
    246. 

  246. 			else
    247. 

  247. 			{
    248. 

  248. 				clone = new Instruction(_id, argument1, argument2);
    249. 

  249. 				clone.component1 = component1;
    250. 

  250. 				clone.component2 = component2;
    251. 

  251. 			}
    252. 

  252. 			
    253. 

  253. 			return clone;
    254. 

  254. 		}
    255. 

  255. 

  256. 	}
    257. 

  257. }
    258.