#!BPY 
""" 
Name: 'A.N.T.Landscape v.1.03' 
Blender: 234 
Group: 'Add' 
Tip: 'Create a landscape mesh.' 
""" 


##########################################################################
##        : A.N.T.(Another Noise Tool) Landscape 1.03 VCol.
##        : Jimmy Hazevoet  : Jan./Oct. 2005
##########################################################################
#------------------------------------------------------------------------#
## v.1.03 : NEW: Mesh 'VertexColor' gradient.
##             : Use new 'Mesh Modifier' (Blender2.38+) for SubSurf.
##             : Some new Effect and Filter stuff.
#------------------------------------------------------------------------#
##########################################################################

import Blender
from Blender import *
from Blender.Noise import *
from math import *
from Blender.Draw import *
from Blender.BGL import *
from Blender import Scene
sc=Scene.getCurrent()

# color stuff #------------------------------
#############################################
vcolours = Create(1)
ColScreen = Create(0)
preGrad = Create(0)
newheight = Create(0.50)
EVB_H      = 125
EVB_R      = 150
EVB_G      = 200
EVB_B      = 250
EVB_DEL    = 300
EV_NEW     = 5
EV_NOEVENT = 1
colorcontrols=[]

colors = (
      #default ### [ h, r, g, b] ###
      [[ 1.0, 227, 228, 231], [ 0.70, 96, 98, 97], [ 0.003, 76, 99, 27], [ 0.20, 96, 74, 23], [ 0.0,  11, 35, 84], [-1.0,  11, 35, 84]],
      #natural
      [[ 1.00, 200, 200, 200], [ 0.70, 159, 159, 159], [ 0.20, 157, 131, 67], [ 0.003, 85, 108, 67], [0.0, 3, 71, 109], [-1.0,  2, 39,  89]],
      #dry
      [[ 1.00, 169, 115, 54], [ 0.1, 187, 146, 37], [ 0.0, 132, 137, 54], [-1.0, 132, 137, 54]],
      #red
      [ [ 1.0 , 249, 225, 163],[ 0.5 , 239, 195, 103], [ 0.25, 214, 115,  72], [ 0.0, 100, 40,  25], [ -1.0,   0,  0,  0]],
      #stone
      [[ 1.0 , 236, 219, 196], [ 0.7, 190, 179,  171], [ 0.35, 174, 180,  170], [ 0.0, 114, 114,  114], [ -1.0,   0,  0,  0]],
      #grayscale
      [[ 1.0, 255, 255, 255], [ 0.0, 0, 0, 0], [-1.0, 0, 0, 0]]
      )

# Linear color gradient computation from: BDi_0.0.3.py
def col_gradient(value, col1, col2):
    delta = (value-col1[0]) / (col2[0]-col1[0])
    jitter = random() * 0.05 * delta
    if (delta+jitter)<1.0:  delta = delta+jitter
    else:                   delta = delta-jitter
    gg=col1[2]+(col2[2]-col1[2])*delta
    bb=col1[3]+(col2[3]-col1[3])*delta
    rr=col1[1]+(col2[1]-col1[1])*delta
    return ( NMesh.Col(int(round(rr)),int(round(gg)),int(round(bb))) ), ( ((round(rr)),(round(gg)),(round(bb))) )

######################################################
#------------------------------
def reset():
   global NSize, iScale, invert, FalTyp, Fall, FalHard, offset, slev, plev, pslope, platnoise, edgesatsea
   global RaPos, RaSiz, RaHgh, RaCha, RaTyp, Noise_Type, Noise_Basis
   global Distortion_Noise, Damnt, VFunc, VExp, VDep
   global Ha, La, Oc, Of, Ga, Ri, Ri_S, Ri_B, Depth, Hard, Amp, Freq, Lx, Ly, Lz, Sx, Sy
   global FX, EffectZ, FXnoise, FXblend, Flt, FilterZ, filtF, filtG, lower, upper
   global fxSize, fxSx, fxSy, fxLx, fxLy, fxIntens, fxOfst, fxgrad, fxA, fxB, fxC, fxD

   RaPos = Create(1); RaSiz = Create(0); RaHgh = Create(0); RaCha = Create(0); RaTyp = Create(0)
   FalTyp = Create( 2 ); Fall = Create( 1.0 ); FalHard = Create( 1.0 )
   plev = Create( 1.0 ); slev = Create( 0.0 ); edgesatsea = Create(0); pslope = Create(0); platnoise = Create(0)
   NSize = Create(1.0); iScale = Create(0.25); invert = Create(0); offset = Create(0.0)
   Sx = Create(1.0); Sy = Create(1.0); Lx = Create(0.0); Ly = Create(0.0); Lz = Create(0.0)
   Noise_Type = Create(3); Noise_Basis = Create(0)
   Oc = Create(5.0); La = Create(3.0); Ha = Create(1.0); Ga = Create(1.0); Of = Create(1.0)
   Ri = Create(1.0); Ri_S = Create(1.0); Ri_B = Create(0)
   Depth = Create(2); Hard = Create(0); Amp = Create(0.5); Freq = Create(2.0)
   Distortion_Noise = Create(0); Damnt = Create(2.0)
   VFunc = Create(0); VExp  = Create(2.5); VDep  = Create(0)
   FX = Create(0); EffectZ = Create(0); fxgrad = Create(0); fxA = Create(2); fxB = Create(0); fxC = Create(1.0); fxD = Create(2.0)
   fxSize = Create(1.0); fxSx = Create(1.0); fxSy = Create(1.0); fxLx = Create(0.0); fxLy = Create(0.0)
   fxIntens= Create(0.25);  fxOfst  = Create(0.0); FXnoise  = Create(0); FXblend  = Create(1)
   Flt = Create(0); FilterZ = Create(0); filtF = Create(1.0); filtG = Create(0.25); lower = Create(0.0); upper = Create(1.0)
reset()
#------------------------------
def resetMe():
   global MEName, preset, pview, Auto_Update, Quality, resolution, Q_T, smooth, Rseed, RanMod
   MEName = Create("Landscape"); preset = Create(0); pview = Create(0)
   Auto_Update = Create(1); Quality = Create(3); resolution = Create(50)
   Q_T = Create(0); smooth = Create(0)
   RanMod = Create(0); Rseed = Create(0)
resetMe()

### Presets ----------------------------------
#------------------------------
def Preset_Noise():
   global preset, NSize, Lx, Ly, Lz, Sx, Sy, iScale, invert, offset, slev, plev, pslope, platnoise, FalTyp, Fall, FalHard
   global Noise_Type, Noise_Basis, Distortion_Noise, Damnt, Distortion_Noise
   global Ha, La, Oc, Of, Ga, Depth, Hard, Amp, Freq, VFunc, VDep, Ri, Ri_S, Ri_B
   global FX, EffectZ, FXblend, FXnoise, FXblend, FilterZ, filtF, filtG, Flt
   global fxSize, fxSx, fxSy, fxLx, fxLy, fxIntens, fxOfst

   if preset.val >2: ## randomise position ##
      Lx = Create( 0.0+(random() * 1000 ) ); Ly = Create( 0.0+(random() * 1000 ) ); Lz = Create( 0.0+(random() * 1000 ) )
   if preset.val == 2: # Original
      Noise_Type = Create(5); NSize = Create(0.25); iScale = Create(0.1); FalTyp = Create(0); Oc = Create(2.0); La = Create(2.0)
   elif preset.val == 3: # Blender hills
      Noise_Type = Create(5); Depth = Create(2)
   elif preset.val == 4: # Stones hills
      NSize = Create(0.5); Of = Create(0.9); FX = Create(1); EffectZ = Create(8); FXblend = Create(9); fxIntens = Create(0.125); fxOfst = Create(0.1); fxSize = Create(3.0)
   elif preset.val == 5: # Round hills
      Noise_Type = Create(6); VFunc = Create(1); iScale = Create(0.5); invert = Create(1); offset = Create(-0.25); NSize = Create(0.5)
   elif preset.val == 6: # Plateau
      Noise_Basis = Create(3); NSize = Create(0.5); iScale = Create(0.5); plev = Create(0.25); pslope = Create(1); slev = Create(-0.25); FalTyp = Create(1) 
      EffectZ = Create(7); FXblend  = Create(2); platnoise = Create(1)
   elif preset.val == 7: # Shattered
      Noise_Type  = Create(2); Noise_Basis = Create(7); Of = Create(2.0); Ga = Create(2.0); NSize = Create(0.25); offset = Create(-0.25); FalHard = Create(2.5) 
   elif preset.val == 8: # Chaotic
      NSize  = Create(0.25); Oc = Create(6.0); La = Create(2.0); Ha = Create(0.8); Of = Create(0.4)
   elif preset.val == 9: # RidgedMF
      Noise_Type = Create(1); La = Create(2.0); Ha = Create(0.8); Ga = Create(2.5)
   elif preset.val == 10: # Distorted hTerrain
      Noise_Type = Create(13); Ri = Create(-1.0); Ri_S = Create(0.75); Ri_B = Create(3)
   elif preset.val == 11: # Cauliflower
      Noise_Type = Create(2); Noise_Basis = Create(3); La = Create(5.0); Ga = Create(5.0); iScale = Create(0.35); invert = Create(1); NSize = Create(0.5); FalTyp = Create(1)
   elif preset.val == 12: # Ridges
      Noise_Type = Create(4); Noise_Basis = Create(3); NSize = Create(0.5); iScale = Create(0.5); offset = Create(0.1); Ha = Create(1.5)
   elif preset.val == 13: # Crystalline
      Noise_Type = Create(2); Noise_Basis = Create(4); iScale = Create(0.75); invert = Create(1); offset = Create(0.25)
   elif preset.val == 14: # Warped
      NSize  = Create(0.5); Of = Create(0.5); Flt = Create(1); FilterZ = Create(1)
   elif preset.val == 15: # ChebyTech
      Noise_Type = Create(6); VFunc = Create(3); VDep = Create(1); FalTyp = Create(0); plev = Create(0.2); NSize  = Create(0.25); iScale = Create(0.6)
   elif preset.val == 16: # CellNoise
      Noise_Type  = Create(5); Noise_Basis = Create(9); FalHard = Create(10.0)
   elif preset.val == 17: # Canyon
      NSize = Create(0.5); plev = Create(0.25); platnoise = Create(1); FalHard = Create(2.5); iScale = Create(0.5); offset = Create(-0.25); FilterZ = Create(3)
   elif preset.val == 18: # Ring o Rock
      Noise_Type = Create(2); Noise_Basis = Create(7); Of = Create(2.0); Ga = Create(2.0); NSize = Create(0.5); offset = Create(-0.6)
      iScale = Create(0.5); FX = Create(1); EffectZ = Create(2); FXblend = Create(2)
   elif preset.val == 19: # xtreme Peaks
      Noise_Type = Create(10); iScale = Create(0.5); Flt = Create(1); FilterZ = Create(2)
   elif preset.val == 20: # hardturb
      Noise_Type = Create(5); Hard = Create(1); Depth = Create(3); Amp = Create(0.65); invert = Create(1); offset = Create(0.5); iScale = Create(0.5); FalTyp = Create(1)
   elif preset.val == 21: # Cliff
      FalTyp = Create(0); platnoise = Create(1); iScale = Create(0.5); FX = Create(1); EffectZ = Create(4); FXblend = Create(2)
      fxIntens= Create(1.0); fxSx  = Create(0.0); fxSy  = Create(0.5)

## Randomise ------------------------------------------------------
###-----------------------------------
def Random_N():
   global iScale, invert, offset, NSize
   global RaPos, RaSiz, RaCha, RaHgh, RaTyp, Rseed
   global Noise_Type, Noise_Basis, Distortion_Noise, VFunc
   global Lx, Ly, Lz, Sx, Sy, Ha, La, Oc, Of, Ga, Ri, Ri_S, Ri_B
   global Depth, Hard, Amp, Freq, Damnt, VExp, VDep

   setRandomSeed(Rseed.val)
   inv1=inv2=1
   randinv_one = int( random() * 2)
   if randinv_one == 1:   inv1=-1
   randinv_two = int( random() * 2)
   if randinv_two == 1:   inv2=-1
   # randomise Position #--------------------------------
   if RaPos.val == 1:
      Lx = Create( (random() * 1000.0 ) * inv1 ); Ly = Create( (random() * 1000.0 ) * inv2 ); Lz = Create( (random() * 1000.0 ) * inv2 )
   # randomise Size #------------------------------------
   if RaSiz.val == 1:
      NSize = Create( 0.1+(random() * 1.0 ) ); Sx = Create( 1.0+(random() * 0.5 ) ); Sy = Create( 1.0+(random() * 0.5 ) )
   # randomise Height #----------------------------------
   if RaHgh.val == 1:
      iScale = Create( 0.1+( random() * 1.0 ) ); invert = Create( int( random() * 2) ); offset = Create( (random() * 0.10 ) * inv2 )
   # randomise Character #--------------------------------
   if RaCha.val == 1:
      Oc = Create( 1.0+( random() * 7.0 ) ); La = Create( 1.0+( random() * 5.0 ) ); Ga = Create( 0.5+( random() * 5.5 ) ); Ha = Create( 0.5+( random() * 1.5 ) ); Of = Create( 0.5+( random() * 1.0 ) )
      Ri = Create( 0.2+( random() * 1.0 ) * inv1); Ri_S = Create( 0.3+( random() * 0.9 ) ); Ri_B = Create( int( random() * 10) )
      Depth = Create( int( random() * 10) ); Hard = Create( int( random() * 2) ); Amp = Create( 0.25+( random() * 1.0 ) ); Freq = Create( 0.5+( random() * 2.5 ) )
      Distortion_Noise = Create( int( random() * 10) ); Damnt = Create( 0.5+( random() * 3.0 ) )
      VFunc = Create( int( random() * 7) ); VDep = Create( int( random() * 3) ); VExp = Create( ( random() * 10.0 ) )
   # randomise Type #-----------------------------------
   if RaTyp.val == 1:
      Noise_Type = Create( int( random() * 10) ); Noise_Basis = Create( int( random() * 10) )

## Noise --------------------------------------------------------
###-----------------------------------
def Noise_func(x,y,z):
   global iScale, invert, offset, NSize, Sx, Sy, Lx, Ly, Lz, Noise_Type, Noise_Basis
   global Distortion_Noise, Damnt, VFunc, VExp, VDep
   global Ha, La, Oc, Of, Ga, Ri, Ri_S, Ri_B, Depth, Hard, Amp, Freq

   x1 = ( x / Sx.val / NSize.val + Lx.val )
   y1 = ( y / Sy.val / NSize.val + Ly.val )
   z1 = ( z * 1.0 + Lz.val )
   Basis = Noise_Basis.val
   if Basis == 9:   Basis = 14
   if Noise_Type.val == 0:
         nz = multiFractal((x1,y1,z1),Ha.val, La.val, Oc.val, Basis)
   elif Noise_Type.val == 1:
         nz = ridgedMFractal((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Ga.val, Basis)
   elif Noise_Type.val == 2:
         nz = hybridMFractal((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Ga.val, Basis)
   elif Noise_Type.val == 3:
         nz = heteroTerrain((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Basis)
   elif Noise_Type.val == 4:
         nz = fBm((x1,y1,z1),Ha.val, La.val, Oc.val, Basis)
   elif Noise_Type.val == 5:
         nz = turbulence((x1,y1,z1),1+Depth.val, Hard.val, Basis,Amp.val,Freq.val)+1.0
   elif Noise_Type.val == 6:
         nz = voronoi((x1,y1,z1),VFunc.val,VExp.val)[0][VDep.val]
   elif Noise_Type.val == 7:
         vlBasis = Distortion_Noise.val
         if vlBasis == 9:   vlBasis = 14
         distortion = Damnt.val
         nz = vlNoise((x1,y1,z1), distortion, vlBasis, Basis)+1
   elif Noise_Type.val == 8:
         nz = noise((x1,y1,z1),Basis)
   elif Noise_Type.val == 9:
         nz = cellNoise((x1,y1,z1))
   elif Noise_Type.val == 10:
         ht = heteroTerrain((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Basis)
         nz = (Dist( ( ht**2),( ht**2) )**2)*0.025
   elif Noise_Type.val == 11:
         ht = heteroTerrain((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Basis)
         ca = WaveFunc( ht , Ri.val , (0.1/Ri.val*pi) , 1 )
         nz = BModFunc( ht , ca , 1 )*2.0
   elif Noise_Type.val == 12:
         ribasis = Ri_B.val
         if ribasis == 9: ribasis = 14
         nz = heteroTerrain((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Basis)
         nz += Ri.val*ridgedMFractal((x1/Ri_S.val,y1/Ri_S.val,z1),Ha.val,La.val,Oc.val,Of.val,Ga.val,ribasis)
   elif Noise_Type.val == 13:
         ribasis = Ri_B.val
         if ribasis == 9: ribasis = 14
         vlBasis = Distortion_Noise.val
         if vlBasis == 9:   vlBasis = 14
         distortion = Damnt.val
         nz = heteroTerrain((x1,y1,z1),Ha.val, La.val, Oc.val, Of.val, Basis)
         nz += Ri.val*vlNoise((x1/Ri_S.val,y1/Ri_S.val,z1),distortion,vlBasis,ribasis)
   else:
         nt1 = (turbulence(( x1 , y1 , z1), 0, 1, 1, 0.5, 2.0 )*5-0.25)
         nt2 = (turbulence(( x1 , y1 , z1),1+Depth.val, Hard.val, Basis,Amp.val,Freq.val)*0.1)
         nz  = ( ClipFunc( nt1, 0.0, 0.25 ) +  (nt1*0.05) + nt2 )*4.0
   if invert.val == 1:
      nz *= iScale.val/2
      z = -nz + iScale.val
   else:   z = nz * iScale.val/2
   z += offset.val

   return x,y,z

## Effects  -----------------------------------------------
###------------------------------------------
def StonesFunc(x,y,z):
   return x,y, ClipFunc( (noise((10*x,10*y,z),1)*0.75-0.25), 0.0, 0.25 )
def SparseCracksFunc(x,y,z):
   return x,y, ClipFunc( (turbulence((x*2,y*2,z),0,1,1,0.5,2.0 )*4-0.25), 0.0, 0.25 )
def CratersFunc(x,y,z):
   return x,y,  ClipFunc( (noise((2*x,2*y,z),3)*1.0+0.5), -0.5, 0.0 )
def SawFunc(x,y,z):
   wa1 = WaveFunc( x+y , 1.0 , 1.0, 3 )
   wa2 = WaveFunc( (y+wa1*0.5) , 1.0 , 1.0, 3 )
   return x,y, BModFunc( x*wa2, y*wa1, 7 )
def Dist(x,y):
   return sqrt( (x*x)+(y*y) )
def ClipFunc( input, ClipMin, ClipMax ):
   if ( input < ClipMin ):  input = ClipMin
   if ( input > ClipMax ):  input = ClipMax
   return input
def maxFunc( c1, c2 ):
   if ( c1 > c2 ): c2 = c1
   return c2
def minFunc( c1, c2 ):
   if ( c1 < c2 ): c2 = c1
   return c2
###-----------------------------------
def BModFunc( c1, c2, bmod ):
   if   bmod == 0:  return  ( c2 )                      #0  c2
   elif bmod == 1:  return  ( c1*(1.0-0.5) + c2*0.5 )   #1  blend
   elif bmod == 2:  return  ( c1 + c2 )                 #2  add
   elif bmod == 3:  return  ( c1 - c2 )                 #3  subtract
   elif bmod == 4:  return  ( c1 * c2 )                 #4  multiply
   elif bmod == 5:  return  (abs( c1 - c2 ))            #5  difference
   elif bmod == 6:  return  1.0-((1.0-c1)*(1.0-c2)/1.0) #6  screen
   elif bmod == 7:  return  ( c1 + c2 ) % 1.0           #7  add modulo
   elif bmod == 8:  return  minFunc( c1, c2 )           #8  min
   elif bmod == 9:  return  maxFunc( c1, c2 )           #9  max
   #### elif bmod == 10:                                #10 warp
   else:            return  ( c1 )                      #11 c1
###-----------------------------------
def WaveFunc( input, numb, scale, type ):
   if   type == 1:  return  (  sin( input * numb*pi ) * scale )
   elif type == 2:  return  (  cos( input * numb*pi ) * scale )
   elif type == 3:  return  (  ( input * numb ) % 1.0 * scale )
   elif type == 4:  return  (  int( input * numb ) * scale ) / ( numb )
   else:            return  (  ( input * numb*pi ) * scale )

###-----------------------------------
def Z_Effect(x,y,z):
   global EffectZ, FXnoise, FXblend
   global fxSize, fxSx, fxSy, fxLx, fxLy, fxIntens, fxOfst, fxgrad, fxA, fxB, fxC, fxD

   basis = FXnoise.val
   if basis == 9: basis = 14
   Nfunc = Noise_func(x,y,z)
   if EffectZ.val == 0:  z = Nfunc[2]
   else:
      phi = 3.14159265359
      x2 = ( x * fxSize.val * fxSx.val - fxLx.val )
      y2 = ( y * fxSize.val * fxSy.val - fxLy.val )
      if   EffectZ.val == 1:  ez = ( x * sin( Dist( x2,y2 ) * phi*2 ) - y * cos( Dist( x2,y2 ) * phi*2 ) )
      elif EffectZ.val == 2:  ez = sin( -Dist( x2,y2 ) * phi*2 )
      elif EffectZ.val == 3:  ez = sin( ( x2 * phi ) + sin( y2 * phi ) )
      elif EffectZ.val == 4:  ez = sin( x2*phi + y2*phi )
      elif EffectZ.val == 5:  ez = cos( x2 * phi ) * sin( y2 * phi )
      elif EffectZ.val == 6:  ez = BModFunc(WaveFunc(y2,1.0,1.0,3), WaveFunc(x2,1.0,1.0,3), 1 )
      elif EffectZ.val in [7,8,9,10]:
         if   EffectZ.val == 7:  nz = SawFunc(x2,y2,0.0)
         elif EffectZ.val == 8:  nz = StonesFunc(x2,y2,0.0)
         elif EffectZ.val == 9:  nz = CratersFunc(x2,y2,0.0)
         elif EffectZ.val == 10: nz = SparseCracksFunc(x2,y2,0.0)
         ez = nz[2]
      elif EffectZ.val == 11:
         ez = turbulence((x2+2.0,y2-2.0,0.0),1+fxA.val, fxB.val, basis, 0.5,2.0)+1.0
      elif EffectZ.val == 12:
         ez = multiFractal((x2,y2,0.0),fxC.val, fxD.val, fxA.val, basis)
      elif EffectZ.val == 13:
         bs = fxA.val
         if bs == 9: bs = 14
         ez = vlNoise((x2,y2,0.0), fxC.val, bs, basis)+1
      elif EffectZ.val == 14:
         value = (x2*x2 + y2*y2)/0.5
         if value > 1.0:  radg = 0.0
         radg = 1.0 - value
         grad = [ x2, -x2, y2, -y2, radg ]
         ez = grad[ fxgrad.val ]
      elif EffectZ.val == 15:
         ez = ( fxSize.val * random() )

      ez *= fxIntens.val
      ez += fxOfst.val
      Nfunc=Noise_func(x,y,z)
      if FXblend.val == 10:
         Wfunc = Noise_func( x-ez, y-ez, 0.0 )
         z = Wfunc[2]
      else:
         z = BModFunc( Nfunc[2], ez , FXblend.val )
   return x,y,z

## Filters -------------------------
###-----------------------------------
def  Z_Filter(x,y,z):
   global Flt, FilterZ, filtF, filtG, lower, upper

   Efunc = Z_Effect(x,y,z)
   if  FilterZ.val == 0:  z = Efunc[2]
   elif FilterZ.val == 1:
      zn    = Z_Effect(x,y,z)
      Sfunc = Z_Effect(x-(zn[2]*filtF.val+filtG.val), y-(zn[2]*filtF.val+filtG.val), z )
      z = Sfunc[2]
   elif FilterZ.val == 2:
      z = (Dist( (Efunc[2]**2),(Efunc[2]**2) )**2)*2.0
   elif FilterZ.val in [3,4,5,6,7]:
      canion1      = ( Efunc[2], (filtF.val*10.0), (0.1/(filtF.val*10.0)*pi), 2 , Efunc[2], 2 )
      canion2      = ( (Dist( Efunc[2]**2 ,Efunc[2]**2 )**2),(filtF.val*10.0),(0.1/(filtF.val*10.0)*pi),1 , (Dist( Efunc[2]**2 ,Efunc[2]**2 )**2),2 )
      sawf         = ( Efunc[2], filtF.val*1.0, filtG.val , 3 , 0, 0 )
      poster       = ( Efunc[2]*2.0, filtF.val*20.0 , filtG.val*2.0 ,4 , 0, 0)
      posternoise  = ( Efunc[2]*2.0, filtF.val*20.0 , filtG.val*2.0 ,4 ,  Efunc[2]*2.0, 1)
      FiltType = ( 0,0,0, canion1, canion2, sawf, poster, posternoise )
      FTyp     = FiltType[ FilterZ.val ]
      Wa  = WaveFunc( FTyp[0], FTyp[1], FTyp[2], FTyp[3] )
      z   = BModFunc( FTyp[4] , Wa , FTyp[5] )
   elif FilterZ.val == 8:
      z = SmoothStep( Efunc[2], lower.val, upper.val )*filtF.val
   return x,y,z
###-----------------------------------
def SmoothStep( input, low, up ):
   value = input
   if value < low:  return 0.0
   elif value > up: return 1.0
   else:
      delta = up - low
      if fabs(delta) > 0.000001:
         value = (value - low) / delta
         return value * value * (3.0 - 2.0 * value)
      else:
         if value > up:
            return 1.0

## Limit height --------------------------------------------------------
###-----------------------------------
def Z_Limit(x,y,z):
   global FalTyp, Fall, FalHard, slev, edgesatsea, plev, pslope, platnoise

   plateau  = plev.val; sealevel = slev.val
   if edgesatsea.val == 1:
       edgesatsealevel = slev.val
   else:
       edgesatsealevel = 0.0

   Ffunc  = Z_Filter(x,y,z)
   height = Ffunc[2] - edgesatsealevel
   if FalTyp.val != 0:
      if FalTyp.val == 2: fha = 2*FalHard.val
      else:               fha = 1*FalHard.val
      distype = ( sqrt((x*x + y*y)**fha), sqrt((x*x)**fha+(y*y)**fha), sqrt(y*y)**fha, sqrt(x*x)**fha )
      dist = distype[ FalTyp.val-1 ]
      height = Ffunc[2] - edgesatsealevel
      radius = 1.0 * Fall.val
      if( dist <  radius ):
         dist = dist / radius
         dist = ( (dist) * (dist) * ( 3-2*(dist) ) )
         z = ( height - height * dist ) + edgesatsealevel
      else:  z = edgesatsealevel
   else:     z = Ffunc[2]

   Nfunc = Noise_func(x,y,z)
   flatnoise = Nfunc[2] * 0.1
   slope = abs( (x/pi-1)*(y/pi+1) )
   if pslope.val == 1:
      if platnoise.val == 1:
         if ( z > plateau * slope + flatnoise ):  z = plateau * slope + flatnoise
      else:
         if ( z > plateau * slope ):              z = plateau * slope
   if pslope.val == 0:
      if platnoise.val == 1:
         if ( z > plateau + flatnoise ):  z = plateau + flatnoise
      else:
         if ( z > plateau ):              z = plateau
   if ( z < sealevel ):  z = sealevel

   return x,y,z

## Mesh -----------------------------------------------------------
###-----------------------------------
def Crea(): 
   global MEName, Quality, resolution, Q_T, smooth, submode, sub, vcolours, preGrad

   reso = ( 32+1, 50+1, 64+1, 100+1, 128+1, 150+1, 200+1, 256+1, 512+1, resolution.val+1 )
   n = reso[ Quality.val ]

   try:
      o=Object.Get('Terrainn')
      me=o.getData()
      UPDATE=1	
   except:
      o=Object.New('Mesh','Terrainn')
      sc.link(o)
      me = NMesh.GetRaw()
      UPDATE=0

   me.verts=[]
   me.faces=[]
   COL=[]
   height = 0
   # Vertices -----------------------------------
   i=j=h=0.0
   for i in range(0, n, 1):
      i = i-(n-1)/2
      i = i*2.0/(n-1)
      for j in range(0, n, 1):
         j = j-(n-1)/2
         j = j*2.0/(n-1)
         Result = Z_Limit(i,j,h)
         height = Result[2]
         v=NMesh.Vert(i, j, height)
         me.verts.append(v)
         #-----------------------------------
         for cc in range(len(colors[ preGrad.val ])):
              if ( height  > colors[ preGrad.val ][cc][0]):
                      COL.append( col_gradient( height ,colors[ preGrad.val ][cc],colors[ preGrad.val ][cc-1])[0] )
                      break
   me.hasVertexColours(1)
   ##--------------------------------------
   if Q_T.val == 1:
      for i in range(n-1):
         for j in range(n-1):
            f = NMesh.Face()
            f.v.append(me.verts[n*i+j])
            f.v.append(me.verts[n*(i+1)+j])
            f.v.append(me.verts[n*i+(j+1)])
            if vcolours.val !=0:
               f.col.append(COL[n*i+j])
               f.col.append(COL[n*(i+1)+j])
               f.col.append(COL[n*i+(j+1)])
            f.smooth = smooth.val
            me.faces.append(f)
            f = NMesh.Face()
            f.v.append(me.verts[n*i+(j+1)])
            f.v.append(me.verts[n*(i+1)+j])
            f.v.append(me.verts[n*(i+1)+(j+1)])
            if vcolours.val !=0:
               f.col.append(COL[n*i+(j+1)])
               f.col.append(COL[n*(i+1)+j])
               f.col.append(COL[n*(i+1)+(j+1)])
            f.smooth = smooth.val
            me.faces.append(f)
   else:
      for i in range(n-1):
         for j in range(n-1):
            f= NMesh.Face()
            f.v.append(me.verts[i*n+j])
            f.v.append(me.verts[(i+1)*n+j])
            f.v.append(me.verts[(i+1)*n+j+1])
            f.v.append(me.verts[i*n+j+1])
            if vcolours.val !=0:
               f.col.append(COL[i*n+j])
               f.col.append(COL[(i+1)*n+j])
               f.col.append(COL[(i+1)*n+j+1])
               f.col.append(COL[i*n+j+1])
            f.smooth = smooth.val
            me.faces.append(f)

   if UPDATE :
      me.update()
   else :
      o.link(me)
   o.makeDisplayList()
   Blender.Redraw()


### G.U.I.  ,   Preview  --------------------------- 
#---------------------------------------------------------------------- 
def Preview_Noise():
   global pview, preGrad
   for x in range(-64, 64):
      for y in range(-64, 64):
         poco = Z_Limit(x/64.0, y/64.0, 0.0)
         if pview.val == 1:
            r,g,b = (poco[2]+1)/2 , (poco[2]+1)/2 , (poco[2]+1)/2
            glColor3f(r,g,b)
         elif pview.val == 2:
            r,g,b = (poco[2]) , (poco[2]) , (poco[2])
            glColor3f(r,g,b)
         elif pview.val == 3:
            for cc in range(len(colors[ preGrad.val ])):
               if ( poco[2]  > colors[ preGrad.val ][cc][0]):
                  r,g,b = (col_gradient( poco[2] ,colors[ preGrad.val ][cc],colors[ preGrad.val ][cc-1] )[1] )
                  break
            glColor3f(r/255.0,g/255.0,b/255.0)

         glRecti(x+135, y+307, x+136, y+308)
#------------------------------------
def ColBox(x,y, w, h, r, g, b):
   glColor3f(r, g, b)
   glRecti(x, y, w, h)
###----------------------------------- 
def GUI():
   global MEName, preset, pview, Auto_Update, Quality, resolution, Q_T, smooth, submode, sub
   global NSize, iScale, invert, FalTyp, Fall, FalHard, offset, Lx, Ly, Lz, Sx, Sy, slev, plev
   global RaPos, RaSiz, RaHgh, RaCha, RaTyp, Rseed, RanMod, Flt, FilterZ, filtF, filtG, lower, upper
   global Noise_Type, Noise_Basis, Distortion_Noise, Damnt, VFunc, VExp, VDep
   global Ha, La, Oc, Of, Ga, Ri, Ri_S, Ri_B, Depth, Hard, Amp, Freq
   global FX, EffectZ, FXnoise, FXblend, fxSize, fxSx, fxSy, fxLx, fxLy
   global fxIntens, fxOfst, fxgrad, fxA, fxB, fxC, fxD
   global pslope, platnoise, edgesatsea
   global vcolours, ColScreen, colorcontrols, colsel, curcol, preGrad, newheight

   BGL.glClearColor(0.66, 0.66, 0.66, 1)
   BGL.glClear(BGL.GL_COLOR_BUFFER_BIT)
   glColor3f(0.73,0.73,0.73)
   glRecti(5, 5, 265, 227)
   glColor3f(0.61,0.61,0.61)
   if pview.val !=0:
      glRecti(5, 225, 265, 390)
      Preview_Noise()
   else:
      glRecti(5, 225, 265, 242)
   glColor3f(1.0,1.0,1.0)
   glRasterPos2d(140, 230)
   Text("A.N.T.Landscape 1.03",'small')

   colorcontrols = [[], [], [], []]
   ## Colors ##-----------------------------------
   if ( ColScreen.val == 1 ):
      ColScreen = Toggle("Col.",EV_NOEVENT, 160,205, 30,15, ColScreen.val,"Change colors")
      Button("Update", 103, 195, 205, 45, 15,"Update mesh.")
      #----------------------------------------------
      glColor3f(1.0,0.0,0.0); glRasterPos2d(10, 190);  Text("Red",'small')
      glColor3f(0.0,1.0,0.0); glRasterPos2d(60, 190);  Text("Green",'small')
      glColor3f(0.0,0.0,1.0); glRasterPos2d(110, 190); Text("Blue",'small')
      glColor3f(0.0,0.0,0.0); glRasterPos2d(195, 190); Text("Height",'small')
      #----------------------------------------------
      for c in range ( len(colors[ preGrad.val ]) ):
         #- Height ---------------------------------------
         if ( c != ( len(colors[ preGrad.val ]) -1 ) ):
            ccontrol = Create(colors[ preGrad.val ][c][0])
            ccontrol = Number("", EVB_H+c, 195, 170-20*c, 45, 15, ccontrol.val, -1.0, 1.0, "Color above this Height")
            colorcontrols[0].append(ccontrol)
         #- Red ---------------------------------------
         ccontrol = Create(colors[ preGrad.val ][c][1])
         ccontrol = Number("", EVB_R+c, 10, 170-20*c, 45, 15, ccontrol.val, 0, 255, "Red")
         colorcontrols[1].append(ccontrol)
         #- Green ---------------------------------------
         ccontrol = Create(colors[ preGrad.val ][c][2])
         ccontrol = Number("", EVB_G+c, 60, 170-20*c, 45, 15, ccontrol.val, 0, 255, "Green")
         colorcontrols[2].append(ccontrol)
         #- Blue ---------------------------------------
         ccontrol = Create(colors[ preGrad.val ][c][3])
         ccontrol = Number("", EVB_B+c, 110, 170-20*c, 45, 15, ccontrol.val, 0, 255, "Blue")
         colorcontrols[3].append(ccontrol)
         #- Col -------------------------------------
         ColBox( 160,185-20*c, 190,170-20*c, (colors[ preGrad.val ][c][1])/255.0, (colors[ preGrad.val ][c][2])/255.0, (colors[ preGrad.val ][c][3])/255.0 )
         #- Delete ----------------------------------
         if (c!=0) and (c!=(len(colors[ preGrad.val ])-1)):
            PushButton("X", EVB_DEL+c , 245,170-20*c, 15,15, "Remove color")

      #- Add New ------------------------------------
      Button("Add",EV_NEW, 60, 205, 45, 15, "Add new color at given height")
      newheight = Number("", EV_NOEVENT+c, 110, 205, 45, 15, newheight.val, -1.0, 1.0, "Height for new color")
      #- Preset grad's ------------------------------
      gradsmnu = "Gradients %t|Default %x0|Natural %x1|Dry %x2|Red %x3|Stone %x4|Greyscale %x5"
      preGrad = Menu(gradsmnu,EV_NOEVENT, 10,205, 45,15, preGrad.val,"Preset gradients")
   else:
      ColScreen = Toggle("Colors",EV_NOEVENT, 140,205, 60,15, ColScreen.val,"Change colors")
      vcolours = Toggle("VertCol.", 102,210,205,50,15, vcolours.val,"Faces : Enable VertexColors.")
      ## Noise ##
      FX = Toggle( "Effects" ,31,10,205,60,15,FX.val,"Effects")
      Flt = Toggle( "Filters" ,32,70,205,60,15,Flt.val,"Filter")
      nbasis = "Noise Basis%t|Blender Original%x0|Original Perlin%x1|Improved Perlin%x2|Voronoi_F1%x3|Voronoi_F2%x4|Voronoi_F3%x5|Voronoi_F4%x6|Voronoi_F2-F1%x7|Voronoi Crackle%x8|CellNoise%x9"
      ntype  = "Noise Type's %t|multiFractal %x0|ridgedMFractal %x1|hybridMFractal %x2|heteroTerrain %x3|fBm %x4|turbulence %x5|Voronoi %x6|DistortedNoise %x7|noise %x8|cellNoise %x9| %l|Peaked hTerrain %x10|Layered hTerrain %x11|hTerrain + ridgedMF %x12|hTerrain + DistortedN %x13|turbulence Cracks %x14"
      votype = "Voronoi%t|Distance %x0|Distance Squared %x1|Manhattan %x2|Chebychev %x3|Minkovsky 1/2 %x4|Minkovsky 4 %x5|Minkovsky %x6"
      if FX.val !=1 and Flt.val !=1:
         Noise_Type = Menu(ntype,102,10,60,120,20, Noise_Type.val, "Noise Type")
         if Noise_Type.val == 6:
            VFunc = Menu(votype, 102, 10,85,120,15, VFunc.val)
         elif Noise_Type.val != 9:
            Noise_Basis = Menu(nbasis,102,10,85, 120, 15, Noise_Basis.val, "Noise Basis")
         if Noise_Type.val in [0,1,2,3,4, 10,11,12,13]:
            Oc = Slider("Octs: ", 102, 10,180,120,15, Oc.val,0.0,8.0 ,0, "Musgrave:  Octaves")
            La = Slider("Lacu: ", 102, 10,165,120,15, La.val,0.0,6.0 ,0, "Musgrave:  Lacunarity")
            Ha = Slider("H: ", 102, 10,150,120,15, Ha.val,0.0,2.0 ,0, "Musgrave:  H")
            if Noise_Type.val in [1,2,12]:
               Ga = Slider("Gain: ", 102, 10,120,120,15, Ga.val,0.0,6.0 ,0, "Musgrave:  Gain")
            if Noise_Type.val in [1,2,3,10,11,12,13]:
               Of = Slider("Ofst: ", 102, 10,135,120,15, Of.val,0.0,6.0 ,0, "Musgrave:  Offset")
            if Noise_Type.val == 11:
               Ri = Number("Layers:", 102, 10,120,120,15, Ri.val,0.0,10.0 ,"number of Layers")
            if Noise_Type.val == 12:
               Ri = Number(":", 102, 10,105,50,15, Ri.val,-2.0,2.0 ,"ridgedMF intensity")
               Ri_S = Number(":", 102, 60,105,50,15, Ri_S.val,0.001,10.0 ,"ridgedMF Size")
               Ri_B = Menu(nbasis, 102, 110,105,20,15, Ri_B.val,"ridgedMF Noise basis"+" = "+str(int(Ri_B.val)) )
            elif Noise_Type.val == 13:
               Ri = Number(":", 102, 10,105,40,15, Ri.val,-2.0,2.0 ,"Distortion intensity")
               Ri_S = Number(":", 102, 50,105,40,15, Ri_S.val,0.001,10.0 ,"Distortion Size")
               Damnt = Number("Distortion: ",102,90,105,40,15, Damnt.val, 0.0,10.0,"Distortion amount")
               Ri_B = Menu(nbasis, 102, 10,120,60,15, Ri_B.val,"Distortion Noise basis")
               Distortion_Noise = Menu(nbasis ,102,70,120,60,15, Distortion_Noise.val, "Distortion Noise")
         elif Noise_Type.val in [5,14]:
            if Hard.val == 0: Hardtext ="Soft"
            elif Hard.val == 1: Hardtext ="Hard"
            Hard = Toggle( Hardtext , 102, 10,135,60,15,Hard.val, "Turbulence:  Soft noise / Hard noise")
            Amp = Slider("Amp:", 102,10,165,120,15,Amp.val,0.0,10.0, 0, "Turbulence: Ampscale ")
            Freq = Slider("Freq:", 102,10,150,120,15,Freq.val,0.0,10.0, 0, "Turbulence:  Freqscale")
            Depth = Number("Depth:", 102,70,135,60,15,Depth.val,0.0,10.0, "Turbulence:  Octaves")
         elif Noise_Type.val == 6:
            VDep = Number("Depth:",102,10,165,120,15,VDep.val,0,3, "Voronoi:  Depth")
            if (VFunc.val == 6):
               VExp = Slider("Exp:",102,10,150,120,15,VExp.val,0.0,10.0, 0, "Voronoi:  Minkovsky exponent")
         elif Noise_Type.val == 7:
            Distortion_Noise = Menu(nbasis ,102,10,150,120,15, Distortion_Noise.val, "DistortedNoise:  Distortion Noise")
            Damnt = Slider("Dist:",102,10, 165, 120, 15, Damnt.val, 0.0,10.0, 0, "DistortedNoise:  Distortion amount")
      elif FX.val ==1:
         glColor3f(0.61,0.61,0.61)   ##  Effects ##
         glRecti(8, 55, 132, 200)
         efxmnu = "Effect Type's %t|None %x0|Spiral %x1|Ring %x2|ZigZag %x3|Wave %x4|Bumps %x5|Sawteeth %x6|Saw-irregular %x7|Stones %x8|Craters %x9|Cracks %x10|Turbulence %x11|multiFractal %x12|DistortedNoise %x13|Gradient %x14|Random %x15"
         EffectZ = Menu(efxmnu,102,10,180,60,15, EffectZ.val, "Effect Types")
         if EffectZ.val !=0:
            blfxmnu = "Blend Type's %t|None   (Effect only) %x0|Blend %x1|Add %x2|Subtract %x3|Multiply %x4|Difference %x5|Screen %x6|Add modulo %x7|Min %x8|Max %x9|Warp %x10"
            FXblend = Menu(blfxmnu,102,70,180,60,15, FXblend.val, "Mix Effect with Noise")
            fxIntens = Number("i:",102,10,110,60,15,fxIntens.val,-10.0,10.0, "Intensity")
            fxOfst = Number("z:",102,70,110,60,15,fxOfst.val,-10.0,10.0, "Offset")
            if EffectZ.val < 15:
               fxSx = Number("x:",102,10,160,60,15,fxSx.val,0.0,25.0, "Freq.X")
               fxSy = Number("y:",102,70,160,60,15,fxSy.val,0.0,25.0, "Freq.Y")
               fxLx = Number("x:",102,10,130,60,15,fxLx.val,-25.0,25.0, "Position X")
               fxLy = Number("y:",102,70,130,60,15,fxLy.val,-25.0,25.0, "Position Y")
               if EffectZ.val in [11,12,13]:
                  FXnoise = Menu(nbasis,102,10,60,120,15,FXnoise.val, "Noise Basis" )
               if EffectZ.val == 11:
                  fxB = Toggle("Hard:",102,70,75,60,15,fxB.val)
                  fxA = Number("Oct:",102,10,75,60,15,fxA.val,0,10)
               if EffectZ.val == 12:
                  fxA = Number("Oct:",102,10,75,60,15,fxA.val,0,10)
                  fxC = Number("H:",102,70,75,60,15,fxC.val,0.0,6.0)
                  fxD = Number("La:",102,70,90,60,15,fxD.val,0.0,6.0)
               if EffectZ.val == 13:
                  fxA = Menu(nbasis,102,10,75,60,15,fxA.val, "Noise Basis" )
                  fxC = Number("Dst:",102,70,75,60,15,fxC.val,0.0,10.0)
               if EffectZ.val < 14:
                  fxSize = Number("Freq:",102,10,145,120,15,fxSize.val,0.0,25.0, "Frequency")
            if EffectZ.val == 14:
               fxgradmnu = "Gradient's %t|x %x0|-x %x1|y %x2|-y %x3|Radial %x4"
               fxgrad = Menu(fxgradmnu,102,10,145,120,15, fxgrad.val)
            if EffectZ.val == 15:
               fxSize = Number("R: ",102,10,145,120,15,fxSize.val,0.0,25.0, "Random")
      elif Flt.val ==1:
         glColor3f(0.61,0.61,0.61)   ## Filters ##
         glRecti(8, 55, 132, 200)
         filtmnu = "Filter Type's%t|None %x0|Warp %x1|Peaks %x2|Layers %x3|Peaks and Layers %x4|Saw %x5|Posterise %x6|blended Posterise %x7|SmoothStep %x8"
         FilterZ = Menu(filtmnu,102,10,180,120,15,  FilterZ.val,"Filter Type's")
         if FilterZ.val !=0:
            if FilterZ.val in [1,3,4,5,6,7]:
               filtF = Number(":",102,10,160,60,15,filtF.val, -25.0,25.0 , "Intensity" )
            if FilterZ.val in [1,5,6,7]:
               filtG = Number(":",102,70,160,60,15,filtG.val, -25.0,25.0 , "Offset" )
            if FilterZ.val == 8:
               lower = Number(":",102,10,160,60,15,lower.val, -1.0,1.0 , "Lower" )
               upper = Number(":",102,70,160,60,15,upper.val, -1.0,1.0 , "Upper" )
               filtF = Number(":",102,10,140,60,15,filtF.val, -25.0,25.0 , "Intensity" )

      Lx = Number("",102,140,50,60,15,Lx.val,-1000.0,1000.0,"Noise x position" )
      Ly = Number("",102,200,50,60,15,Ly.val,-1000.0,1000.0,"Noise y position" )
      Lz = Number("",102,200,35,60,15,Lz.val,-1000.0,1000.0,"Noise z position" )
      NSize = Number("NoiseSize: ",102,140,70, 120, 20, NSize.val, 0.001, 10.0, "Noise size")
      Sx = Number("x",102,140,90,60,15,Sx.val,0.001,10.0,"Noise x size")
      Sy = Number("y",102,200,90,60,15,Sy.val,0.001,10.0,"Noise y size")
      iScale = Number("iScale: ",102,140, 110, 90, 20, iScale.val, -10.0,10.0, "Height:  Noise intensity")
      invert = Toggle("I",102,230,110,30,20, invert.val,"Height: Invert noise intensity")
      offset = Number("Offset: ",102,140,130,120,15,offset.val,-10.0,10.0, "Height: Noise z offset")
      plev = Number("Max.:",102,140,180,90,15,plev.val, slev.val,1.0, "Plateau: Clip z Max.")
      pslope   = Toggle("S",102,230,180,15,15, pslope.val, "Plateau:  Set Flat  /  Set Slope")
      platnoise = Toggle("N",102,245,180,15,15, platnoise.val, "Plateau:  Set Flat  /  Set Noise ( +0.1*noise ) ")
      falmnu = "Falloff Type's %t|None %x0|Round %x1|Square %x2|y Linear %x3|x Linear %x4"
      if FalTyp.val !=0:
         slev = Number("Min.:",102,140,165,90,15,slev.val, -0.999,plev.val, "Sealevel: Clip z Min.")
         edgesatsea = Toggle("E",102,230,165,30,15, edgesatsea.val, "Edge Falloff:  Set Edge's at Sealevel")
         FalTyp = Menu(falmnu,102,230,150,30,15, FalTyp.val,"Edge Falloff Type's")
         Fall = Number(":",102,140,150,45,15,Fall.val,0.0,10.0,"Edge Falloff : Radius")
         FalHard = Number(":",102,185,150,45,15,FalHard.val,0.0,25.0,"Edge Falloff : Hardness")
      else:
         FalTyp = Menu(falmnu,102,140,150,120,15, FalTyp.val,"Edge Falloff type's")
         slev = Number("Min.:",102,140,165,120,15,slev.val, -0.999,plev.val, "Sealevel: Clip z Min.")

      RaPos = Toggle("P",105,10,35,20,15, RaPos.val,"Random Noise Position.")
      RaSiz = Toggle("S",105,30,35,20,15, RaSiz.val,"Random Noise Size.")
      RaHgh = Toggle("H",105,50,35,20,15, RaHgh.val,"Random Noise Height.")
      RaCha = Toggle("C",105,70,35,20,15, RaCha.val,"Random Noise Character.")
      RaTyp = Toggle("T",105,90,35,20,15, RaTyp.val,"Random Noise Type.")
      semnu = "Random Mode %t|Random %x0|Seed %x1"
      RanMod = Menu(semnu,222,110,35,20,15, RanMod.val,"Random Mode")
      if RanMod.val == 0:
         Button("Random", 69, 80, 10, 50, 20,"Randomise Noise ( P,S,H,C,T ).")
         Rseed = Create(0)
      else:
         Rseed = Number(":",69,80,10,50,20,Rseed.val,0,255,"Random seed ( P,S,C,H,T )")

      resmnu = "Mesh Quality%t|32 %x0|50 %x1|64 %x2|100 %x3|128 %x4|150 %x5|200 %x6|256 %x7|512 %x8|Manual %x9"
      if Quality.val == 9:
         resolution = Number(":",102,140,25,40,15, resolution.val, 2,512,"Mesh resolution ( n*n )")
         Quality = Menu(resmnu,102,140,10,40,15, Quality.val, "Mesh Quality")
      else:
         Quality = Menu(resmnu,102,140,10,40,15, Quality.val, "Mesh Quality")
      Q_T = Toggle("Faces",102,220,10,40,15,Q_T.val,"Faces : Set Quads / Set Triangles")
      smooth = Toggle("Smooth",102,180,10,40,15,smooth.val,"Faces : Set Solid / Set Smooth")
      Auto_Update = Toggle("A",105,60,10,20,20, Auto_Update.val,"Automatic mesh update.")
      Button("Update", 103, 10, 10, 50, 20,"Update mesh.")

   pvi = "Preview %t|None %x0|Grey %x1|Original %x2|Coloured %x3"
   pview = Menu(pvi,111, 10,226,20,15, pview.val, "Preview")
   Button("P", 888, 35, 226, 15, 15,"Presets")
   Button("X", 999, 245, 226, 15, 15,"Reset / Exit")

### do_it ----------------------------------- 
###----------------------------------- 
def do_it():
   Blender.Window.WaitCursor(1)
   Crea()
   Blender.Window.WaitCursor(0)
   Redraw()
def do_it_random():
   Blender.Window.WaitCursor(1)
   Random_N()
   Crea()
   Blender.Window.WaitCursor(0)
   Redraw()
###-----------------------------------
def event(evt, val):
   if (evt== ESCKEY and not val):
      Exit()
def bevent(evt):
   global Auto_Update, preset, preGrad, colorcontrols, colors

   if (evt== 999):
      name = "OK ?%t|Exit %x1|Reset %x2"
      result = Blender.Draw.PupMenu(name)
      if result == 2:
         resetMe()
         reset()
         do_it()
      elif result == 1:
         Exit()

   if (evt == EV_NOEVENT):
      Draw()

   if (evt == EV_NEW ):
      colors[ preGrad.val ].append([newheight.val, 128, 128, 128])
      colors[ preGrad.val ].sort()
      colors[ preGrad.val ].reverse()
      Draw()
   else:
      for c in range( len(colors[ preGrad.val ]) ):
         if (evt == EVB_H+c):
            colors[ preGrad.val ][c][0] = colorcontrols[0][c].val
         elif (evt == EVB_R+c):
            colors[ preGrad.val ][c][1] = colorcontrols[1][c].val
         elif (evt == EVB_G+c):
            colors[ preGrad.val ][c][2] = colorcontrols[2][c].val
         elif (evt == EVB_B+c):
            colors[ preGrad.val ][c][3] = colorcontrols[3][c].val
         elif (evt == EVB_DEL+c):
            del(colors[ preGrad.val ][c])
      colors[ preGrad.val ].sort()
      colors[ preGrad.val ].reverse()
      Draw()

   if (evt == 888):
      pre="Default %x1|Original %x2|Blender hills %x3|Stones hills %x4|Round hills %x5|Plateau %x6|Shattered %x7|Chaotic %x8|RidgedMF %x9|Dist.hTerrain %x10|Cauliflower %x11|Ridges %x12|Crystalline %x13||Warped hT. %x14|ChebyTech %x15|CellNoise %x16|Canyonised %x17|Ring o Rock %x18|Xtreme Peaks %x19|HardTurb %x20|Cliff %x21"
      result = Blender.Draw.PupMenu(pre,7)
      if result > 0:
         preset.val = result
         if Auto_Update.val == 1:
            reset()
            Preset_Noise()
            do_it()
         else:
            reset()
            Preset_Noise()
         Draw()

   if (evt in [ 111 , 222 ] ):
      Draw()
   if (evt == 103):
      do_it()
   if Auto_Update.val == 1:
      if (evt == 102):
         do_it()
      elif (evt == 69):
         do_it_random()
   if Auto_Update.val == 0:
      if (evt == 69):
         Random_N()
         Draw()
      elif (evt == 102):
         Draw()

   if (evt == 31):
      if FX.val ==1:
         Flt.val = 0
         Draw()
   if (evt == 32):
      if Flt.val ==1:
         FX.val = 0
         Draw()

Register(GUI, event, bevent)