HLSL translations v1

Author: domportera

src/hlsl/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2022 Domenic Portera
+As this contains many translations of existing works, those works' original licenses can be found in their respective subfolders. 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/hlsl/README.md

@@ -0,0 +1,7 @@
+[Source repo where this HLSL port is maintained](https://github.com/domportera/hlsl-noise)
+
+Ports of [this library](https://github.com/ashima/webgl-noise) to HLSL are also included. [This fork](https://github.com/stegu/webgl-noise) (also by the author of psrdnoise) is your best source of information about these functions.
+
+These have been modified for compatibility with HLSL (of course), removing redundant code and renaming things where necessary so that you may #include to your heart's content without worrying about function redefinition errors. I've even included a "noise-include-all.hlsl" for your convenience if you'd like to play around.
+
+When using this, ensure you are using a compiler that supports macros. If you're not, you may need to edit the `special-math.hlsl` file to convert the `mod` macro into several explicit overloaded functions.

src/hlsl/ashima/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2011 by Ashima Arts (Simplex noise)
+Copyright (C) 2011-2016 by Stefan Gustavson (Classic noise and others)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

src/hlsl/ashima/README.md

@@ -0,0 +1,35 @@
+The wiki for this repository contains more information.
+
+Simplex noise functions are (C) Ashima Arts and Stefan Gustavson
+Classic noise functions are (C) Stefan Gustavson
+Cellular noise functions are (C) Stefan Gustavson
+The "psrdnoise" functions are (C) Stefan Gustavson
+
+Source code for the noise functions is released under the
+conditions of the MIT license. See the file LICENSE for details.
+
+The simplex noise functions follow Ken Perlin's original idea,
+more clearly explained in Stefan Gustavson's paper
+"Simplex noise demystified"
+http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+but without using any uniform arrays or texture engines.
+
+Many other noise implementations make heavy use of a
+texture lookup table and are texture bandwidth limited.
+The noise functions in this library, however, are completely
+self contained with no dependency on external data.
+While not quite as fast as texture-based implementations
+on typical current desktop GPUs, they are more scalable to
+massive parallelism and much more convenient to use, and
+they can make good use of unused ALU resources when run
+concurrently with a typical texture-intensive rendering.
+
+2016-05-13: Ashima Arts now seems to be defunct as a company
+(their website and email addresses have ceased to function)
+so I cloned this repository to:
+
+https://github.com/stegu/webgl-noise/
+
+This site is heavily linked from all over the place on the
+Internet, so I (Stefan Gustavson) will keep updating both sites
+for the foreseeable future as the (apparently) sole maintainer.

src/hlsl/ashima/cellular2D.hlsl

@@ -0,0 +1,53 @@
+// Cellular noise ("Worley noise") in 2D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+#include "../common/stegu-math.hlsl"
+
+// Cellular noise, returning F1 and F2 in a float2.
+// Standard 3x3 search window for good F1 and F2 values
+float2 cellular(float2 P) {
+#define K 0.142857142857 // 1/7
+#define Ko 0.428571428571 // 3/7
+#define jitter2D 1.0 // Less gives more regular pattern
+	float2 Pi = mod289(floor(P));
+ 	float2 Pf = frac(P);
+	float3 oi = float3(-1.0, 0.0, 1.0);
+	float3 of = float3(-0.5, 0.5, 1.5);
+	float3 px = permute(Pi.x + oi);
+	float3 p = permute(px.x + Pi.y + oi); // p11, p12, p13
+	float3 ox = frac(p*K) - Ko;
+	float3 oy = mod7(floor(p*K))*K - Ko;
+	float3 dx = Pf.x + 0.5 + jitter2D*ox;
+	float3 dy = Pf.y - of + jitter2D*oy;
+	float3 d1 = dx * dx + dy * dy; // d11, d12 and d13, squared
+	p = permute(px.y + Pi.y + oi); // p21, p22, p23
+	ox = frac(p*K) - Ko;
+	oy = mod7(floor(p*K))*K - Ko;
+	dx = Pf.x - 0.5 + jitter2D*ox;
+	dy = Pf.y - of + jitter2D*oy;
+	float3 d2 = dx * dx + dy * dy; // d21, d22 and d23, squared
+	p = permute(px.z + Pi.y + oi); // p31, p32, p33
+	ox = frac(p*K) - Ko;
+	oy = mod7(floor(p*K))*K - Ko;
+	dx = Pf.x - 1.5 + jitter2D*ox;
+	dy = Pf.y - of + jitter2D*oy;
+	float3 d3 = dx * dx + dy * dy; // d31, d32 and d33, squared
+	// Sort out the two smallest distances (F1, F2)
+	float3 d1a = min(d1, d2);
+	d2 = max(d1, d2); // Swap to keep candidates for F2
+	d2 = min(d2, d3); // neither F1 nor F2 are now in d3
+	d1 = min(d1a, d2); // F1 is now in d1
+	d2 = max(d1a, d2); // Swap to keep candidates for F2
+	d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; // Swap if smaller
+	d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; // F1 is in d1.x
+	d1.yz = min(d1.yz, d2.yz); // F2 is now not in d2.yz
+	d1.y = min(d1.y, d1.z); // nor in  d1.z
+	d1.y = min(d1.y, d2.x); // F2 is in d1.y, we're done.
+	return sqrt(d1.xy);
+}
+
+// Adapted to HLSL by Dom Portera, published under the MIT license
+// https://github.com/domportera/hlsl-noise

src/hlsl/ashima/cellular2x2.hlsl

@@ -0,0 +1,48 @@
+// Cellular noise ("Worley noise") in 2D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+#include "../common/stegu-math.hlsl"
+
+// Cellular noise, returning F1 and F2 in a float2.
+// Speeded up by using 2x2 search window instead of 3x3,
+// at the expense of some strong pattern artifacts.
+// F2 is often wrong and has sharp discontinuities.
+// If you need a smooth F2, use the slower 3x3 version.
+// F1 is sometimes wrong, too, but OK for most purposes.
+float2 cellular2x2(float2 P) {
+#define K 0.142857142857 // 1/7
+#define K2_2x2 0.0714285714285 // K/2
+#define jitter2x2 0.8 // jitter 1.0 makes F1 wrong more often
+	float2 Pi = mod289(floor(P));
+ 	float2 Pf = frac(P);
+	float4 Pfx = Pf.x + float4(-0.5, -1.5, -0.5, -1.5);
+	float4 Pfy = Pf.y + float4(-0.5, -0.5, -1.5, -1.5);
+	float4 p = permute(Pi.x + float4(0.0, 1.0, 0.0, 1.0));
+	p = permute(p + Pi.y + float4(0.0, 0.0, 1.0, 1.0));
+	float4 ox = mod7(p)*K+K2_2x2;
+	float4 oy = mod7(floor(p*K))*K+K2_2x2;
+	float4 dx = Pfx + jitter2x2*ox;
+	float4 dy = Pfy + jitter2x2*oy;
+	float4 d = dx * dx + dy * dy; // d11, d12, d21 and d22, squared
+	// Sort out the two smallest distances
+#if 0
+	// Cheat and pick only F1
+	d.xy = min(d.xy, d.zw);
+	d.x = min(d.x, d.y);
+	return float2(sqrt(d.x)); // F1 duplicated, F2 not computed
+#else
+	// Do it right and find both F1 and F2
+	d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap if smaller
+	d.xz = (d.x < d.z) ? d.xz : d.zx;
+	d.xw = (d.x < d.w) ? d.xw : d.wx;
+	d.y = min(d.y, d.z);
+	d.y = min(d.y, d.w);
+	return sqrt(d.xy);
+#endif
+}
+
+// Adapted to HLSL by Dom Portera, published under the MIT license
+// https://github.com/domportera/hlsl-noise

src/hlsl/ashima/cellular2x2x2.hlsl

@@ -0,0 +1,67 @@
+// Cellular noise ("Worley noise") in 3D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+#include "../common/stegu-math.hlsl"
+
+// Cellular noise, returning F1 and F2 in a float2.
+// Speeded up by using 2x2x2 search window instead of 3x3x3,
+// at the expense of some pattern artifacts.
+// F2 is often wrong and has sharp discontinuities.
+// If you need a good F2, use the slower 3x3x3 version.
+float2 cellular2x2x2(float3 P) {
+#define K 0.142857142857 // 1/7
+#define Ko 0.428571428571 // 1/2-K/2
+#define K2_2x2x2 0.020408163265306 // 1/(7*7)
+#define Kz 0.166666666667 // 1/6
+#define Kzo 0.416666666667 // 1/2-1/6*2
+#define jitter2x2x2 0.8 // smaller jitter gives less errors in F2
+	float3 Pi = mod289(floor(P));
+ 	float3 Pf = frac(P);
+	float4 Pfx = Pf.x + float4(0.0, -1.0, 0.0, -1.0);
+	float4 Pfy = Pf.y + float4(0.0, 0.0, -1.0, -1.0);
+	float4 p = permute(Pi.x + float4(0.0, 1.0, 0.0, 1.0));
+	p = permute(p + Pi.y + float4(0.0, 0.0, 1.0, 1.0));
+	float4 p1 = permute(p + Pi.z); // z+0
+	float4 p2 = permute(p + Pi.z + float4(1.0, 1.0, 1.0, 1.0)); // z+1
+	float4 ox1 = frac(p1*K) - Ko;
+	float4 oy1 = mod7(floor(p1*K))*K - Ko;
+	float4 oz1 = floor(p1*K2_2x2x2)*Kz - Kzo; // p1 < 289 guaranteed
+	float4 ox2 = frac(p2*K) - Ko;
+	float4 oy2 = mod7(floor(p2*K))*K - Ko;
+	float4 oz2 = floor(p2*K2_2x2x2)*Kz - Kzo;
+	float4 dx1 = Pfx + jitter2x2x2*ox1;
+	float4 dy1 = Pfy + jitter2x2x2*oy1;
+	float4 dz1 = Pf.z + jitter2x2x2*oz1;
+	float4 dx2 = Pfx + jitter2x2x2*ox2;
+	float4 dy2 = Pfy + jitter2x2x2*oy2;
+	float4 dz2 = Pf.z - 1.0 + jitter2x2x2*oz2;
+	float4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
+	float4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1
+
+	// Sort out the two smallest distances (F1, F2)
+#if 0
+	// Cheat and sort out only F1
+	d1 = min(d1, d2);
+	d1.xy = min(d1.xy, d1.wz);
+	d1.x = min(d1.x, d1.y);
+	return float2(sqrt(d1.x));
+#else
+	// Do it right and sort out both F1 and F2
+	float4 d = min(d1,d2); // F1 is now in d
+	d2 = max(d1,d2); // Make sure we keep all candidates for F2
+	d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap smallest to d.x
+	d.xz = (d.x < d.z) ? d.xz : d.zx;
+	d.xw = (d.x < d.w) ? d.xw : d.wx; // F1 is now in d.x
+	d.yzw = min(d.yzw, d2.yzw); // F2 now not in d2.yzw
+	d.y = min(d.y, d.z); // nor in d.z
+	d.y = min(d.y, d.w); // nor in d.w
+	d.y = min(d.y, d2.x); // F2 is now in d.y
+	return sqrt(d.xy); // F1 and F2
+#endif
+}
+
+// Adapted to HLSL by Dom Portera, published under the MIT license
+// https://github.com/domportera/hlsl-noise