Ant landscape, remove original file: mention rBAfcab90a6a004

1 files changed, 0 insertions, 1422 deletions

diff --git a/add_mesh_ant_landscape.py b/add_mesh_ant_landscape.py
deleted file mode 100644
index eaa19b54..00000000
--- a/add_mesh_ant_landscape.py
+++ /dev/null
@@ -1,1422 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-bl_info = {
-    "name": "A.N.T. Landscape",
-    "author": "Jimmy Hazevoet",
-    "version": (0, 1, 6),
-    "blender": (2, 77, 0),
-    "location": "View3D > Add > Mesh",
-    "description": "Another Noise Tool: Add a landscape primitive",
-    "warning": "",
-    "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
-                "Scripts/Add_Mesh/ANT_Landscape",
-    "category": "Add Mesh",
-}
-
-"""
-# -------------------------------------------------------------
-- UPDATE: A.N.T. Landscape - Version 0,1,6 (5/2017)
-# -------------------------------------------------------------
-                - NEW:
-                -
-                - Use Blender internal texture data block - texture nodes
-                - Variable X and Y grid size and variable X and Y subdivisions
-                - Triangulate faces
-                - Slope map, z normal to vertex group weight,
-                    and optional select vertices on flat area's
-                - Place landscape at cursor position or at world center
-                - Noise variations (from old A.N.T. Blender-2.49 addon)
-                - Variable X and Y noise size (and X Y Offset since version 0.1.5)
-                - Plateau and Sealevel renamed to Maximum (plateau) and Minimum (now: seabed)
-                - Variable X and Y edge fallof with variable edge level (now: sealevel)
-                - Add water plane with variable height
-                - Use materials
-                - Some small changes and fixes
-                -
-
-# -------------------------------------------------------------
-# Another Noise Tool: Landscape mesh generator
-# -------------------------------------------------------------
-MESH OPTIONS:
-Mesh update:     Turn this on for interactive mesh refresh.
-Sphere:          Generate sphere or a grid mesh.
-Smooth:          Generate smooth shaded mesh.
-Triangulate:     Triangulate faces
-Subdivision X Y: Number of mesh X Y subdivisions, higher numbers gives more detail but slows down the script.
-Mesh size X Y:   X,Y size of the grid mesh in blender units.
-X_Offset:        Noise x offset in blender units (make tiled terrain)
-Y_Offset:        Noise y offset in blender units
-Cursor:          Place at cursor location
-Vertex Group:    Slope map, z normal value to vertex group weight,
-                    and select vertices on flat area's
-
-NOISE OPTIONS: ( Many of these options are the same as in blender textures. )
-Random seed:     Use this to randomise the origin of the noise function.
-Noise size:      Size of the noise.
-Noise type:      Available noise types: multiFractal, ridgedMFractal, fBm, hybridMFractal, heteroTerrain,
-                 Turbulence, Distorted Noise, Marble, Shattered_hTerrain, Strata_hTerrain, Planet_noise
-Noise basis:     Blender, Perlin, NewPerlin, Voronoi_F1, Voronoi_F2, Voronoi_F3, Voronoi_F4, Voronoi_F2-F1,
-                 Voronoi Crackle, Cellnoise
-Distortion:      Distortion amount.
-Hard:            Hard/Soft turbulence noise.
-Depth:           Noise depth, number of frequencies in the fBm.
-Dimension:       Musgrave: Fractal dimension of the roughest areas.
-Lacunarity:      Musgrave: Gap between successive frequencies.
-Offset:          Musgrave: Raises the terrain from sea level.
-Gain:            Musgrave: Scale factor.
-Marble Bias:     Sin, Tri, Saw
-Marble Sharpnes: Soft, Sharp, Sharper
-Marble Shape:    Shape of the marble function: Default, Ring, Swirl, Bumps, Wave, X, Y
-
-TERRAIN OPTIONS:
-Height:          Scale terrain height.
-Invert:          Invert terrain height.
-Offset:          Terrain height offset.
-Seabed:          Flattens terrain at seabed level.
-Plateau:         Flattens terrain at plateau level.
-Falloff:         Terrain height falloff: X falloff, Y falloff, XY falloff
-Edge Level:      Falloff edge level, sealevel
-FalloffSizeX:    Scale falloff x
-FalloffSizeY:    Scale falloff y
-Strata:          Strata amount, number of strata / terrace layers.
-Strata type:     Strata types, Smooth, Sharp-sub, Sharp-add, Quantize
-
-WATER:          Add water plane
-Level:          Adjust plane level
-
-MATERIAL:       Use materials
-"""
-
-# import modules
-import bpy
-from bpy.props import (
-        BoolProperty,
-        EnumProperty,
-        FloatProperty,
-        IntProperty,
-        StringProperty,
-        FloatVectorProperty,
-        )
-from mathutils import Vector
-from mathutils.noise import (
-        seed_set,
-        turbulence,
-        turbulence_vector,
-        fractal,
-        hybrid_multi_fractal,
-        multi_fractal,
-        ridged_multi_fractal,
-        hetero_terrain,
-        random_unit_vector,
-        variable_lacunarity,
-        )
-from math import (
-        floor, sqrt,
-        sin, cos, pi,
-        )
-
-
-# Create a new mesh (object) from verts/edges/faces.
-# verts/edges/faces ... List of vertices/edges/faces for the
-#                    new mesh (as used in from_pydata).
-# name ... Name of the new mesh (& object).
-def create_mesh_object(context, verts, edges, faces, name):
-    # Create new mesh
-    mesh = bpy.data.meshes.new(name)
-
-    # Make a mesh from a list of verts/edges/faces.
-    mesh.from_pydata(verts, edges, faces)
-
-    # Update mesh geometry after adding stuff.
-    mesh.update()
-
-    from bpy_extras import object_utils
-
-    return object_utils.object_data_add(context, mesh, operator=None)
-
-
-# ------------------------------------------------------------
-# Generate XY Grid
-def grid_gen(sub_d_x, sub_d_y, tri, meshsize_x, meshsize_y, options, water_plane, water_level):
-    verts = []
-    faces = []
-    for i in range (0, sub_d_x):
-        x = meshsize_x * (i / (sub_d_x - 1) - 1 / 2)
-        for j in range(0, sub_d_y):
-            y = meshsize_y * (j / (sub_d_y - 1) - 1 / 2)
-            if water_plane:
-                z = water_level
-            else:
-                z = landscape_gen(x, y, 0, meshsize_x, meshsize_y, options)
-
-            verts.append((x,y,z))
-
-    count = 0
-    for i in range (0, sub_d_y * (sub_d_x - 1)):
-        if count < sub_d_y - 1 :
-            A = i + 1
-            B = i
-            C = (i + sub_d_y)
-            D = (i + sub_d_y) + 1
-            if tri:
-                faces.append((A, B, D))
-                faces.append((B, C, D))
-            else:
-                faces.append((A, B, C, D))
-            count = count + 1
-        else:
-            count = 0
-
-    return verts, faces
-
-
-# Generate UV Sphere
-def sphere_gen(sub_d_x, sub_d_y, tri, meshsize, options, water_plane, water_level):
-    verts = []
-    faces = []
-    sub_d_x += 1
-    sub_d_y += 1
-    for i in range(0, sub_d_x):
-        for j in range(0, sub_d_y):
-            u = sin(j * pi * 2 / (sub_d_y - 1)) * cos(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
-            v = cos(j * pi * 2 / (sub_d_y - 1)) * cos(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
-            w = sin(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
-            if water_plane:
-                h = water_level
-            else:
-                h = landscape_gen(u, v, w, meshsize, meshsize, options) / meshsize
-            verts.append(((u + u * h), (v + v * h), (w + w * h)))
-
-    count = 0
-    for i in range (0, sub_d_y * (sub_d_x - 1)):
-        if count < sub_d_y - 1 :
-            A = i + 1
-            B = i
-            C = (i + sub_d_y)
-            D = (i + sub_d_y) + 1
-            if tri:
-                faces.append((A, B, D))
-                faces.append((B, C, D))
-            else:
-                faces.append((A, B, C, D))
-            count = count + 1
-        else:
-            count = 0
-
-    return verts, faces
-
-
-# ------------------------------------------------------------
-# Z normal value to vertex group (Slope map)
-class ANTSlopeVGroup(bpy.types.Operator):
-    bl_idname = "mesh.ant_slope_vgroup"
-    bl_label = "Slope Map"
-    bl_description = "Slope map - z normal value to vertex group weight"
-    #bl_options = {'REGISTER'} 
-
-    z_method = EnumProperty(
-            name="Method:",
-            default='SLOPE_Z',
-            items=[
-                ('SLOPE_Z', "Slope Z", "Slope for planar mesh"),
-                ('SLOPE_XYZ', "Slope XYZ", "Slope for spherical mesh")
-                ])
-    group_name = StringProperty(
-            name="Vertex Group Name:",
-            default="Slope",
-            description="Name"
-            )
-    select_flat = BoolProperty(
-            name="Vert Select:",
-            default=True,
-            description="Select vertices on flat surface"
-            )
-    select_range = FloatProperty(
-            name="Vert Select Range:",
-            default=0.0,
-            min=0.0,
-            max=1.0,
-            description="Increase to select more vertices"
-            )
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-
-    def execute(self, context):
-        message = "Popup Values: %d, %f, %s, %s" % \
-            (self.select_flat, self.select_range, self.group_name, self.z_method)
-        self.report({'INFO'}, message)
-
-        ob = bpy.context.active_object
-
-        if self.select_flat:
-            bpy.ops.object.mode_set(mode='EDIT')
-            bpy.ops.mesh.select_all(action='DESELECT')
-            bpy.context.tool_settings.mesh_select_mode = [True, False, False]
-            bpy.ops.object.mode_set(mode='OBJECT')
-
-        bpy.ops.object.vertex_group_add()
-        vg_normal = ob.vertex_groups.active
-
-        for v in ob.data.vertices:
-            if self.z_method == 'SLOPE_XYZ':
-                zno = (v.co.normalized() * v.normal.normalized()) * 2 - 1
-            else:
-                zno = v.normal[2]
-
-            vg_normal.add([v.index], zno, 'REPLACE')
-
-            if self.select_flat:
-                if zno >= (1.0 - self.select_range):
-                    v.select = True
-
-        vg_normal.name = self.group_name
-
-        return {'FINISHED'}
-
-# ------------------------------------------------------------
-# ------------------------------------------------------------
-# Marble_noise:
-def sin_bias(a):
-    return 0.5 + 0.5 * sin(a)
-
-
-def cos_bias(a):
-    return 0.5 + 0.5 * cos(a)
-
-
-def tri_bias(a):
-    b = 2 * pi
-    a = 1 - 2 * abs(floor((a * (1 / b)) + 0.5) - (a * (1 / b)))
-    return a
-
-
-def saw_bias(a):
-    b = 2 * pi
-    n = int(a / b)
-    a -= n * b
-    if a < 0:
-        a += b
-    return a / b
-
-
-def soft(a):
-    return a
-
-
-def sharp(a):
-    return a**0.5
-
-
-def sharper(a):
-    return sharp(sharp(a))
-
-
-def shapes(x, y, shape=0):
-    p = pi
-    if shape is 1:
-        # ring
-        x = x * p
-        y = y * p
-        s = cos(x**2 + y**2) / (x**2 + y**2 + 0.5)
-    elif shape is 2:
-        # swirl
-        x = x * p
-        y = y * p
-        s = ((x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5))
-    elif shape is 3:
-        # bumps
-        x = x * p
-        y = y * p
-        s = ((cos(x * p) + cos(y * p)) - 0.5)
-    elif shape is 4:
-        # wave
-        x = x * p * 2
-        y = y * p * 2
-        s = sin(x + sin(y))
-    elif shape is 5:
-        # y grad.
-        s = (y * p)
-    elif shape is 6:
-        # x grad.
-        s = (x * p)
-    else:
-        # marble default
-        s = ((x + y) * 5)
-    return s
-
-
-# marble_noise
-def marble_noise(x, y, z, origin, size, shape, bias, sharpnes, turb, depth, hard, basis, amp, freq):
-
-    s = shapes(x, y, shape)
-    x += origin[0]
-    y += origin[1]
-    z += origin[2]
-    value = s + turb * turbulence_vector((x, y, z), depth, hard, basis)[1]
-
-    if bias is 1:
-        value = cos_bias(value)
-    elif bias is 2:
-        value = tri_bias(value)
-    elif bias is 3:
-        value = saw_bias(value)
-    else:
-        value = sin_bias(value)
-
-    if sharpnes is 1:
-        value = 1.0 - sharp(value)
-    elif sharpnes is 2:
-        value = 1.0 - sharper(value)
-    elif sharpnes is 3:
-        value = soft(value)
-    elif sharpnes is 4:
-        value = sharp(value)
-    elif sharpnes is 5:
-        value = sharper(value)
-    else:
-        value = 1.0 - soft(value)
-
-    return value
-
-# A.N.T. Noise variations:
-
-# vl_noise_turbulence: 
-def vlnTurbMode(coords, distort, basis, vlbasis, hardnoise):
-    # hard noise
-    if hardnoise:
-        return (abs(-variable_lacunarity(coords, distort, basis, vlbasis)))
-    # soft noise
-    else:
-        return variable_lacunarity(coords, distort, basis, vlbasis)
-
-
-def vl_noise_turbulence(coords, distort, depth, basis, vlbasis, hardnoise, amp, freq):
-    x, y, z = coords
-    value = vlnTurbMode(coords, distort, basis, vlbasis, hardnoise)
-    i=0
-    for i in range(depth):
-        i+=1
-        value += vlnTurbMode((x * (freq * i), y * (freq * i), z), distort, basis, vlbasis, hardnoise) * (amp * 0.5 / i)
-    return value
-
-
-## duo_multiFractal:
-def double_multiFractal(coords, H, lacunarity, octaves, offset, gain, basis, vlbasis):
-    x, y, z = coords
-    n1 = multi_fractal((x * 1.5 + 1, y * 1.5 + 1, z), 1.0, 1.0, 1.0, basis) * (offset * 0.5)
-    n2 = multi_fractal((x - 1, y - 1, z), H, lacunarity, octaves, vlbasis) * (gain * 0.5)
-    return (n1 * n1 + n2 * n2) * 0.5
-
-
-## distorted_heteroTerrain:
-def distorted_heteroTerrain(coords, H, lacunarity, octaves, offset, distort, basis, vlbasis):
-    x, y, z = coords
-    h1 = (hetero_terrain((x, y, z), 1.0, 2.0, 1.0, 1.0, basis) * 0.5)
-    h2 = (hetero_terrain((x, y, h1 * distort * 2), H, lacunarity, octaves, offset, vlbasis) * 0.25)
-    return (h1 * h1 + h2 * h2) * 0.5
-
-
-## SlickRock:
-def slick_rock(coords, H, lacunarity, octaves, offset, gain, distort, basis, vlbasis):
-    x, y, z = coords
-    n = multi_fractal((x,y,z), 1.0, 2.0, 2.0, basis) * distort * 0.5
-    r = ridged_multi_fractal((x + n, y + n, z + n), H, lacunarity, octaves, offset + 0.1, gain * 2, vlbasis)
-    return (n + (n * r)) * 0.5
-
-
-## vlhTerrain
-def vl_hTerrain(coords, H, lacunarity, octaves, offset, basis, vlbasis, distort):
-    x, y, z = coords
-    ht = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis ) * 0.25
-    vl = ht * variable_lacunarity((x, y, z), distort, basis, vlbasis) * 0.5 + 0.5
-    return vl * ht
-
-
-# another turbulence
-def ant_turbulence(coords, depth, hardnoise, nbasis, amp, freq, distortion):
-    x, y, z = coords
-    tv = turbulence_vector((x + 1, y + 2, z + 3), depth, hardnoise, nbasis, amp, freq)
-    d = (distortion * tv[0]) * 0.25
-    return (d + ((tv[0] - tv[1]) * (tv[2])**2))
-
-
-# shattered_hterrain:
-def shattered_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
-    x, y, z = coords
-    d = (turbulence_vector(coords, 6, 0, 0)[0] * 0.5 + 0.5) * distort * 0.5
-    t1 = (turbulence_vector((x + d, y + d, z), 0, 0, 7)[0] + 0.5)
-    t2 = (hetero_terrain((x * 2, y * 2, z * 2), H, lacunarity, octaves, offset, basis) * 0.5)
-    return ((t1 * t2) + t2 * 0.5) * 0.5
-
-
-# strata_hterrain
-def strata_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
-    x, y, z = coords
-    value = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis) * 0.5
-    steps = (sin(value * (distort * 5) * pi) * (0.1 / (distort * 5) * pi))
-    return (value * (1.0 - 0.5) + steps * 0.5)
-
-
-# planet_noise by Farsthary: https://farsthary.com/2010/11/24/new-planet-procedural-texture/
-def planet_noise(coords, oct=6, hard=0, noisebasis=1, nabla=0.001):
-    x, y, z = coords
-    d = 0.001
-    offset = nabla * 1000
-    x = turbulence((x, y, z), oct, hard, noisebasis)
-    y = turbulence((x + offset, y, z), oct, hard, noisebasis)
-    z = turbulence((x, y + offset, z), oct, hard, noisebasis)
-    xdy = x - turbulence((x, y + d, z), oct, hard, noisebasis)
-    xdz = x - turbulence((x, y, z + d), oct, hard, noisebasis)
-    ydx = y - turbulence((x + d, y, z), oct, hard, noisebasis)
-    ydz = y - turbulence((x, y, z + d), oct, hard, noisebasis)
-    zdx = z - turbulence((x + d, y, z), oct, hard, noisebasis)
-    zdy = z - turbulence((x, y + d, z), oct, hard, noisebasis)
-    return (zdy - ydz), (zdx - xdz), (ydx - xdy)
-
-
-# ------------------------------------------------------------
-# landscape_gen
-def landscape_gen(x, y, z, meshsize_x, meshsize_y, props):
-
-    rseed = props[0]
-    nsize = props[1]
-    ntype = props[2]
-    nbasis = int(props[3][0])
-    vlbasis = int(props[4][0])
-    distortion = props[5]
-    hardnoise = int(props[6])
-    depth = props[7]
-    dimension = props[8]
-    lacunarity = props[9]
-    offset = props[10]
-    gain = props[11]
-    marblebias = int(props[12][0])
-    marblesharpnes = int(props[13][0])
-    marbleshape = int(props[14][0])
-    invert = props[15]
-    height = props[16]
-    heightoffset = props[17]
-    falloff = int(props[18][0])
-    minimum = props[19]
-    maximum = props[20]
-    strata = props[21]
-    stratatype = props[22]
-    sphere = props[23]
-    x_offset = props[24]
-    y_offset = props[25]
-    edge_level = props[26]
-    falloffsize_x = props[27]
-    falloffsize_y = props[28]
-    size_x = props[29]
-    size_y = props[30]
-    amp = props[31]
-    freq = props[32]
-    texture_name = props[33]
-
-    # origin
-    if rseed is 0:
-        origin = x_offset, y_offset, 0
-        origin_x = x_offset
-        origin_y = y_offset
-        origin_z = 0
-        o_range = 1.0
-    else:
-        # randomise origin
-        o_range = 10000.0
-        seed_set(rseed)
-        origin = random_unit_vector()
-        ox = (origin[0] * o_range)
-        oy = (origin[1] * o_range)
-        oz = (origin[2] * o_range)
-        origin_x = (ox - (ox / 2)) + x_offset
-        origin_y = (oy - (oy / 2)) + y_offset
-        origin_z = (oz - (oz / 2))
-
-    ncoords = (x / (nsize * size_x) + origin_x, y / (nsize * size_y) + origin_y, z / nsize + origin_z)
-
-    # noise basis type's
-    if nbasis == 9:
-        nbasis = 14  # cellnoise
-    if vlbasis ==9:
-        vlbasis = 14
-
-    # noise type's
-    if ntype == 'multi_fractal':
-        value = multi_fractal(ncoords, dimension, lacunarity, depth, nbasis) * 0.5
-
-    elif ntype == 'ridged_multi_fractal':
-        value = ridged_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis) * 0.5
-
-    elif ntype == 'hybrid_multi_fractal':
-        value = hybrid_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis) * 0.5
-
-    elif ntype == 'hetero_terrain':
-        value = hetero_terrain(ncoords, dimension, lacunarity, depth, offset, nbasis) * 0.25
-
-    elif ntype == 'fractal':
-        value = fractal(ncoords, dimension, lacunarity, depth, nbasis)
-
-    elif ntype == 'turbulence_vector':
-        value = turbulence_vector(ncoords, depth, hardnoise, nbasis, amp, freq)[0]
-
-    elif ntype == 'variable_lacunarity':
-        value = variable_lacunarity(ncoords, distortion, nbasis, vlbasis)
-
-    elif ntype == 'marble_noise':
-        value = marble_noise(
-                        (ncoords[0] - origin_x + x_offset),
-                        (ncoords[1] - origin_y + y_offset), 
-                        (ncoords[2] - origin_z),
-                        (origin[0] + x_offset, origin[1] + y_offset, 0), nsize,
-                        marbleshape, marblebias, marblesharpnes,
-                        distortion, depth, hardnoise, nbasis, amp, freq
-                        )
-    elif ntype == 'shattered_hterrain':
-        value = shattered_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)
-
-    elif ntype == 'strata_hterrain':
-        value = strata_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)
-
-    elif ntype == 'ant_turbulence':
-        value = ant_turbulence(ncoords, depth, hardnoise, nbasis, amp, freq, distortion)
-
-    elif ntype == 'vl_noise_turbulence':
-        value = vl_noise_turbulence(ncoords, distortion, depth, nbasis, vlbasis, hardnoise, amp, freq)
-
-    elif ntype == 'vl_hTerrain':
-        value = vl_hTerrain(ncoords, dimension, lacunarity, depth, offset, nbasis, vlbasis, distortion)
-
-    elif ntype == 'distorted_heteroTerrain':
-        value = distorted_heteroTerrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis, vlbasis)
-
-    elif ntype == 'double_multiFractal':
-        value = double_multiFractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis, vlbasis)
-
-    elif ntype == 'slick_rock':
-        value = slick_rock(ncoords,dimension, lacunarity, depth, offset, gain, distortion, nbasis, vlbasis)
-
-    elif ntype == 'planet_noise':
-        value = planet_noise(ncoords, depth, hardnoise, nbasis)[2] * 0.5 + 0.5
-
-    elif ntype == 'blender_texture':
-        if texture_name != "" and texture_name in bpy.data.textures:
-            value = bpy.data.textures[texture_name].evaluate(ncoords)[3]
-        else:
-            value = 0.0
-    else:
-        value = 0.0
-
-    # adjust height
-    if invert:
-        value = -value
-        value = value * height + heightoffset
-    else:
-        value = value * height + heightoffset
-
-    # Edge falloff:
-    if not sphere:
-        if falloff:
-            ratio_x, ratio_y = abs(x) * 2 / meshsize_x, abs(y) * 2 / meshsize_y
-            fallofftypes = [0,
-                            sqrt(ratio_y**falloffsize_y),
-                            sqrt(ratio_x**falloffsize_x),
-                            sqrt(ratio_x**falloffsize_x + ratio_y**falloffsize_y)
-                           ]
-            dist = fallofftypes[falloff]
-            value -= edge_level
-            if(dist < 1.0):
-                dist = (dist * dist * (3 - 2 * dist))
-                value = (value - value * dist) + edge_level
-            else:
-                value = edge_level
-
-    # strata / terrace / layers
-    if stratatype != '0':
-        strata = strata / height
-
-    if stratatype == '1':
-        strata *= 2
-        steps = (sin(value * strata * pi) * (0.1 / strata * pi))
-        value = (value * 0.5 + steps * 0.5) * 2.0
-
-    elif stratatype == '2':
-        steps = -abs(sin(value * strata * pi) * (0.1 / strata * pi))
-        value = (value * 0.5 + steps * 0.5) * 2.0
-
-    elif stratatype == '3':
-        steps = abs(sin(value * strata * pi) * (0.1 / strata * pi))
-        value = (value * 0.5 + steps * 0.5) * 2.0
-
-    elif stratatype == '4':
-        value = int( value * strata ) * 1.0 / strata
-
-    elif stratatype == '5':
-        steps = (int( value * strata ) * 1.0 / strata)
-        value = (value * (1.0 - 0.5) + steps * 0.5)
-
-    # clamp height min max
-    if (value < minimum):
-        value = minimum
-    if (value > maximum):
-        value = maximum
-
-    return value
-
-
-# ------------------------------------------------------------
-# Add landscape
-class landscape_add(bpy.types.Operator):
-    bl_idname = "mesh.landscape_add"
-    bl_label = "Landscape"
-    bl_options = {'REGISTER', 'UNDO', 'PRESET'}
-    bl_description = "Add landscape mesh"
-
-    # properties
-    at_cursor = BoolProperty(
-            name="Cursor",
-            description="Place at cursor location",
-            default=True
-            )
-    smooth_mesh = BoolProperty(
-            name="Smooth",
-            default=True,
-            description="Shade smooth"
-            )
-    tri_face = BoolProperty(
-            name="Triangulate",
-            default=False,
-            description="Triangulate faces"
-            )
-    sphere_mesh = BoolProperty(
-            name="Sphere",
-            default=False,
-            description="Generate uv sphere - remove doubles when ready"
-            )
-    subdivision_x = IntProperty(
-            name="Subdivisions X",
-            min=4,
-            max=6400,
-            default=128,
-            description="Mesh X subdivisions"
-            )
-    subdivision_y = IntProperty(
-            name="Subdivisions Y",
-            min=4,
-            max=6400,
-            default=128,
-            description="Mesh Y subdivisions"
-            )
-    meshsize = FloatProperty(
-            name="Size",
-            min=0.01,
-            max=100000.0,
-            default=2.0,
-            description="Mesh size"
-            )
-    meshsize_x = FloatProperty(
-            name="Size X",
-            min=0.01,
-            default=2.0,
-            description="Mesh x size"
-            )
-    meshsize_y = FloatProperty(
-            name="Size Y",
-            min=0.01,
-            default=2.0,
-            description="Mesh y size"
-            )
-
-    random_seed = IntProperty(
-            name="Random Seed",
-            min=0,
-            default=0,
-            description="Randomize noise origin"
-            )
-    x_offset = FloatProperty(
-            name="Offset X",
-            default=0.0,
-            description="Noise X Offset"
-            )
-    y_offset = FloatProperty(
-            name="Offset Y",
-            default=0.0,
-            description="Noise Y Offset"
-            )
-    noise_size = FloatProperty(
-            name="Noise Size",
-            min=0.01,
-            max=1000.0,
-            default=1.0,
-            description="Noise size"
-            )
-    noise_size_x = FloatProperty(
-            name="Size X",
-            min=0.01,
-            max=1000.0,
-            default=1.0,
-            description="Noise x size"
-            )
-    noise_size_y = FloatProperty(
-            name="Size Y",
-            min=0.01,
-            max=1000.0,
-            default=1.0,
-            description="Noise y size"
-            )
-    NoiseTypes = [
-            ('multi_fractal', "Multi Fractal", "Blender: Multi Fractal algorithm"),
-            ('ridged_multi_fractal', "Ridged MFractal", "Blender: Ridged Multi Fractal"),
-            ('hybrid_multi_fractal', "Hybrid MFractal", "Blender: Hybrid Multi Fractal"),
-            ('hetero_terrain', "Hetero Terrain", "Blender: Hetero Terrain"),
-            ('fractal', "fBm Fractal", "Blender: fBm - Fractional Browninian motion"),
-            ('turbulence_vector', "Turbulence", "Blender: Turbulence Vector"),
-            ('variable_lacunarity', "Distorted Noise", "Blender: Distorted Noise"),
-            ('marble_noise', "Marble", "A.N.T.: Marble Noise"),
-            ('shattered_hterrain', "Shattered hTerrain", "A.N.T.: Shattered hTerrain"),
-            ('strata_hterrain', "Strata hTerrain", "A.N.T: Strata hTerrain"),
-            ('ant_turbulence', "Another Turbulence", "A.N.T: Turbulence variation"),
-            ('vl_noise_turbulence', "vlNoise turbulence", "A.N.T: vlNoise turbulence"),
-            ('vl_hTerrain', "vlNoise hTerrain", "A.N.T: vlNoise hTerrain"),
-            ('distorted_heteroTerrain', "Distorted hTerrain", "A.N.T distorted hTerrain"),
-            ('double_multiFractal', "Double MultiFractal", "A.N.T: double multiFractal"),
-            ('slick_rock', "Slick Rock", "A.N.T: slick rock"),
-            ('planet_noise', "Planet Noise", "Planet Noise by: Farsthary"),
-            ('blender_texture', "Blender Texture - Texture Nodes", "Blender texture data block")
-            ]
-    noise_type = EnumProperty(
-            name="Type",
-            description="Noise type",
-            default='hetero_terrain',
-            items=NoiseTypes
-            )
-    BasisTypes = [
-            ("0", "Blender", "Blender default noise"),
-            ("1", "Perlin", "Perlin noise"),
-            ("2", "New Perlin", "New Perlin noise"),
-            ("3", "Voronoi F1", "Voronoi F1"),
-            ("4", "Voronoi F2", "Voronoi F2"),
-            ("5", "Voronoi F3", "Voronoi F3"),
-            ("6", "Voronoi F4", "Voronoi F4"),
-            ("7", "Voronoi F2-F1", "Voronoi F2-F1"),
-            ("8", "Voronoi Crackle", "Voronoi Crackle"),
-            ("9", "Cell Noise", "Cell noise")
-            ]
-    basis_type = EnumProperty(
-            name="Basis",
-            description="Noise basis algorithms",
-            default="0",
-            items=BasisTypes
-            )
-    vl_basis_type = EnumProperty(
-            name="VLBasis",
-            description="VLNoise basis algorithms",
-            default="0",
-            items=BasisTypes
-            )
-    distortion = FloatProperty(
-            name="Distortion",
-            min=0.01,
-            max=100.0,
-            default=1.0,
-            description="Distortion amount"
-            )
-    hardTypes = [
-            ("0", "Soft", "Soft Noise"),
-            ("1", "Hard", "Hard noise")
-            ]
-    hard_noise = EnumProperty(
-            name="Soft Hard",
-            description="Soft Noise, Hard noise",
-            default="0",
-            items=hardTypes
-            )
-    noise_depth = IntProperty(
-            name="Depth",
-            min=0,
-            max=16,
-            default=8,
-            description="Noise Depth - number of frequencies in the fBm"
-            )
-    amplitude = FloatProperty(
-            name="Amp",
-            min=0.01,
-            max=1.0,
-            default=0.5,
-            description="Amplitude"
-            )
-    frequency = FloatProperty(
-            name="Freq",
-            min=0.01,
-            max=5.0,
-            default=2.0,
-            description="Frequency"
-            )
-    dimension = FloatProperty(
-            name="Dimension",
-            min=0.01,
-            max=2.0,
-            default=1.0,
-            description="H - fractal dimension of the roughest areas"
-            )
-    lacunarity = FloatProperty(
-            name="Lacunarity",
-            min=0.01,
-            max=6.0,
-            default=2.0,
-            description="Lacunarity - gap between successive frequencies"
-            )
-    moffset = FloatProperty(
-            name="Offset",
-            min=0.01,
-            max=6.0,
-            default=1.0,
-            description="Offset - raises the terrain from sea level"
-            )
-    gain = FloatProperty(
-            name="Gain",
-            min=0.01,
-            max=6.0,
-            default=1.0,
-            description="Gain - scale factor"
-            )
-    BiasTypes = [
-            ("0", "Sin", "Sin"),
-            ("1", "Cos", "Cos"),
-            ("2", "Tri", "Tri"),
-            ("3", "Saw", "Saw")
-            ]
-    marble_bias = EnumProperty(
-            name="Bias",
-            description="Marble bias",
-            default="0",
-            items=BiasTypes
-            )
-    SharpTypes = [
-            ("0", "Soft", "Soft"),
-            ("1", "Sharp", "Sharp"),
-            ("2", "Sharper", "Sharper"),
-            ("3", "Soft inv.", "Soft"),
-            ("4", "Sharp inv.", "Sharp"),
-            ("5", "Sharper inv.", "Sharper")
-            ]
-    marble_sharp = EnumProperty(
-            name="Sharp",
-            description="Marble sharpness",
-            default="0",
-            items=SharpTypes
-            )
-    ShapeTypes = [
-            ("0", "Default", "Default"),
-            ("1", "Ring", "Ring"),
-            ("2", "Swirl", "Swirl"),
-            ("3", "Bump", "Bump"),
-            ("4", "Wave", "Wave"),
-            ("5", "Y", "Y"),
-            ("6", "X", "X")
-            ]
-    marble_shape = EnumProperty(
-            name="Shape",
-            description="Marble shape",
-            default="0",
-            items=ShapeTypes
-            )
-    height = FloatProperty(
-            name="Height",
-            min=-10000.0,
-            max=10000.0,
-            default=0.5,
-            description="Noise intensity scale"
-            )
-    invert = BoolProperty(
-            name="Invert",
-            default=False,
-            )
-    offset = FloatProperty(
-            name="Offset",
-            min=-10000.0,
-            max=10000.0,
-            default=0.0,
-            description="Height offset"
-            )
-    fallTypes = [
-            ("0", "None", "None"),
-            ("1", "Y", "Y Falloff"),
-            ("2", "X", "X Falloff"),
-            ("3", "X Y", "X Y Falloff")
-            ]
-    edge_falloff = EnumProperty(
-            name="Falloff",
-            description="Flatten edges",
-            default="3",
-            items=fallTypes
-            )
-    falloff_size_x = FloatProperty(
-            name="Falloff X",
-            min=0.1,
-            max=100.0,
-            default=4.0,
-            description="Falloff x scale"
-            )
-    falloff_size_y = FloatProperty(
-            name="Falloff Y",
-            min=0.1,
-            max=100.0,
-            default=4.0,
-            description="Falloff y scale"
-            )
-    edge_level = FloatProperty(
-            name="Edge Level",
-            min=-10000.0,
-            max=10000.0,
-            default=0.0,
-            description="Edge level, sealevel offset"
-            )
-    maximum = FloatProperty(
-            name="Maximum",
-            min=-10000.0,
-            max=10000.0,
-            default=1.0,
-            description="Maximum, flattens terrain at plateau level"
-            )
-    minimum = FloatProperty(
-            name="Minimum",
-            min=-10000.0,
-            max=10000.0,
-            default=-0.11,
-            description="Minimum, flattens terrain at seabed level"
-            )
-    strata = FloatProperty(
-            name="Amount",
-            min=0.01,
-            max=1000.0,
-            default=5.0,
-            description="Strata layers / terraces"
-            )
-    StrataTypes = [
-            ("0", "None", "No strata"),
-            ("1", "Smooth", "Smooth transitions"),
-            ("2", "Sharp -", "Sharp substract transitions"),
-            ("3", "Sharp +", "Sharp add transitions"),
-            ("4", "Posterize", "Posterize"),
-            ("5", "Posterize Mix", "Posterize mixed with noise")
-            ]
-    strata_type = EnumProperty(
-            name="Strata",
-            description="Strata types",
-            default="0",
-            items=StrataTypes
-            )
-    water_plane = BoolProperty(
-            name="Water Plane",
-            default=False,
-            description="Add water plane"
-            )
-    water_level = FloatProperty(
-            name="Level",
-            min=-10000.0,
-            max=10000.0,
-            default=0.01,
-            description="Water level"
-            )
-    use_mat = BoolProperty(
-            name="Material",
-            default=False,
-            description="Use material"
-            )
-    sel_land_mat = StringProperty(
-            name='Terrain',
-            description="Terrain material"
-            )
-    sel_water_mat = StringProperty(
-            name='Water',
-            description="Water material"
-            )
-    show_noise_settings = BoolProperty(
-            name="Noise Settings",
-            default=True,
-            description="Show noise settings"
-            )
-    show_terrain_settings = BoolProperty(
-            name="Terrain Settings",
-            default=True,
-            description="Show terrain settings"
-            )
-    refresh = BoolProperty(
-            name="Refresh",
-            description="Refresh",
-            default=False
-            )
-    auto_refresh = BoolProperty(
-            name="Auto",
-            description="Automatic refresh",
-            default=True
-            )
-    texture_name = StringProperty(
-        name="Texture",
-        default=""
-        )
-
-    def draw(self, context):
-        sce = context.scene
-        layout = self.layout
-
-        box = layout.box()
-        row = box.row(align=True)
-        if self.auto_refresh is False:
-            self.refresh = False
-        elif self.auto_refresh is True:
-            self.refresh = True
-        split = row.split(align=True)
-        split.prop(self, 'auto_refresh', toggle=True, icon_only=True, icon='AUTO')
-        split.prop(self, 'refresh', toggle=True, icon_only=True, icon='FILE_REFRESH')
-        split.prop(self, "at_cursor", toggle=True, icon_only=True, icon='CURSOR')
-        split.prop(self, "smooth_mesh", toggle=True, icon_only=True, icon='SOLID')
-        split.prop(self, "tri_face", toggle=True, icon_only=True, icon='MESH_DATA')
-        split.operator('mesh.ant_slope_vgroup', text="", icon='GROUP_VERTEX')
-        col = box.column(align=True)
-        col.prop(self, "sphere_mesh", toggle=True)
-        col = box.column(align=True)
-        col.prop(self, "subdivision_x")
-        col.prop(self, "subdivision_y")
-
-        box = layout.box()
-        col = box.column(align=False)
-        col.prop(self, 'use_mat', toggle=True)
-        if self.use_mat:
-            col = box.column(align=True)
-            col.prop_search(self, "sel_land_mat",  bpy.data, "materials")
-            col = box.column(align=True)
-            if self.water_plane:
-                col.prop_search(self, "sel_water_mat",  bpy.data, "materials")
-
-        box = layout.box()
-        box.prop(self, "show_noise_settings", toggle=True)
-        if self.show_noise_settings:
-            box.prop(self, "noise_type")
-            if self.noise_type == "blender_texture":
-                box.prop_search(self, "texture_name", bpy.data, "textures")
-            else:
-                box.prop(self, "basis_type")
-
-            col = box.column(align=True)
-            col.prop(self, "random_seed")
-            col = box.column(align=True)
-            col.prop(self, "x_offset")
-            col.prop(self, "y_offset")
-            col.prop(self, "noise_size_x")
-            col.prop(self, "noise_size_y")
-            col = box.column(align=True)
-            col.prop(self, "noise_size")
-
-            col = box.column(align=True)
-            if self.noise_type == "multi_fractal":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-            elif self.noise_type == "ridged_multi_fractal":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "gain")
-            elif self.noise_type == "hybrid_multi_fractal":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "gain")
-            elif self.noise_type == "hetero_terrain":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-            elif self.noise_type == "fractal":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-            elif self.noise_type == "turbulence_vector":
-                col.prop(self, "noise_depth")
-                col.prop(self, "amplitude")
-                col.prop(self, "frequency")
-                col.separator()
-                row = col.row(align=True)
-                row.prop(self, "hard_noise", expand=True)
-            elif self.noise_type == "variable_lacunarity":
-                box.prop(self, "vl_basis_type")
-                box.prop(self, "distortion")
-            elif self.noise_type == "marble_noise":
-                box.prop(self, "marble_shape")
-                box.prop(self, "marble_bias")
-                box.prop(self, "marble_sharp")
-                col = box.column(align=True)
-                col.prop(self, "distortion")
-                col.prop(self, "noise_depth")
-                col.separator()
-                row = col.row(align=True)
-                row.prop(self, "hard_noise", expand=True)
-            elif self.noise_type == "shattered_hterrain":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "distortion")
-            elif self.noise_type == "strata_hterrain":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "distortion", text="Strata")
-            elif self.noise_type == "ant_turbulence":
-                col.prop(self, "noise_depth")
-                col.prop(self, "amplitude")
-                col.prop(self, "frequency")
-                col.prop(self, "distortion")
-                col.separator()
-                row = col.row(align=True)
-                row.prop(self, "hard_noise", expand=True)
-            elif self.noise_type == "vl_noise_turbulence":
-                col.prop(self, "noise_depth")
-                col.prop(self, "amplitude")
-                col.prop(self, "frequency")
-                col.prop(self, "distortion")
-                col.separator()
-                col.prop(self, "vl_basis_type")
-                col.separator()
-                row = col.row(align=True)
-                row.prop(self, "hard_noise", expand=True)
-            elif self.noise_type == "vl_hTerrain":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "distortion")
-                col.separator()
-                col.prop(self, "vl_basis_type")
-            elif self.noise_type == "distorted_heteroTerrain":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "distortion")
-                col.separator()
-                col.prop(self, "vl_basis_type")
-            elif self.noise_type == "double_multiFractal":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "moffset")
-                col.prop(self, "gain")
-                col.separator()
-                col.prop(self, "vl_basis_type")
-            elif self.noise_type == "slick_rock":
-                col.prop(self, "noise_depth")
-                col.prop(self, "dimension")
-                col.prop(self, "lacunarity")
-                col.prop(self, "gain")
-                col.prop(self, "moffset")
-                col.prop(self, "distortion")
-                col.separator()
-                col.prop(self, "vl_basis_type")
-            elif self.noise_type == "planet_noise":
-                col.prop(self, "noise_depth")
-                col.separator()
-                row = col.row(align=True)
-                row.prop(self, "hard_noise", expand=True)
-
-        box = layout.box()
-        box.prop(self, "show_terrain_settings", toggle=True)
-        if self.show_terrain_settings:
-            col = box.column(align=True)
-            if self.sphere_mesh:
-                col.prop(self, "meshsize")
-            else:
-                col.prop(self, "meshsize_x")
-                col.prop(self, "meshsize_y")
-
-            col = box.column(align=True)
-            row = col.row(align=True).split(0.9, align=True)
-            row.prop(self, "height")
-            row.prop(self, "invert", toggle=True, text="", icon='ARROW_LEFTRIGHT')
-            col.prop(self, "offset")
-            col.prop(self, "maximum")
-            col.prop(self, "minimum")
-
-            if not self.sphere_mesh:
-                col = box.column(align=False)
-                col.prop(self, "edge_falloff")
-                if self.edge_falloff is not "0":
-                    col = box.column(align=True)
-                    col.prop(self, "edge_level")
-                    if self.edge_falloff in ["2", "3"]:
-                        col.prop(self, "falloff_size_x")
-                    if self.edge_falloff in ["1", "3"]:
-                        col.prop(self, "falloff_size_y")
-
-            col = box.column(align=False)
-            col.prop(self, "strata_type")
-            if self.strata_type is not "0":
-                col = box.column(align=False)
-                col.prop(self, "strata")
-
-            col = box.column(align=False)
-            col.prop(self, "water_plane", toggle=True)
-            if self.water_plane is True:
-                col = box.column(align=False)
-                col.prop(self, "water_level")
-
-
-    def invoke(self, context, event):
-        self.refresh = True
-        return self.execute(context)
-
-
-    def execute(self, context):
-        if not self.refresh:
-            return {'PASS_THROUGH'}
-
-        # turn off undo
-        undo = bpy.context.user_preferences.edit.use_global_undo
-        bpy.context.user_preferences.edit.use_global_undo = False
-        # deselect all objects when in object mode
-        if bpy.ops.object.select_all.poll():
-            bpy.ops.object.select_all(action='DESELECT')
-
-        scene = context.scene
-        # settings
-        props = [
-            self.random_seed,
-            self.noise_size,
-            self.noise_type,
-            self.basis_type,
-            self.vl_basis_type,
-            self.distortion,
-            self.hard_noise,
-            self.noise_depth,
-            self.dimension,
-            self.lacunarity,
-            self.moffset,
-            self.gain,
-            self.marble_bias,
-            self.marble_sharp,
-            self.marble_shape,
-            self.invert,
-            self.height,
-            self.offset,
-            self.edge_falloff,
-            self.minimum,
-            self.maximum,
-            self.strata,
-            self.strata_type,
-            self.sphere_mesh,
-            self.x_offset,
-            self.y_offset,
-            self.edge_level,
-            self.falloff_size_x,
-            self.falloff_size_y,
-            self.noise_size_x,
-            self.noise_size_y,
-            self.amplitude,
-            self.frequency,
-            self.texture_name
-            ]
-
-        # Main function, create landscape mesh object
-        if self.sphere_mesh:
-            # sphere
-            verts, faces = sphere_gen(self.subdivision_y, self.subdivision_x, self.tri_face, self.meshsize, props, False, 0.0)
-            lobj = create_mesh_object(context, verts, [], faces, "Landscape")
-        else:
-            # grid
-            verts, faces = grid_gen(self.subdivision_x, self.subdivision_y, self.tri_face, self.meshsize_x, self.meshsize_y, props, False, 0.0)
-            lobj = create_mesh_object(context, verts, [], faces, "Landscape")
-
-        if self.smooth_mesh:
-            bpy.ops.object.shade_smooth()
-
-        if not self.at_cursor:
-            lobj.object.location = (0.0, 0.0, 0.0)
-
-        # Landscape Material
-        if self.use_mat:
-            if self.sel_land_mat != "" and self.sel_land_mat in bpy.data.materials:
-                mat = bpy.data.materials[self.sel_land_mat]
-                bpy.context.object.data.materials.append(mat)
-
-        # Water plane
-        if self.water_plane:
-            if self.sphere_mesh:
-                # sphere
-                verts, faces = sphere_gen(self.subdivision_y, self.subdivision_x, self.tri_face, self.meshsize, props, self.water_plane, self.water_level)
-                wobj = create_mesh_object(context, verts, [], faces, "Water")
-            else:
-                # grid
-                verts, faces = grid_gen(2, 2, self.tri_face, self.meshsize_x, self.meshsize_y, props, self.water_plane, self.water_level)
-                wobj = create_mesh_object(context, verts, [], faces, "Water")
-
-            wobj.object.select = True
-            if self.smooth_mesh:
-                bpy.ops.object.shade_smooth()
-
-            if not self.at_cursor:
-                wobj.object.location = (0.0, 0.0, 0.0)
-
-            # Water Material
-            if self.use_mat:
-                if self.sel_water_mat != "" and self.sel_water_mat in bpy.data.materials:
-                    mat = bpy.data.materials[self.sel_water_mat]
-                    bpy.context.object.data.materials.append(mat)
-
-        # select landscape and make active
-        lobj.object.select = True
-        scene.objects.active = lobj.object
-        #
-        if self.auto_refresh is False:
-            self.refresh = False
-
-        # restore pre operator undo state
-        context.user_preferences.edit.use_global_undo = undo
-
-        return {'FINISHED'}
-
-
-# ------------------------------------------------------------
-# Register:
-
-# Define "Landscape" menu
-def menu_func_landscape(self, context):
-    self.layout.operator(landscape_add.bl_idname, text="Landscape", icon="RNDCURVE")
-
-
-def register():
-    bpy.utils.register_module(__name__)
-    bpy.types.INFO_MT_mesh_add.append(menu_func_landscape)
-    #bpy.utils.register_class(ANTSlopeVGroup)
-
-
-def unregister():
-    bpy.utils.unregister_module(__name__)
-    bpy.types.INFO_MT_mesh_add.remove(menu_func_landscape)
-    #bpy.utils.unregister_class(ANTSlopeVGroup)
-
-
-if __name__ == "__main__":
- register()