AccidentalNoise.Noise.CellularFunction C# (CSharp) Метод

        public static void CellularFunction(Double x, Double y, Double z, Double w, Double u, Double v, Int32 seed, Double[] f, Double[] disp)
        {
            var xInt = FastFloor(x);
            var yInt = FastFloor(y);
            var zInt = FastFloor(z);
            var wInt = FastFloor(w);
            var uInt = FastFloor(u);
            var vInt = FastFloor(v);

            for (var c = 0; c < 4; ++c)
            {
                f[c] = 99999.0;
                disp[c] = 0.0;
            }

            for (var vcur = vInt - 1; vcur <= vInt + 1; ++vcur)
            {
                for (var ucur = uInt - 1; ucur <= uInt + 1; ++ucur)
                {

                    for (var wcur = wInt - 2; wcur <= wInt + 2; ++wcur)
                    {
                        for (var zcur = zInt - 2; zcur <= zInt + 2; ++zcur)
                        {
                            for (var ycur = yInt - 2; ycur <= yInt + 2; ++ycur)
                            {
                                for (var xcur = xInt - 2; xcur <= xInt + 2; ++xcur)
                                {
                                    var xpos = xcur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed);
                                    var ypos = ycur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed + 1);
                                    var zpos = zcur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed + 2);
                                    var wpos = wcur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed + 3);
                                    var upos = ucur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed + 4);
                                    var vpos = vcur + InternalValueNoise(x, y, z, w, u, v, xcur, ycur, zcur, wcur, ucur, vcur, seed + 5);
                                    var xdist = xpos - x;
                                    var ydist = ypos - y;
                                    var zdist = zpos - z;
                                    var wdist = wpos - w;
                                    var udist = upos - u;
                                    var vdist = vpos - v;
                                    var dist = (xdist * xdist + ydist * ydist + zdist * zdist + wdist * wdist + udist * udist + vdist * vdist);
                                    var xval = FastFloor(xpos);
                                    var yval = FastFloor(ypos);
                                    var zval = FastFloor(zpos);
                                    var wval = FastFloor(wpos);
                                    var uval = FastFloor(upos);
                                    var vval = FastFloor(vpos);
                                    var dsp = InternalValueNoise(x, y, z, w, u, v, xval, yval, zval, wval, uval, vval, seed + 6);
                                    AddDistance(f, disp, dist, dsp);
                                }
                            }
                        }
                    }
                }
            }
        }