DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 Commits
1 Branch
310MB
Tree: e07df08cd8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e07df08cd8'
${ noResults }
DPF-Plugins/plugins/ProM/projectM/vendor/glm/gtc/noise.inl

809 lines
32KB
Raw Blame History 

  1. /// @ref gtc_noise

  2. /// @file glm/gtc/noise.inl

  3. ///

  4. // Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise":

  5. // https://github.com/ashima/webgl-noise

  6. // Following Stefan Gustavson's paper "Simplex noise demystified":

  7. // http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf

  8. 

  9. namespace glm{

  10. namespace gtc

  11. {

  12. 	template<typename T, qualifier Q>

  13. 	GLM_FUNC_QUALIFIER vec<4, T, Q> grad4(T const& j, vec<4, T, Q> const& ip)

  14. 	{

  15. 		vec<3, T, Q> pXYZ = floor(fract(vec<3, T, Q>(j) * vec<3, T, Q>(ip)) * T(7)) * ip[2] - T(1);

  16. 		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), vec<3, T, Q>(1));

  17. 		vec<4, T, Q> s = vec<4, T, Q>(lessThan(vec<4, T, Q>(pXYZ, pW), vec<4, T, Q>(0.0)));

  18. 		pXYZ = pXYZ + (vec<3, T, Q>(s) * T(2) - T(1)) * s.w;

  19. 		return vec<4, T, Q>(pXYZ, pW);

  20. 	}

  21. }//namespace gtc

  22. 

  23. 	// Classic Perlin noise

  24. 	template<typename T, qualifier Q>

  25. 	GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position)

  26. 	{

  27. 		vec<4, T, Q> Pi = glm::floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);

  28. 		vec<4, T, Q> Pf = glm::fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);

  29. 		Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation

  30. 		vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z);

  31. 		vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w);

  32. 		vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z);

  33. 		vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w);

  34. 

  35. 		vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy);

  36. 

  37. 		vec<4, T, Q> gx = static_cast<T>(2) * glm::fract(i / T(41)) - T(1);

  38. 		vec<4, T, Q> gy = glm::abs(gx) - T(0.5);

  39. 		vec<4, T, Q> tx = glm::floor(gx + T(0.5));

  40. 		gx = gx - tx;

  41. 

  42. 		vec<2, T, Q> g00(gx.x, gy.x);

  43. 		vec<2, T, Q> g10(gx.y, gy.y);

  44. 		vec<2, T, Q> g01(gx.z, gy.z);

  45. 		vec<2, T, Q> g11(gx.w, gy.w);

  46. 

  47. 		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));

  48. 		g00 *= norm.x;

  49. 		g01 *= norm.y;

  50. 		g10 *= norm.z;

  51. 		g11 *= norm.w;

  52. 

  53. 		T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x));

  54. 		T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y));

  55. 		T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z));

  56. 		T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w));

  57. 

  58. 		vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y));

  59. 		vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x);

  60. 		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);

  61. 		return T(2.3) * n_xy;

  62. 	}

  63. 

  64. 	// Classic Perlin noise

  65. 	template<typename T, qualifier Q>

  66. 	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position)

  67. 	{

  68. 		vec<3, T, Q> Pi0 = floor(Position); // Integer part for indexing

  69. 		vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1

  70. 		Pi0 = detail::mod289(Pi0);

  71. 		Pi1 = detail::mod289(Pi1);

  72. 		vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation

  73. 		vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0

  74. 		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);

  75. 		vec<4, T, Q> iy = vec<4, T, Q>(vec<2, T, Q>(Pi0.y), vec<2, T, Q>(Pi1.y));

  76. 		vec<4, T, Q> iz0(Pi0.z);

  77. 		vec<4, T, Q> iz1(Pi1.z);

  78. 

  79. 		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);

  80. 		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);

  81. 		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);

  82. 

  83. 		vec<4, T, Q> gx0 = ixy0 * T(1.0 / 7.0);

  84. 		vec<4, T, Q> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);

  85. 		gx0 = fract(gx0);

  86. 		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);

  87. 		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0));

  88. 		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));

  89. 		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));

  90. 

  91. 		vec<4, T, Q> gx1 = ixy1 * T(1.0 / 7.0);

  92. 		vec<4, T, Q> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);

  93. 		gx1 = fract(gx1);

  94. 		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);

  95. 		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0));

  96. 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));

  97. 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));

  98. 

  99. 		vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x);

  100. 		vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y);

  101. 		vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z);

  102. 		vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w);

  103. 		vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x);

  104. 		vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y);

  105. 		vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z);

  106. 		vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w);

  107. 

  108. 		vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));

  109. 		g000 *= norm0.x;

  110. 		g010 *= norm0.y;

  111. 		g100 *= norm0.z;

  112. 		g110 *= norm0.w;

  113. 		vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));

  114. 		g001 *= norm1.x;

  115. 		g011 *= norm1.y;

  116. 		g101 *= norm1.z;

  117. 		g111 *= norm1.w;

  118. 

  119. 		T n000 = dot(g000, Pf0);

  120. 		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));

  121. 		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));

  122. 		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));

  123. 		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));

  124. 		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));

  125. 		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));

  126. 		T n111 = dot(g111, Pf1);

  127. 

  128. 		vec<3, T, Q> fade_xyz = detail::fade(Pf0);

  129. 		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);

  130. 		vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);

  131. 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);

  132. 		return T(2.2) * n_xyz;

  133. 	}

  134. 	/*

  135. 	// Classic Perlin noise

  136. 	template<typename T, qualifier Q>

  137. 	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& P)

  138. 	{

  139. 		vec<3, T, Q> Pi0 = floor(P); // Integer part for indexing

  140. 		vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1

  141. 		Pi0 = mod(Pi0, T(289));

  142. 		Pi1 = mod(Pi1, T(289));

  143. 		vec<3, T, Q> Pf0 = fract(P); // Fractional part for interpolation

  144. 		vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0

  145. 		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);

  146. 		vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);

  147. 		vec<4, T, Q> iz0(Pi0.z);

  148. 		vec<4, T, Q> iz1(Pi1.z);

  149. 

  150. 		vec<4, T, Q> ixy = permute(permute(ix) + iy);

  151. 		vec<4, T, Q> ixy0 = permute(ixy + iz0);

  152. 		vec<4, T, Q> ixy1 = permute(ixy + iz1);

  153. 

  154. 		vec<4, T, Q> gx0 = ixy0 / T(7);

  155. 		vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5);

  156. 		gx0 = fract(gx0);

  157. 		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);

  158. 		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0));

  159. 		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));

  160. 		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));

  161. 

  162. 		vec<4, T, Q> gx1 = ixy1 / T(7);

  163. 		vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5);

  164. 		gx1 = fract(gx1);

  165. 		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);

  166. 		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0));

  167. 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));

  168. 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));

  169. 

  170. 		vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x);

  171. 		vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y);

  172. 		vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z);

  173. 		vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w);

  174. 		vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x);

  175. 		vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y);

  176. 		vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z);

  177. 		vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w);

  178. 

  179. 		vec<4, T, Q> norm0 = taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));

  180. 		g000 *= norm0.x;

  181. 		g010 *= norm0.y;

  182. 		g100 *= norm0.z;

  183. 		g110 *= norm0.w;

  184. 		vec<4, T, Q> norm1 = taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));

  185. 		g001 *= norm1.x;

  186. 		g011 *= norm1.y;

  187. 		g101 *= norm1.z;

  188. 		g111 *= norm1.w;

  189. 

  190. 		T n000 = dot(g000, Pf0);

  191. 		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));

  192. 		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));

  193. 		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));

  194. 		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));

  195. 		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));

  196. 		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));

  197. 		T n111 = dot(g111, Pf1);

  198. 

  199. 		vec<3, T, Q> fade_xyz = fade(Pf0);

  200. 		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);

  201. 		vec<2, T, Q> n_yz = mix(

  202. 			vec<2, T, Q>(n_z.x, n_z.y),

  203. 			vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);

  204. 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);

  205. 		return T(2.2) * n_xyz;

  206. 	}

  207. 	*/

  208. 	// Classic Perlin noise

  209. 	template<typename T, qualifier Q>

  210. 	GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position)

  211. 	{

  212. 		vec<4, T, Q> Pi0 = floor(Position);	// Integer part for indexing

  213. 		vec<4, T, Q> Pi1 = Pi0 + T(1);		// Integer part + 1

  214. 		Pi0 = mod(Pi0, vec<4, T, Q>(289));

  215. 		Pi1 = mod(Pi1, vec<4, T, Q>(289));

  216. 		vec<4, T, Q> Pf0 = fract(Position);	// Fractional part for interpolation

  217. 		vec<4, T, Q> Pf1 = Pf0 - T(1);		// Fractional part - 1.0

  218. 		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);

  219. 		vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);

  220. 		vec<4, T, Q> iz0(Pi0.z);

  221. 		vec<4, T, Q> iz1(Pi1.z);

  222. 		vec<4, T, Q> iw0(Pi0.w);

  223. 		vec<4, T, Q> iw1(Pi1.w);

  224. 

  225. 		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);

  226. 		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);

  227. 		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);

  228. 		vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0);

  229. 		vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1);

  230. 		vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0);

  231. 		vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1);

  232. 

  233. 		vec<4, T, Q> gx00 = ixy00 / T(7);

  234. 		vec<4, T, Q> gy00 = floor(gx00) / T(7);

  235. 		vec<4, T, Q> gz00 = floor(gy00) / T(6);

  236. 		gx00 = fract(gx00) - T(0.5);

  237. 		gy00 = fract(gy00) - T(0.5);

  238. 		gz00 = fract(gz00) - T(0.5);

  239. 		vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);

  240. 		vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0.0));

  241. 		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));

  242. 		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));

  243. 

  244. 		vec<4, T, Q> gx01 = ixy01 / T(7);

  245. 		vec<4, T, Q> gy01 = floor(gx01) / T(7);

  246. 		vec<4, T, Q> gz01 = floor(gy01) / T(6);

  247. 		gx01 = fract(gx01) - T(0.5);

  248. 		gy01 = fract(gy01) - T(0.5);

  249. 		gz01 = fract(gz01) - T(0.5);

  250. 		vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);

  251. 		vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0));

  252. 		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));

  253. 		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));

  254. 

  255. 		vec<4, T, Q> gx10 = ixy10 / T(7);

  256. 		vec<4, T, Q> gy10 = floor(gx10) / T(7);

  257. 		vec<4, T, Q> gz10 = floor(gy10) / T(6);

  258. 		gx10 = fract(gx10) - T(0.5);

  259. 		gy10 = fract(gy10) - T(0.5);

  260. 		gz10 = fract(gz10) - T(0.5);

  261. 		vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);

  262. 		vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0));

  263. 		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));

  264. 		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));

  265. 

  266. 		vec<4, T, Q> gx11 = ixy11 / T(7);

  267. 		vec<4, T, Q> gy11 = floor(gx11) / T(7);

  268. 		vec<4, T, Q> gz11 = floor(gy11) / T(6);

  269. 		gx11 = fract(gx11) - T(0.5);

  270. 		gy11 = fract(gy11) - T(0.5);

  271. 		gz11 = fract(gz11) - T(0.5);

  272. 		vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);

  273. 		vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(0.0));

  274. 		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));

  275. 		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));

  276. 

  277. 		vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x);

  278. 		vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y);

  279. 		vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z);

  280. 		vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w);

  281. 		vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x);

  282. 		vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y);

  283. 		vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z);

  284. 		vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w);

  285. 		vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x);

  286. 		vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y);

  287. 		vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z);

  288. 		vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w);

  289. 		vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x);

  290. 		vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y);

  291. 		vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z);

  292. 		vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w);

  293. 

  294. 		vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));

  295. 		g0000 *= norm00.x;

  296. 		g0100 *= norm00.y;

  297. 		g1000 *= norm00.z;

  298. 		g1100 *= norm00.w;

  299. 

  300. 		vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));

  301. 		g0001 *= norm01.x;

  302. 		g0101 *= norm01.y;

  303. 		g1001 *= norm01.z;

  304. 		g1101 *= norm01.w;

  305. 

  306. 		vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));

  307. 		g0010 *= norm10.x;

  308. 		g0110 *= norm10.y;

  309. 		g1010 *= norm10.z;

  310. 		g1110 *= norm10.w;

  311. 

  312. 		vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));

  313. 		g0011 *= norm11.x;

  314. 		g0111 *= norm11.y;

  315. 		g1011 *= norm11.z;

  316. 		g1111 *= norm11.w;

  317. 

  318. 		T n0000 = dot(g0000, Pf0);

  319. 		T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));

  320. 		T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));

  321. 		T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));

  322. 		T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));

  323. 		T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));

  324. 		T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));

  325. 		T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));

  326. 		T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));

  327. 		T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));

  328. 		T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));

  329. 		T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));

  330. 		T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));

  331. 		T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));

  332. 		T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));

  333. 		T n1111 = dot(g1111, Pf1);

  334. 

  335. 		vec<4, T, Q> fade_xyzw = detail::fade(Pf0);

  336. 		vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w);

  337. 		vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w);

  338. 		vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z);

  339. 		vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y);

  340. 		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);

  341. 		return T(2.2) * n_xyzw;

  342. 	}

  343. 

  344. 	// Classic Perlin noise, periodic variant

  345. 	template<typename T, qualifier Q>

  346. 	GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position, vec<2, T, Q> const& rep)

  347. 	{

  348. 		vec<4, T, Q> Pi = floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);

  349. 		vec<4, T, Q> Pf = fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);

  350. 		Pi = mod(Pi, vec<4, T, Q>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period

  351. 		Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation

  352. 		vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z);

  353. 		vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w);

  354. 		vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z);

  355. 		vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w);

  356. 

  357. 		vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy);

  358. 

  359. 		vec<4, T, Q> gx = static_cast<T>(2) * fract(i / T(41)) - T(1);

  360. 		vec<4, T, Q> gy = abs(gx) - T(0.5);

  361. 		vec<4, T, Q> tx = floor(gx + T(0.5));

  362. 		gx = gx - tx;

  363. 

  364. 		vec<2, T, Q> g00(gx.x, gy.x);

  365. 		vec<2, T, Q> g10(gx.y, gy.y);

  366. 		vec<2, T, Q> g01(gx.z, gy.z);

  367. 		vec<2, T, Q> g11(gx.w, gy.w);

  368. 

  369. 		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));

  370. 		g00 *= norm.x;

  371. 		g01 *= norm.y;

  372. 		g10 *= norm.z;

  373. 		g11 *= norm.w;

  374. 

  375. 		T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x));

  376. 		T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y));

  377. 		T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z));

  378. 		T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w));

  379. 

  380. 		vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y));

  381. 		vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x);

  382. 		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);

  383. 		return T(2.3) * n_xy;

  384. 	}

  385. 

  386. 	// Classic Perlin noise, periodic variant

  387. 	template<typename T, qualifier Q>

  388. 	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position, vec<3, T, Q> const& rep)

  389. 	{

  390. 		vec<3, T, Q> Pi0 = mod(floor(Position), rep); // Integer part, modulo period

  391. 		vec<3, T, Q> Pi1 = mod(Pi0 + vec<3, T, Q>(T(1)), rep); // Integer part + 1, mod period

  392. 		Pi0 = mod(Pi0, vec<3, T, Q>(289));

  393. 		Pi1 = mod(Pi1, vec<3, T, Q>(289));

  394. 		vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation

  395. 		vec<3, T, Q> Pf1 = Pf0 - vec<3, T, Q>(T(1)); // Fractional part - 1.0

  396. 		vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);

  397. 		vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);

  398. 		vec<4, T, Q> iz0(Pi0.z);

  399. 		vec<4, T, Q> iz1(Pi1.z);

  400. 

  401. 		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);

  402. 		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);

  403. 		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);

  404. 

  405. 		vec<4, T, Q> gx0 = ixy0 / T(7);

  406. 		vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5);

  407. 		gx0 = fract(gx0);

  408. 		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);

  409. 		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0));

  410. 		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));

  411. 		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));

  412. 

  413. 		vec<4, T, Q> gx1 = ixy1 / T(7);

  414. 		vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5);

  415. 		gx1 = fract(gx1);

  416. 		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);

  417. 		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(T(0)));

  418. 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));

  419. 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));

  420. 

  421. 		vec<3, T, Q> g000 = vec<3, T, Q>(gx0.x, gy0.x, gz0.x);

  422. 		vec<3, T, Q> g100 = vec<3, T, Q>(gx0.y, gy0.y, gz0.y);

  423. 		vec<3, T, Q> g010 = vec<3, T, Q>(gx0.z, gy0.z, gz0.z);

  424. 		vec<3, T, Q> g110 = vec<3, T, Q>(gx0.w, gy0.w, gz0.w);

  425. 		vec<3, T, Q> g001 = vec<3, T, Q>(gx1.x, gy1.x, gz1.x);

  426. 		vec<3, T, Q> g101 = vec<3, T, Q>(gx1.y, gy1.y, gz1.y);

  427. 		vec<3, T, Q> g011 = vec<3, T, Q>(gx1.z, gy1.z, gz1.z);

  428. 		vec<3, T, Q> g111 = vec<3, T, Q>(gx1.w, gy1.w, gz1.w);

  429. 

  430. 		vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));

  431. 		g000 *= norm0.x;

  432. 		g010 *= norm0.y;

  433. 		g100 *= norm0.z;

  434. 		g110 *= norm0.w;

  435. 		vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));

  436. 		g001 *= norm1.x;

  437. 		g011 *= norm1.y;

  438. 		g101 *= norm1.z;

  439. 		g111 *= norm1.w;

  440. 

  441. 		T n000 = dot(g000, Pf0);

  442. 		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));

  443. 		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));

  444. 		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));

  445. 		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));

  446. 		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));

  447. 		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));

  448. 		T n111 = dot(g111, Pf1);

  449. 

  450. 		vec<3, T, Q> fade_xyz = detail::fade(Pf0);

  451. 		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);

  452. 		vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);

  453. 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);

  454. 		return T(2.2) * n_xyz;

  455. 	}

  456. 

  457. 	// Classic Perlin noise, periodic version

  458. 	template<typename T, qualifier Q>

  459. 	GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position, vec<4, T, Q> const& rep)

  460. 	{

  461. 		vec<4, T, Q> Pi0 = mod(floor(Position), rep); // Integer part modulo rep

  462. 		vec<4, T, Q> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep

  463. 		vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation

  464. 		vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0

  465. 		vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);

  466. 		vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);

  467. 		vec<4, T, Q> iz0(Pi0.z);

  468. 		vec<4, T, Q> iz1(Pi1.z);

  469. 		vec<4, T, Q> iw0(Pi0.w);

  470. 		vec<4, T, Q> iw1(Pi1.w);

  471. 

  472. 		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);

  473. 		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);

  474. 		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);

  475. 		vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0);

  476. 		vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1);

  477. 		vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0);

  478. 		vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1);

  479. 

  480. 		vec<4, T, Q> gx00 = ixy00 / T(7);

  481. 		vec<4, T, Q> gy00 = floor(gx00) / T(7);

  482. 		vec<4, T, Q> gz00 = floor(gy00) / T(6);

  483. 		gx00 = fract(gx00) - T(0.5);

  484. 		gy00 = fract(gy00) - T(0.5);

  485. 		gz00 = fract(gz00) - T(0.5);

  486. 		vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);

  487. 		vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0));

  488. 		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));

  489. 		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));

  490. 

  491. 		vec<4, T, Q> gx01 = ixy01 / T(7);

  492. 		vec<4, T, Q> gy01 = floor(gx01) / T(7);

  493. 		vec<4, T, Q> gz01 = floor(gy01) / T(6);

  494. 		gx01 = fract(gx01) - T(0.5);

  495. 		gy01 = fract(gy01) - T(0.5);

  496. 		gz01 = fract(gz01) - T(0.5);

  497. 		vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);

  498. 		vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0));

  499. 		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));

  500. 		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));

  501. 

  502. 		vec<4, T, Q> gx10 = ixy10 / T(7);

  503. 		vec<4, T, Q> gy10 = floor(gx10) / T(7);

  504. 		vec<4, T, Q> gz10 = floor(gy10) / T(6);

  505. 		gx10 = fract(gx10) - T(0.5);

  506. 		gy10 = fract(gy10) - T(0.5);

  507. 		gz10 = fract(gz10) - T(0.5);

  508. 		vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);

  509. 		vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0.0));

  510. 		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));

  511. 		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));

  512. 

  513. 		vec<4, T, Q> gx11 = ixy11 / T(7);

  514. 		vec<4, T, Q> gy11 = floor(gx11) / T(7);

  515. 		vec<4, T, Q> gz11 = floor(gy11) / T(6);

  516. 		gx11 = fract(gx11) - T(0.5);

  517. 		gy11 = fract(gy11) - T(0.5);

  518. 		gz11 = fract(gz11) - T(0.5);

  519. 		vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);

  520. 		vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(T(0)));

  521. 		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));

  522. 		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));

  523. 

  524. 		vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x);

  525. 		vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y);

  526. 		vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z);

  527. 		vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w);

  528. 		vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x);

  529. 		vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y);

  530. 		vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z);

  531. 		vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w);

  532. 		vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x);

  533. 		vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y);

  534. 		vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z);

  535. 		vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w);

  536. 		vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x);

  537. 		vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y);

  538. 		vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z);

  539. 		vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w);

  540. 

  541. 		vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));

  542. 		g0000 *= norm00.x;

  543. 		g0100 *= norm00.y;

  544. 		g1000 *= norm00.z;

  545. 		g1100 *= norm00.w;

  546. 

  547. 		vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));

  548. 		g0001 *= norm01.x;

  549. 		g0101 *= norm01.y;

  550. 		g1001 *= norm01.z;

  551. 		g1101 *= norm01.w;

  552. 

  553. 		vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));

  554. 		g0010 *= norm10.x;

  555. 		g0110 *= norm10.y;

  556. 		g1010 *= norm10.z;

  557. 		g1110 *= norm10.w;

  558. 

  559. 		vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));

  560. 		g0011 *= norm11.x;

  561. 		g0111 *= norm11.y;

  562. 		g1011 *= norm11.z;

  563. 		g1111 *= norm11.w;

  564. 

  565. 		T n0000 = dot(g0000, Pf0);

  566. 		T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));

  567. 		T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));

  568. 		T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));

  569. 		T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));

  570. 		T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));

  571. 		T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));

  572. 		T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));

  573. 		T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));

  574. 		T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));

  575. 		T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));

  576. 		T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));

  577. 		T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));

  578. 		T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));

  579. 		T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));

  580. 		T n1111 = dot(g1111, Pf1);

  581. 

  582. 		vec<4, T, Q> fade_xyzw = detail::fade(Pf0);

  583. 		vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w);

  584. 		vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w);

  585. 		vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z);

  586. 		vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y);

  587. 		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);

  588. 		return T(2.2) * n_xyzw;

  589. 	}

  590. 

  591. 	template<typename T, qualifier Q>

  592. 	GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, Q> const& v)

  593. 	{

  594. 		vec<4, T, Q> const C = vec<4, T, Q>(

  595. 			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0

  596. 			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)

  597. 			T(-0.577350269189626),	// -1.0 + 2.0 * C.x

  598. 			T( 0.024390243902439)); //  1.0 / 41.0

  599. 

  600. 		// First corner

  601. 		vec<2, T, Q> i  = floor(v + dot(v, vec<2, T, Q>(C[1])));

  602. 		vec<2, T, Q> x0 = v -   i + dot(i, vec<2, T, Q>(C[0]));

  603. 

  604. 		// Other corners

  605. 		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0

  606. 		//i1.y = 1.0 - i1.x;

  607. 		vec<2, T, Q> i1 = (x0.x > x0.y) ? vec<2, T, Q>(1, 0) : vec<2, T, Q>(0, 1);

  608. 		// x0 = x0 - 0.0 + 0.0 * C.xx ;

  609. 		// x1 = x0 - i1 + 1.0 * C.xx ;

  610. 		// x2 = x0 - 1.0 + 2.0 * C.xx ;

  611. 		vec<4, T, Q> x12 = vec<4, T, Q>(x0.x, x0.y, x0.x, x0.y) + vec<4, T, Q>(C.x, C.x, C.z, C.z);

  612. 		x12 = vec<4, T, Q>(vec<2, T, Q>(x12) - i1, x12.z, x12.w);

  613. 

  614. 		// Permutations

  615. 		i = mod(i, vec<2, T, Q>(289)); // Avoid truncation effects in permutation

  616. 		vec<3, T, Q> p = detail::permute(

  617. 			detail::permute(i.y + vec<3, T, Q>(T(0), i1.y, T(1)))

  618. 			+ i.x + vec<3, T, Q>(T(0), i1.x, T(1)));

  619. 

  620. 		vec<3, T, Q> m = max(vec<3, T, Q>(0.5) - vec<3, T, Q>(

  621. 			dot(x0, x0),

  622. 			dot(vec<2, T, Q>(x12.x, x12.y), vec<2, T, Q>(x12.x, x12.y)),

  623. 			dot(vec<2, T, Q>(x12.z, x12.w), vec<2, T, Q>(x12.z, x12.w))), vec<3, T, Q>(0));

  624. 		m = m * m ;

  625. 		m = m * m ;

  626. 

  627. 		// Gradients: 41 points uniformly over a line, mapped onto a diamond.

  628. 		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)

  629. 

  630. 		vec<3, T, Q> x = static_cast<T>(2) * fract(p * C.w) - T(1);

  631. 		vec<3, T, Q> h = abs(x) - T(0.5);

  632. 		vec<3, T, Q> ox = floor(x + T(0.5));

  633. 		vec<3, T, Q> a0 = x - ox;

  634. 

  635. 		// Normalise gradients implicitly by scaling m

  636. 		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );

  637. 		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);

  638. 

  639. 		// Compute final noise value at P

  640. 		vec<3, T, Q> g;

  641. 		g.x  = a0.x  * x0.x  + h.x  * x0.y;

  642. 		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;

  643. 		g.y = a0.y * x12.x + h.y * x12.y;

  644. 		g.z = a0.z * x12.z + h.z * x12.w;

  645. 		return T(130) * dot(m, g);

  646. 	}

  647. 

  648. 	template<typename T, qualifier Q>

  649. 	GLM_FUNC_QUALIFIER T simplex(vec<3, T, Q> const& v)

  650. 	{

  651. 		vec<2, T, Q> const C(1.0 / 6.0, 1.0 / 3.0);

  652. 		vec<4, T, Q> const D(0.0, 0.5, 1.0, 2.0);

  653. 

  654. 		// First corner

  655. 		vec<3, T, Q> i(floor(v + dot(v, vec<3, T, Q>(C.y))));

  656. 		vec<3, T, Q> x0(v - i + dot(i, vec<3, T, Q>(C.x)));

  657. 

  658. 		// Other corners

  659. 		vec<3, T, Q> g(step(vec<3, T, Q>(x0.y, x0.z, x0.x), x0));

  660. 		vec<3, T, Q> l(T(1) - g);

  661. 		vec<3, T, Q> i1(min(g, vec<3, T, Q>(l.z, l.x, l.y)));

  662. 		vec<3, T, Q> i2(max(g, vec<3, T, Q>(l.z, l.x, l.y)));

  663. 

  664. 		//   x0 = x0 - 0.0 + 0.0 * C.xxx;

  665. 		//   x1 = x0 - i1  + 1.0 * C.xxx;

  666. 		//   x2 = x0 - i2  + 2.0 * C.xxx;

  667. 		//   x3 = x0 - 1.0 + 3.0 * C.xxx;

  668. 		vec<3, T, Q> x1(x0 - i1 + C.x);

  669. 		vec<3, T, Q> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y

  670. 		vec<3, T, Q> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y

  671. 

  672. 		// Permutations

  673. 		i = detail::mod289(i);

  674. 		vec<4, T, Q> p(detail::permute(detail::permute(detail::permute(

  675. 			i.z + vec<4, T, Q>(T(0), i1.z, i2.z, T(1))) +

  676. 			i.y + vec<4, T, Q>(T(0), i1.y, i2.y, T(1))) +

  677. 			i.x + vec<4, T, Q>(T(0), i1.x, i2.x, T(1))));

  678. 

  679. 		// Gradients: 7x7 points over a square, mapped onto an octahedron.

  680. 		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)

  681. 		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0

  682. 		vec<3, T, Q> ns(n_ * vec<3, T, Q>(D.w, D.y, D.z) - vec<3, T, Q>(D.x, D.z, D.x));

  683. 

  684. 		vec<4, T, Q> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)

  685. 

  686. 		vec<4, T, Q> x_(floor(j * ns.z));

  687. 		vec<4, T, Q> y_(floor(j - T(7) * x_));    // mod(j,N)

  688. 

  689. 		vec<4, T, Q> x(x_ * ns.x + ns.y);

  690. 		vec<4, T, Q> y(y_ * ns.x + ns.y);

  691. 		vec<4, T, Q> h(T(1) - abs(x) - abs(y));

  692. 

  693. 		vec<4, T, Q> b0(x.x, x.y, y.x, y.y);

  694. 		vec<4, T, Q> b1(x.z, x.w, y.z, y.w);

  695. 

  696. 		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;

  697. 		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;

  698. 		vec<4, T, Q> s0(floor(b0) * T(2) + T(1));

  699. 		vec<4, T, Q> s1(floor(b1) * T(2) + T(1));

  700. 		vec<4, T, Q> sh(-step(h, vec<4, T, Q>(0.0)));

  701. 

  702. 		vec<4, T, Q> a0 = vec<4, T, Q>(b0.x, b0.z, b0.y, b0.w) + vec<4, T, Q>(s0.x, s0.z, s0.y, s0.w) * vec<4, T, Q>(sh.x, sh.x, sh.y, sh.y);

  703. 		vec<4, T, Q> a1 = vec<4, T, Q>(b1.x, b1.z, b1.y, b1.w) + vec<4, T, Q>(s1.x, s1.z, s1.y, s1.w) * vec<4, T, Q>(sh.z, sh.z, sh.w, sh.w);

  704. 

  705. 		vec<3, T, Q> p0(a0.x, a0.y, h.x);

  706. 		vec<3, T, Q> p1(a0.z, a0.w, h.y);

  707. 		vec<3, T, Q> p2(a1.x, a1.y, h.z);

  708. 		vec<3, T, Q> p3(a1.z, a1.w, h.w);

  709. 

  710. 		// Normalise gradients

  711. 		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));

  712. 		p0 *= norm.x;

  713. 		p1 *= norm.y;

  714. 		p2 *= norm.z;

  715. 		p3 *= norm.w;

  716. 

  717. 		// Mix final noise value

  718. 		vec<4, T, Q> m = max(T(0.6) - vec<4, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec<4, T, Q>(0));

  719. 		m = m * m;

  720. 		return T(42) * dot(m * m, vec<4, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));

  721. 	}

  722. 

  723. 	template<typename T, qualifier Q>

  724. 	GLM_FUNC_QUALIFIER T simplex(vec<4, T, Q> const& v)

  725. 	{

  726. 		vec<4, T, Q> const C(

  727. 			0.138196601125011,  // (5 - sqrt(5))/20  G4

  728. 			0.276393202250021,  // 2 * G4

  729. 			0.414589803375032,  // 3 * G4

  730. 			-0.447213595499958); // -1 + 4 * G4

  731. 

  732. 		// (sqrt(5) - 1)/4 = F4, used once below

  733. 		T const F4 = static_cast<T>(0.309016994374947451);

  734. 

  735. 		// First corner

  736. 		vec<4, T, Q> i  = floor(v + dot(v, vec4(F4)));

  737. 		vec<4, T, Q> x0 = v -   i + dot(i, vec4(C.x));

  738. 

  739. 		// Other corners

  740. 

  741. 		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)

  742. 		vec<4, T, Q> i0;

  743. 		vec<3, T, Q> isX = step(vec<3, T, Q>(x0.y, x0.z, x0.w), vec<3, T, Q>(x0.x));

  744. 		vec<3, T, Q> isYZ = step(vec<3, T, Q>(x0.z, x0.w, x0.w), vec<3, T, Q>(x0.y, x0.y, x0.z));

  745. 		//  i0.x = dot(isX, vec3(1.0));

  746. 		//i0.x = isX.x + isX.y + isX.z;

  747. 		//i0.yzw = static_cast<T>(1) - isX;

  748. 		i0 = vec<4, T, Q>(isX.x + isX.y + isX.z, T(1) - isX);

  749. 		//  i0.y += dot(isYZ.xy, vec2(1.0));

  750. 		i0.y += isYZ.x + isYZ.y;

  751. 		//i0.zw += 1.0 - vec<2, T, Q>(isYZ.x, isYZ.y);

  752. 		i0.z += static_cast<T>(1) - isYZ.x;

  753. 		i0.w += static_cast<T>(1) - isYZ.y;

  754. 		i0.z += isYZ.z;

  755. 		i0.w += static_cast<T>(1) - isYZ.z;

  756. 

  757. 		// i0 now contains the unique values 0,1,2,3 in each channel

  758. 		vec<4, T, Q> i3 = clamp(i0, T(0), T(1));

  759. 		vec<4, T, Q> i2 = clamp(i0 - T(1), T(0), T(1));

  760. 		vec<4, T, Q> i1 = clamp(i0 - T(2), T(0), T(1));

  761. 

  762. 		//  x0 = x0 - 0.0 + 0.0 * C.xxxx

  763. 		//  x1 = x0 - i1  + 0.0 * C.xxxx

  764. 		//  x2 = x0 - i2  + 0.0 * C.xxxx

  765. 		//  x3 = x0 - i3  + 0.0 * C.xxxx

  766. 		//  x4 = x0 - 1.0 + 4.0 * C.xxxx

  767. 		vec<4, T, Q> x1 = x0 - i1 + C.x;

  768. 		vec<4, T, Q> x2 = x0 - i2 + C.y;

  769. 		vec<4, T, Q> x3 = x0 - i3 + C.z;

  770. 		vec<4, T, Q> x4 = x0 + C.w;

  771. 

  772. 		// Permutations

  773. 		i = mod(i, vec<4, T, Q>(289));

  774. 		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);

  775. 		vec<4, T, Q> j1 = detail::permute(detail::permute(detail::permute(detail::permute(

  776. 			i.w + vec<4, T, Q>(i1.w, i2.w, i3.w, T(1))) +

  777. 			i.z + vec<4, T, Q>(i1.z, i2.z, i3.z, T(1))) +

  778. 			i.y + vec<4, T, Q>(i1.y, i2.y, i3.y, T(1))) +

  779. 			i.x + vec<4, T, Q>(i1.x, i2.x, i3.x, T(1)));

  780. 

  781. 		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope

  782. 		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.

  783. 		vec<4, T, Q> ip = vec<4, T, Q>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));

  784. 

  785. 		vec<4, T, Q> p0 = gtc::grad4(j0,   ip);

  786. 		vec<4, T, Q> p1 = gtc::grad4(j1.x, ip);

  787. 		vec<4, T, Q> p2 = gtc::grad4(j1.y, ip);

  788. 		vec<4, T, Q> p3 = gtc::grad4(j1.z, ip);

  789. 		vec<4, T, Q> p4 = gtc::grad4(j1.w, ip);

  790. 

  791. 		// Normalise gradients

  792. 		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));

  793. 		p0 *= norm.x;

  794. 		p1 *= norm.y;

  795. 		p2 *= norm.z;

  796. 		p3 *= norm.w;

  797. 		p4 *= detail::taylorInvSqrt(dot(p4, p4));

  798. 

  799. 		// Mix contributions from the five corners

  800. 		vec<3, T, Q> m0 = max(T(0.6) - vec<3, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec<3, T, Q>(0));

  801. 		vec<2, T, Q> m1 = max(T(0.6) - vec<2, T, Q>(dot(x3, x3), dot(x4, x4)             ), vec<2, T, Q>(0));

  802. 		m0 = m0 * m0;

  803. 		m1 = m1 * m1;

  804. 		return T(49) *

  805. 			(dot(m0 * m0, vec<3, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +

  806. 			dot(m1 * m1, vec<2, T, Q>(dot(p3, x3), dot(p4, x4))));

  807. 	}

  808. }//namespace glm