Skip to content

Instantly share code, notes, and snippets.

@jarodium

jarodium/mail.php

Last active November 11, 2018 14:45
Show Gist options
  • Save jarodium/bb8da125805c6e719d2ae8fa6ab82294 to your computer and use it in GitHub Desktop.
Save jarodium/bb8da125805c6e719d2ae8fa6ab82294 to your computer and use it in GitHub Desktop.
Download ZIP
Open Simplex implementation in php
Raw
mail.php
<?php
use ajf\TypedArrays\Uint8Array;
use ajf\TypedArrays\Float32Array;
class openSimplexNoise {
/*
* Class Open Simplex
* Direct PHP implementation based on Jonas Wagner ( https://github.com/jwagner/simplex-noise.js/blob/master/simplex-noise.js )
* implementation for javascript which is based on example code by Stefan Gustavson ([email protected]).
* eith Optimisations by Peter Eastman ([email protected]).
* Better rank ordering method by Stefan Gustavson in 2012.
* Copyright (c) 2018 Pedro Heliodoro
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.
*/
private $F2;
private $G2;
private $F3;
private $G3;
private $F4;
private $G4;
function __construct($randomOrSeed) {
$this->F2 = 0.5 * (sqrt(3.0) - 1.0);
$this->G2 = (3.0 - sqrt(3.0)) / 6.0;
$this->F3 = 1.0 / 3.0;
$this->G3 = 1.0 / 6.0;
$this->F4 = (sqrt(5.0) - 1.0) / 4.0;
$this->G4 = (5.0 - sqrt(5.0)) / 20.0;
$random;
if (is_callable($randomOrSeed)) {
$random = call_user_func($randomOrSeed);
}
else if ($randomOrSeed) {
$random = $this->alea($randomOrSeed);
} else {
$random = mt_srand();
}
$this->p = $this->buildPermutationTable($random);
$this->perm = new Uint8Array(512);
$this->permMod12 = new Uint8Array(512);
for ($i = 0; $i < 512; $i++) {
$this->perm[$i] = $this->p[$i & 255];
$this->permMod12[$i] = $this->perm[$i] % 12;
}
$this->grad3 = new Float32Array(
[1, 1, 0,-1, 1, 0,1, -1, 0,-1, -1, 0,1, 0, 1,-1, 0, 1,1, 0, -1,
-1, 0, -1,0, 1, 1,0, -1, 1,0, 1, -1,0, -1, -1]);
$this->grad4 = new Float32Array(
[0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1,
0, -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1,
1, 0, 1, 1, 1, 0, 1, -1, 1, 0, -1, 1, 1, 0, -1, -1,
-1, 0, 1, 1, -1, 0, 1, -1, -1, 0, -1, 1, -1, 0, -1, -1,
1, 1, 0, 1, 1, 1, 0, -1, 1, -1, 0, 1, 1, -1, 0, -1,
-1, 1, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, -1,
1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1, 0,
-1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1, 0]);
//$this->_buildPermutationTable = $this->buildPermutationTable();
}
function noise2D($xin, $yin) {
$permMod12 = $this->permMod12;
$perm = $this->perm;
$grad3 = $this->grad3;
$n0 = 0; // Noise contributions from the three corners
$n1 = 0;
$n2 = 0;
// Skew the input space to determine which simplex cell we're in
$s = ($xin + $yin) * $this->F2; // Hairy factor for 2D
$i = floor($xin + $s);
$j = floor($yin + $s);
$t = ($i + $j) * $this->G2;
$X0 = $i - $t; // Unskew the cell origin back to (x,y) space
$Y0 = $j - $t;
$x0 = $xin - $X0; // The x,y distances from the cell origin
$y0 = $yin - $Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
$i1;
$j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if ($x0 > $y0) {
$i1 = 1;
$j1 = 0;
} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
else {
$i1 = 0;
$j1 = 1;
} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
$x1 = $x0 - $i1 + $this->G2; // Offsets for middle corner in (x,y) unskewed coords
$y1 = $y0 - $j1 + $this->G2;
$x2 = $x0 - 1.0 + 2.0 * $this->G2; // Offsets for last corner in (x,y) unskewed coords
$y2 = $y0 - 1.0 + 2.0 * $this->G2;
// Work out the hashed gradient indices of the three simplex corners
$ii = $i & 255;
$jj = $j & 255;
// Calculate the contribution from the three corners
$t0 = 0.5 - $x0 * $x0 - $y0 * $y0;
if ($t0 >= 0) {
$gi0 = $this->permMod12[$ii + $this->perm[$jj]] * 3;
$t0 *= $t0;
$n0 = $t0 * $t0 * ($this->grad3[$gi0] * $x0 + $grad3[$gi0 + 1] * $y0); // (x,y) of grad3 used for 2D gradient
}
$t1 = 0.5 - $x1 * $x1 - $y1 * $y1;
if ($t1 >= 0) {
$gi1 = $this->permMod12[$ii + $i1 + $this->perm[$jj + $j1]] * 3;
$t1 *= $t1;
$n1 = $t1 * $t1 * ($this->grad3[$gi1] * $x1 + $this->grad3[$gi1 + 1] * $y1);
}
$t2 = 0.5 - $x2 * $x2 - $y2 * $y2;
if ($t2 >= 0) {
$gi2 = $this->permMod12[$ii + 1 + $this->perm[$jj + 1]] * 3;
$t2 *= $t2;
$n2 = $t2 * $t2 * ($this->grad3[$gi2] * $x2 + $this->grad3[$gi2 + 1] * $y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70.0 * ($n0 + $n1 + $n2);
}
function noise3D($xin, $yin, $zin) {
$permMod12 = $this->permMod12;
$perm = $this->perm;
$grad3 = $this->grad3;
$n0;
$n1;
$n2;
$n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
$s = ($xin + $yin + $zin) * $this->F3; // Very nice and simple skew factor for 3D
$i = floor($xin + $s);
$j = floor($yin + $s);
$k = floor($zin + $s);
$t = ($i + $j + $k) * $this->G3;
$X0 = $i - $t; // Unskew the cell origin back to (x,y,z) space
$Y0 = $j - $t;
$Z0 = $k - $t;
$x0 = $xin - $X0; // The x,y,z distances from the cell origin
$y0 = $yin - $Y0;
$z0 = $zin - $Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
$i1;
$j1;
$k1; // Offsets for second corner of simplex in (i,j,k) coords
$i2;
$j2;
$k2; // Offsets for third corner of simplex in (i,j,k) coords
if ($x0 >= $y0) {
if ($y0 >= $z0) {
$i1 = 1;
$j1 = 0;
$k1 = 0;
$i2 = 1;
$j2 = 1;
$k2 = 0;
} // X Y Z order
else if ($x0 >= $z0) {
$i1 = 1;
$j1 = 0;
$k1 = 0;
$i2 = 1;
$j2 = 0;
$k2 = 1;
} // X Z Y order
else {
$i1 = 0;
$j1 = 0;
$k1 = 1;
$i2 = 1;
$j2 = 0;
$k2 = 1;
} // Z X Y order
}
else { // x0<y0
if ($y0 < $z0) {
$i1 = 0;
$j1 = 0;
$k1 = 1;
$i2 = 0;
$j2 = 1;
$k2 = 1;
} // Z Y X order
else if ($x0 < $z0) {
$i1 = 0;
$j1 = 1;
$k1 = 0;
$i2 = 0;
$j2 = 1;
$k2 = 1;
} // Y Z X order
else {
$i1 = 0;
$j1 = 1;
$k1 = 0;
$i2 = 1;
$j2 = 1;
$k2 = 0;
} // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
$x1 = $x0 - $i1 + $this->G3; // Offsets for second corner in (x,y,z) coords
$y1 = $y0 - $j1 + $this->G3;
$z1 = $z0 - $k1 + $this->G3;
$x2 = $x0 - $i2 + 2.0 * $this->G3; // Offsets for third corner in (x,y,z) coords
$y2 = $y0 - $j2 + 2.0 * $this->G3;
$z2 = $z0 - $k2 + 2.0 * $this->G3;
$x3 = $x0 - 1.0 + 3.0 * $this->G3; // Offsets for last corner in (x,y,z) coords
$y3 = $y0 - 1.0 + 3.0 * $this->G3;
$z3 = $z0 - 1.0 + 3.0 * $this->G3;
// Work out the hashed gradient indices of the four simplex corners
$ii = $i & 255;
$jj = $j & 255;
$kk = $k & 255;
// Calculate the contribution from the four corners
$t0 = 0.6 - $x0 * $x0 - $y0 * $y0 - $z0 * $z0;
if ($t0 < 0) $n0 = 0.0;
else {
$gi0 = $this->permMod12[$ii + $this->perm[$jj + $this->perm[$kk]]] * 3;
$t0 *= $t0;
$n0 = $t0 * $t0 * ($this->grad3[$gi0] * $x0 + $this->grad3[$gi0 + 1] * $y0 + $this->grad3[$gi0 + 2] * $z0);
}
$t1 = 0.6 - $x1 * $x1 - $y1 * $y1 - $z1 * $z1;
if ($t1 < 0) $n1 = 0.0;
else {
$gi1 = $this->permMod12[$ii + $i1 + $this->perm[$jj + $j1 + $this->perm[$kk + $k1]]] * 3;
$t1 *= $t1;
$n1 = $t1 * $t1 * ($this->grad3[$gi1] * $x1 + $this->grad3[$gi1 + 1] * $y1 + $this->grad3[$gi1 + 2] * $z1);
}
$t2 = 0.6 - $x2 * $x2 - $y2 * $y2 - $z2 * $z2;
if ($t2 < 0) $n2 = 0.0;
else {
$gi2 = $this->permMod12[$ii + $i2 + $this->perm[$jj + $j2 + $this->perm[$kk + $k2]]] * 3;
$t2 *= $t2;
$n2 = $t2 * $t2 * ($this->grad3[$gi2] * $x2 + $this->grad3[$gi2 + 1] * $y2 + $this->grad3[$gi2 + 2] * $z2);
}
$t3 = 0.6 - $x3 * $x3 - $y3 * $y3 - $z3 * $z3;
if ($t3 < 0) $n3 = 0.0;
else {
$gi3 = $this->permMod12[$ii + 1 + $this->perm[$jj + 1 + $this->perm[$kk + 1]]] * 3;
$t3 *= $t3;
$n3 = $t3 * $t3 * ($this->grad3[$gi3] * $x3 + $this->grad3[$gi3 + 1] * $y3 + $this->grad3[$gi3 + 2] * $z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0 * ($n0 + $n1 + $n2 + $n3);
}
function noise4D ($x, $y, $z, $w) {
$perm = $this->perm;
$grad4 = $this->grad4;
$n0;
$n1;
$n2;
$n3;
$n4; // Noise contributions from the five corners
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
$s = ($x + $y + $z + $w) * $this->F4; // Factor for 4D skewing
$i = floor($x + $s);
$j = floor($y + $s);
$k = floor($z + $s);
$l = floor($w + $s);
$t = ($i + $j + $k + $l) * $this->G4; // Factor for 4D unskewing
$X0 = $i - $t; // Unskew the cell origin back to (x,y,z,w) space
$Y0 = $j - $t;
$Z0 = $k - $t;
$W0 = $l - $t;
$x0 = $x - $X0; // The x,y,z,w distances from the cell origin
$y0 = $y - $Y0;
$z0 = $z - $Z0;
$w0 = $w - $W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// Six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to rank the numbers.
$rankx = 0;
$ranky = 0;
$rankz = 0;
$rankw = 0;
if ($x0 > $y0) $rankx++;
else $ranky++;
if ($x0 > $z0) $rankx++;
else $rankz++;
if ($x0 > $w0) $rankx++;
else $rankw++;
if ($y0 > $z0) $ranky++;
else $rankz++;
if ($y0 > $w0) $ranky++;
else $rankw++;
if ($z0 > $w0) $rankz++;
else $rankw++;
$i1;
$j1;
$k1;
$l1; // The integer offsets for the second simplex corner
$i2;
$j2;
$k2;
$l2; // The integer offsets for the third simplex corner
$i3;
$j3;
$k3;
$l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// Rank 3 denotes the largest coordinate.
$i1 = $rankx >= 3 ? 1 : 0;
$j1 = $ranky >= 3 ? 1 : 0;
$k1 = $rankz >= 3 ? 1 : 0;
$l1 = $rankw >= 3 ? 1 : 0;
// Rank 2 denotes the second largest coordinate.
$i2 = $rankx >= 2 ? 1 : 0;
$j2 = $ranky >= 2 ? 1 : 0;
$k2 = $rankz >= 2 ? 1 : 0;
$l2 = $rankw >= 2 ? 1 : 0;
// Rank 1 denotes the second smallest coordinate.
$i3 = $rankx >= 1 ? 1 : 0;
$j3 = $ranky >= 1 ? 1 : 0;
$k3 = $rankz >= 1 ? 1 : 0;
$l3 = $rankw >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to compute that.
$x1 = $x0 - $i1 + $this->G4; // Offsets for second corner in (x,y,z,w) coords
$y1 = $y0 - $j1 + $this->G4;
$z1 = $z0 - $k1 + $this->G4;
$w1 = $w0 - $l1 + $this->G4;
$x2 = $x0 - $i2 + 2.0 * $this->G4; // Offsets for third corner in (x,y,z,w) coords
$y2 = $y0 - $j2 + 2.0 * $this->G4;
$z2 = $z0 - $k2 + 2.0 * $this->G4;
$w2 = $w0 - $l2 + 2.0 * $this->G4;
$x3 = $x0 - $i3 + 3.0 * $this->G4; // Offsets for fourth corner in (x,y,z,w) coords
$y3 = $y0 - $j3 + 3.0 * $this->G4;
$z3 = $z0 - $k3 + 3.0 * $this->G4;
$w3 = $w0 - $l3 + 3.0 * $this->G4;
$x4 = $x0 - 1.0 + 4.0 * $this->G4; // Offsets for last corner in (x,y,z,w) coords
$y4 = $y0 - 1.0 + 4.0 * $this->G4;
$z4 = $z0 - 1.0 + 4.0 * $this->G4;
$w4 = $w0 - 1.0 + 4.0 * $this->G4;
// Work out the hashed gradient indices of the five simplex corners
$ii = $i & 255;
$jj = $j & 255;
$kk = $k & 255;
$ll = $l & 255;
// Calculate the contribution from the five corners
$t0 = 0.6 - $x0 * $x0 - $y0 * $y0 - $z0 * $z0 - $w0 * $w0;
if ($t0 < 0) $n0 = 0.0;
else {
$gi0 = ($this->perm[$ii + $this->perm[$jj + $this->perm[$kk + $this->perm[$ll]]]] % 32) * 4;
$t0 *= $t0;
$n0 = $t0 * $t0 * ($this->grad4[$gi0] * $x0 + $this->grad4[$gi0 + 1] * $y0 + $this->grad4[$gi0 + 2] * $z0 + $this->grad4[$gi0 + 3] * $w0);
}
$t1 = 0.6 - $x1 * $x1 - $y1 * $y1 - $z1 * $z1 - $w1 * $w1;
if ($t1 < 0) $n1 = 0.0;
else {
$gi1 = ($this->perm[$ii + $i1 + $this->perm[$jj + $j1 + $this->perm[$kk + $k1 + $this->perm[$ll + $l1]]]] % 32) * 4;
$t1 *= $t1;
$n1 = $t1 * $t1 * ($this->grad4[$gi1] * $x1 + $this->grad4[$gi1 + 1] * $y1 + $this->grad4[$gi1 + 2] * $z1 + $this->grad4[$gi1 + 3] * $w1);
}
$t2 = 0.6 - $x2 * $x2 - $y2 * $y2 - $z2 * $z2 - $w2 * $w2;
if ($t2 < 0) $n2 = 0.0;
else {
$gi2 = ($this->perm[$ii + $i2 + $this->perm[$jj + $j2 + $this->perm[$kk + $k2 + $this->perm[$ll + $l2]]]] % 32) * 4;
$t2 *= $t2;
$n2 = $t2 * $t2 * ($this->grad4[$gi2] * $x2 + $this->grad4[$gi2 + 1] * $y2 + $this->grad4[$gi2 + 2] * $z2 + $this->grad4[$gi2 + 3] * $w2);
}
$t3 = 0.6 - $x3 * $x3 - $y3 * $y3 - $z3 * $z3 - $w3 * $w3;
if ($t3 < 0) $n3 = 0.0;
else {
$gi3 = ($this->perm[$ii + $i3 + $this->perm[$jj + $j3 + $this->perm[$kk + $k3 + $this->perm[$ll + $l3]]]] % 32) * 4;
$t3 *= $t3;
$n3 = $t3 * $t3 * ($this->grad4[$gi3] * $x3 + $this->grad4[$gi3 + 1] * $y3 + $this->grad4[$gi3 + 2] * $z3 + $this->grad4[$gi3 + 3] * $w3);
}
$t4 = 0.6 - $x4 * $x4 - $y4 * $y4 - $z4 * $z4 - $w4 * $w4;
if ($t4 < 0) $n4 = 0.0;
else {
$gi4 = ($this->perm[$ii + 1 + $this->perm[$jj + 1 + $this->perm[$kk + 1 + $this->perm[$ll + 1]]]] % 32) * 4;
$t4 *= $t4;
$n4 = $t4 * $t4 * ($this->grad4[$gi4] * $x4 + $this->grad4[$gi4 + 1] * $y4 + $this->grad4[$gi4 + 2] * $z4 + $this->grad4[$gi4 + 3] * $w4);
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * ($n0 + $n1 + $n2 + $n3 + $n4);
}
function buildPermutationTable($random) {
$i;
$p = new Uint8Array(256);
for ($i = 0; $i < 256; $i++) {
$p[$i] = $i;
}
for ($i = 0; $i < 255; $i++) {
$r = $i + ~~($random * (256 - $i));
$aux = $p[$i];
$p[$i] = $p[$r];
$p[$r] = $aux;
}
return $p;
}
/*
The ALEA PRNG and masher code used by Wagner's simplex code,
is based on code by Johannes Baagøe, modified by Jonas Wagner.
Copyright (C) 2010 by Johannes Baagøe [email protected]
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.
*/
function alea() {
$s0 = 0;
$s1 = 0;
$s2 = 0;
$c = 1;
$mash = $this->masher();
$s0 = $mash(' ');
$s1 = $mash(' ');
$s2 = $mash(' ');
$arguments = func_get_args();
for ($i = 0; $i < func_num_args(); $i++) {
$s0 -= $mash($arguments[$i]);
if ($s0 < 0) {
$s0 += 1;
}
$s1 -= $mash($arguments[$i]);
if ($s1 < 0) {
$s1 += 1;
}
$s2 -= $mash($arguments[$i]);
if ($s2 < 0) {
$s2 += 1;
}
}
$mash = null;
return function() {
$t = 2091639 * $s0 + $c * 2.3283064365386963e-10; // 2^-32
$s0 = $s1;
$s1 = $s2;
return $s2 = $t - ($c = $t | 0);
};
}
function masher() {
$n = 0xefc8249d;
return function($data) {
$data = (string)$data;
for ($i = 0; $i < strlen($data); $i++) {
$n += $data{$i};
$h = 0.02519603282416938 * $n;
$n = $this->zerofill($h,0);
$h -= $n;
$h *= $n;
$n = $this->zerofill($h,0);
$h -= $n;
$n += $h * 0x100000000; // 2^32
}
return ($this->zerofill($n,0)) * 2.3283064365386963e-10; // 2^-32
};
}
function zerofill($a,$b) {
if($a>=0) return $a>>$b;
if($b==0) return (($a>>1)&0x7fffffff)*2+(($a>>$b)&1);
return ((~$a)>>$b)^(0x7fffffff>>($b-1));
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment