public override int[] GenLayer(int xCoord, int zCoord, int sizeX, int sizeZ)
        {
            int[] result          = new int[sizeX * sizeZ];
            int   drawLatticeSize = 16;
            float windZoom        = 128;

            for (int x = 0; x < sizeX + drawLatticeSize; x += drawLatticeSize)
            {
                for (int z = 0; z < sizeZ + drawLatticeSize; z += drawLatticeSize)
                {
                    PolarVector vec = windmap.getWindAt(((float)xCoord + x) / windZoom, ((float)zCoord + z) / windZoom);

                    int dx = (int)(vec.length * Math.Cos(vec.angle));
                    int dz = (int)(vec.length * Math.Sin(vec.angle));

                    plotLine(result, sizeX, x, z, x + dx, z + dz);
                    if (x < sizeX && z < sizeZ)
                    {
                        result[z * sizeX + x] = 255 << 16;
                    }
                }
            }

            return(result);
        }
        static PolarVector BiLerp(float lx, float ly, PolarVector leftTop, PolarVector rightTop, PolarVector leftBottom, PolarVector rightBottom)
        {
            PolarVector top = new PolarVector(
                lx * leftTop.angle + (1 - lx) * rightTop.angle,
                lx * leftTop.length + (1 - lx) * rightTop.length
                );

            PolarVector bottom = new PolarVector(
                lx * leftBottom.angle + (1 - lx) * rightBottom.angle,
                lx * leftBottom.length + (1 - lx) * rightBottom.length
                );

            return(new PolarVector(
                       ly * top.angle + (1 - ly) * bottom.angle,
                       ly * top.length + (1 - ly) * bottom.length
                       ));
        }
        public PolarVector getWindAt(double xpos, double zpos)
        {
            int xPosInt = (int)xpos;
            int zPosInt = (int)zpos;

            InitPositionSeed(xPosInt, zPosInt);
            PolarVector leftTop = new PolarVector((float)(NextInt(360) / 180.0 * Math.PI), NextInt(maxStrength - minStrength) + minStrength);

            InitPositionSeed(xPosInt - 1, zPosInt);
            PolarVector rightTop = new PolarVector((float)(NextInt(360) / 180.0 * Math.PI), NextInt(maxStrength - minStrength) + minStrength);

            InitPositionSeed(xPosInt, zPosInt - 1);
            PolarVector leftBottom = new PolarVector((float)(NextInt(360) / 180.0 * Math.PI), NextInt(maxStrength - minStrength) + minStrength);

            InitPositionSeed(xPosInt - 1, zPosInt - 1);
            PolarVector rightBottom = new PolarVector((float)(NextInt(360) / 180.0 * Math.PI), NextInt(maxStrength - minStrength) + minStrength);

            return(BiLerp((float)(xpos - xPosInt), (float)(zpos - zPosInt), leftTop, rightTop, leftBottom, rightBottom));
        }
        static PolarVector SmoothLerp(float lx, float ly, PolarVector w1, PolarVector w2, PolarVector w3, PolarVector w4)
        {
            float lxSmooth = SmoothStep(lx);
            float lySmooth = SmoothStep(ly);

            float lxISmooth = SmoothStep(1 - lx);
            float lyISmooth = SmoothStep(1 - ly);

            PolarVector r1 = new PolarVector(
                lxSmooth * w1.angle + lxISmooth * w2.angle,
                lxSmooth * w1.length + lxISmooth * w2.length
                );

            PolarVector r2 = new PolarVector(
                lxSmooth * w3.angle + lxISmooth * w4.angle,
                lxSmooth * w3.length + lxISmooth * w4.length
                );

            return(new PolarVector(
                       lySmooth * r1.angle + lyISmooth * r2.angle,
                       lySmooth * r1.length + lyISmooth * r2.length
                       ));
        }