Exemple #1
0
        public override float[,,] getValues(float[,,] values, Noise3D.noiseSumFunction sumFunc, Point3 samples, Vector3 origin, Vector3 area)
        {
            values = new float[samples.X, samples.Y,samples.Z];

            for (int i = 0; i < noises.Count; i++)
            {
                noises[i].getValues(values, sumFunctions[i], samples, origin, area);
            }

            Vector3 position = new Vector3();
            Vector3 step = new Vector3(area.X / (samples.X - 1), area.Y / (samples.Y - 1), area.Z / (samples.Z - 1));

            for(int i=0;i<values.GetLength(0);i++)
                for(int j=0;j<values.GetLength(1);j++)
                    for (int k = 0; k < values.GetLength(2); k++)
                    {
                        position.X = i * step.X + origin.X;
                        position.Y = j * step.Y + origin.Y;
                        position.Z = k * step.Z + origin.Z;

                        values[i, j, k] = filter(values[i, j, k], position);
                    }

            return values;
        }
        public override float[,,] getValues(float[,,] values, Noise3D.noiseSumFunction sumFunc, Point3 samples, Vector3 origin, Vector3 area)
        {
            origin *= 1f / period;
            area *= 1f / period;

            float difX, difY,difZ;
            Vector3 difVector = new Vector3();
            Vector3 step = new Vector3(area.X / (samples.X - 1), area.Y / (samples.Y - 1), area.Z / (samples.Z - 1));
            Vector3 pos = new Vector3();
            int cubeX,cubeY,cubeZ;
            Vector3 gradientVector;
            float lll, llu, lul, luu, ull, ulu, uul, uuu;
            float ll, lu, ul, uu;
            float l,u;
            float value;
            for(int i=0;i<samples.X;i++)
                for(int j=0;j<samples.Y;j++)
                    for (int k = 0; k < samples.Z; k++)
                    {
                        pos.X = origin.X + i * step.X;
                        pos.Y = origin.Y + j * step.Y;
                        pos.Z = origin.Z + k * step.Z;

                        cubeX = (int)Math.Floor(pos.X);
                        cubeY = (int)Math.Floor(pos.Y);
                        cubeZ = (int)Math.Floor(pos.Z);

                        difX = pos.X - (float)cubeX;
                        difY = pos.Y - (float)cubeY;
                        difZ = pos.Z - (float)cubeZ;

                        pos *= period;

                        //lll llu luu  lul uul uuu ulu ull
                        //lll
                        difVector.X = difX;
                        difVector.Y = difY;
                        difVector.Z = difZ;
                        gradientVector = getGradientVector(cubeX, cubeY, cubeZ);
                        Vector3.Dot(ref gradientVector, ref difVector, out lll);

                        //llu
                        difVector.Z = difZ - 1f;
                        gradientVector = getGradientVector(cubeX, cubeY, cubeZ + 1);
                        Vector3.Dot(ref gradientVector, ref difVector, out llu);

                        //luu
                        difVector.Y = difY - 1f;
                        gradientVector = getGradientVector(cubeX, cubeY + 1, cubeZ + 1);
                        Vector3.Dot(ref gradientVector, ref difVector, out luu);

                        //lul
                        difVector.Z = difZ;
                        gradientVector = getGradientVector(cubeX, cubeY + 1, cubeZ);
                        Vector3.Dot(ref gradientVector, ref difVector, out lul);

                        //uul
                        difVector.X = difX - 1f;
                        gradientVector = getGradientVector(cubeX + 1, cubeY + 1, cubeZ);
                        Vector3.Dot(ref gradientVector, ref difVector, out uul);

                        //uuu
                        difVector.Z = difZ - 1f;
                        gradientVector = getGradientVector(cubeX + 1, cubeY + 1, cubeZ + 1);
                        Vector3.Dot(ref gradientVector, ref difVector, out uuu);

                        //ulu
                        difVector.Y = difY;
                        gradientVector = getGradientVector(cubeX + 1, cubeY, cubeZ + 1);
                        Vector3.Dot(ref gradientVector, ref difVector, out ulu);

                        //ull
                        difVector.Z = difZ;
                        gradientVector = getGradientVector(cubeX + 1, cubeY, cubeZ);
                        Vector3.Dot(ref gradientVector, ref difVector, out ull);

                        ll = NGInterp(lll, ull, difX);
                        lu = NGInterp(llu, ulu, difX);
                        ul = NGInterp(lul, uul, difX);
                        uu = NGInterp(luu, uuu, difX);

                        l = NGInterp(ll, ul, difY);
                        u = NGInterp(lu, uu, difY);

                        value = NGInterp(l, u, difZ);
                        value = (float)Math.Cos((value + 1) * Math.PI / 2);
                        values[i, j, k] = sumFunc(values[i, j, k], filter(value, pos));
                    }

            return values;
        }
Exemple #3
0
 public void addNoise(Noise3D noise, noiseSumFunction sumFunction)
 {
     noises.Add(noise);
     sumFunctions.Add(sumFunction);
 }
Exemple #4
0
 public void addNoise(Noise3D noise, noiseSumFunction sumFunction)
 {
     noises.Add(noise);
     sumFunctions.Add(sumFunction);
 }