Sorry your browser is not supported!

autocam off
sync on
sync rate 60

` load the height map
noise=find free image()
load image "terrain.png",noise

obj=create_terrain(noise)
img=create_texture(1024,3)
texture object obj,img

global light as integer
light=find free light()
make light light
set ambient light 0
set light range light,1000
set spot light light,10,30
set object specular obj,0xffffff
set object specular power obj,5

while escapekey() = 0
    control_camera()
    paste image noise,0,0
    sync
endwhile

end

function control_camera()
    mx#=mousemovex():mx#=mx#/4.0
    my#=mousemovey():my#=my#/4.0
    
    move camera upkey()-downkey()*2
    move camera right rightkey()-leftkey()*2
    
    xr#=wrapvalue(camera angle x() + my#)
    yr#=wrapvalue(camera angle y() + mx#)
    rotate camera xr#,yr#,camera angle z()
    
    rotate light light,xr#,yr#,camera angle z()
    position light light,camera position x(),camera position y(),camera position z()
endfunction

#constant size_x 20
#constant size_y 20

function create_terrain(noise)
    w=image width(noise)
    h=image height(noise)
    
    bm=find free bitmap()
    create bitmap bm,w,h
    paste image noise,0,0
    
    ` vertex count
    vc=(w+1)*(h+1)
    
    ` face count
    fc=w*h*2
    
    ` UV multipliers
    us#=1.0 / w
    vs#=1.0 / h
    
    ` object id
    obj=find free object()
    make object new obj,vc,fc*3
    
    lock vertexdata for limb obj,0
    
    ` vertex width
    nw=w+1
    
    for y=0 to h
        for x=0 to w
            ` get height map data
            hgt=point(x,y) : hgt=hgt and 255
            
            ` set vertex position
            set vertexdata position y*nw+x, size_x*x, hgt, size_y*y
            
            ` set vertex uv
            set vertexdata uv y*nw+x, us#*x, vs#*y
        next
    next
    
    ` create the faces
    for y=0 to h-1
        for x=0 to w-1
            ` face index offset
            fi=(y*nw+x)*6
            
            ` first triangle
            set indexdata fi+0,y*nw+x
            set indexdata fi+2,(y+1)*nw+x+1
            set indexdata fi+1,(y+1)*nw+x
            
            ` second triangle
            set indexdata fi+3,y*nw+x
            set indexdata fi+5,y*nw+x+1
            set indexdata fi+4,(y+1)*nw+x+1
        next
    next
    
    unlock vertexdata
    
    delete bitmap bm
    
    set object normals obj
    calculate object bounds obj
    
    set object cull obj,1
    
    color object obj,0xff0000
    
endfunction obj

function create_texture(size, seed)
    randomize seed
    bm = find free bitmap()
    create bitmap bm, size, size
    red_range = rnd(256)
    green_range = rnd(256)
    blue_range = rnd(256)
    select rnd(2)
        case 0
            red_range = red_range / 2
            endcase
        case 1
            green_range = green_green / 2
            endcase
        case 2
            blue_range = blue_range / 2
            endcase
    endselect
    red_half = red_range / 2
    green_half = green_range / 2
    blue_half = blue_range / 2
    lock pixels
    red_value = rnd( 255 )
    green_value = rnd( 255 )
    blue_value = rnd( 255 )
    for x = 0 to size - 1
        for y = 0 to size - 1
            red_new = red_value + ( rnd( red_range ) - red_half )
            if red_new < 0
                red_new = 0
            else
                if red_new > 255
                    red_new = 255
                endif
            endif
            green_new = green_value + ( rnd( green_range ) - green_half )
            if green_new < 0
                green_new = 0
            else
                if green_new > 255
                    green_new = 255
                endif
            endif
            blue_new = blue_value + ( rnd( blue_range ) - blue_half )
            if blue_new < 0
                blue_new = 0
            else
                if blue_new > 255
                    blue_new = 255
                endif
            endif
            dot x, y, rgb( red_new, green_new, blue_new )
        next
    next
    unlock pixels
    img = find free image()
    get image img, 0,0, size-1, size-1
    delete bitmap bm
endfunction img

for x=0 to width
    for y=0 to height
        ` set data using the X and Y coords
        ` array position if using a 1d array = (y * width + x)
    next
next

` %%%%%%%%%%%%%%%%%%%%%%%%%%%%
` %% PERLIN NOISE functions %%
` %%%%%%%%%%%%%%%%%%%%%%%%%%%%

` I will admit that I don't fully understand how this works but I managed to get
` the general idea.
` (credits go to http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain)
` (which is from what I've converted this from)

function PN_init(_persistance as float, _frequency as float, _amplitude as float, _octaves as integer, _randomseed as integer)
    global PN_persistance   as float
    global PN_frequency     as float
    global PN_amplitude     as float
    global PN_octaves       as float
    global PN_randomseed    as float
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_randomseed   = _randomseed
endfunction

function PN_getheight( x as float, y as float )
    result as float
    result = PN_amplitude * PN_total( x, y )
endfunction result

function PN_total( i as float, j as float )
    ` properties of one octave (changing each loop)
    t as float
    _amplitude as float
    freq as float
    
    t = 0.0
    _amplitude = 1
    freq = PN_frequency
    
    for k=0 to PN_octaves-1
        t = t + PN_getvalue( j * freq + PN_randomseed, i * freq + PN_randomseed ) * _amplitude
        _amplitude = _amplitude * PN_persistance
        freq = freq * 2.0
    next
endfunction t

function PN_getvalue( x as float, y as float )
    xint as integer
    yint as integer
    
    xint = x
    yint = y
    
    xfrac as float
    yfrac as float
    
    xfrac = x - xint
    yfrac = y - yint
    
    ` noise values
    n01 as float : n02 as float : n03 as float : n04 as float
    n05 as float : n06 as float : n07 as float : n08 as float
    n09 as float
    n12 as float : n14 as float : n16 as float
    n23 as float : n24 as float : n28 as float
    n34 as float
    
    n01 = PN_noise( xint - 1, yint - 1 )
    n02 = PN_noise( xint + 1, yint - 1 )
    n03 = PN_noise( xint - 1, yint + 1 )
    n04 = PN_noise( xint + 1, yiny + 1 )
    n05 = PN_noise( xint - 1, yint )
    n06 = PN_noise( xint + 1, yint )
    n07 = PN_noise( xint, yint - 1 )
    n08 = PN_noise( xint, yint + 1 )
    n09 = PN_noise( xint, yint )
    
    n12 = PN_noise( xint + 2, yint - 1 )
    n14 = PN_noise( xint + 2, yint + 1 )
    n16 = PN_noise( xint + 2, yint )
    
    n23 = PN_noise( xint - 1, yint + 2 )
    n24 = PN_noise( xint + 1, yint + 2 )
    n28 = PN_noise( xint, yint + 2 )
    
    n34 = PN_noise( xint + 2, yint + 2 )
    
    ` fint the noise values of the four corners
    x0y0 as float : x1y0 as float
    x0y1 as float : x1y1 as float
    
    x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09)
    x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06)
    x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08)
    x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04)
    
    ` interpolate between those values according to the x and y fractions
    v1 as float : v2 as float : fin as float
    
    v1 = PN_interpolate(x0y0, x1y0, Xfrac) ` interpolate in x direction (y)
    v2 = PN_interpolate(x0y1, x1y1, Xfrac) ` interpolate in x direction (y+1)
    fin = PN_interpolate(v1, v2, Yfrac)    `interpolate in y direction
endfunction fin

function PN_interpolate( x as float, y as float, a as float )
    nega as float : negasqr as float : fac1 as float
    asqr as float : fac2 as float : result as float
    
    nega = 1.0 - a
    negasqr = nega * nega
    fac1 = ( 3.0 * negasqr ) - ( 2.0 * ( negasqr * nega ) )
    asqr = a * a
    fac2 = ( 3.0 * asqr ) - ( 2.0 * ( asqr * a ) )
    
    result = ( x * fac1 ) + ( y * fac2 )
endfunction result

function PN_noise( x as integer, y as integer )
    n as integer
    
    n = x + y * 57
    n = ( n << 13 ) ^ n
    
    t as integer
    
    t = (n * (n * n * 15731 + 789221) + 1376312589) and 0x7fffffff
    
    result as float
    
    result = t
    result = 1.0 - t * 0.931322574615478515625
endfunction result

autocam off
sync on
sync rate 60

` load the height map
`noise=find free image() : load image "terrain.png",noise

noise = create_noise_map(64,0);

obj=create_terrain(noise)
img=create_texture(1024,320)
texture object obj,img

global light as integer
light=find free light()
make light light
set ambient light 20
set light range light,1000
set spot light light,10,30
set object specular obj,0xffffff
set object specular power obj,5
`set bump mapping on obj,img
set object smoothing obj,60

position camera 100,100,100
point camera 200,0,200

while escapekey() = 0
    control_camera()
    paste image noise,0,0
    sync
endwhile

end

function create_noise_map(size,seed)
    PN_init(0.5, 8, 0.9999, 6, seed)
    
    bm = find free bitmap()
    create bitmap bm, size, size
    
    lock pixels
    
    for x = 0 to size - 1
        for y = 0 to size - 1
            sx# = x : sx# = sx# / size
            sy# = y : sy# = sy# / size
            h# = PN_getheight( sx#, sy# ) * 127.0 + 128
            col = h#
            ink rgb(col,col,col),0xffffff
            dot x,y
        next
    next
    
    unlock pixels
    
    img = find free image()
    get image img,0,0,size-1,size-1
    
    delete bitmap bm
endfunction img

function control_camera()
    mx#=mousemovex():mx#=mx#/4.0
    my#=mousemovey():my#=my#/4.0
    
    move camera upkey()-downkey()*2
    move camera right rightkey()-leftkey()*2
    
    xr#=wrapvalue(camera angle x() + my#)
    yr#=wrapvalue(camera angle y() + mx#)
    rotate camera xr#,yr#,camera angle z()
    
    rotate light light,xr#,yr#,camera angle z()
    position light light,camera position x(),camera position y(),camera position z()
endfunction

#constant size_x 20
#constant size_y 20

function create_terrain(noise)
    w=image width(noise)
    h=image height(noise)
    
    bm=find free bitmap()
    create bitmap bm,w,h
    paste image noise,0,0
    
    ` vertex count
    vc=(w+1)*(h+1)
    
    ` face count
    fc=w*h*2
    
    ` UV multipliers
    us#=1.0 / w
    vs#=1.0 / h
    
    ` object id
    obj=find free object()
    make object new obj,vc,fc*3
    
    lock vertexdata for limb obj,0
    
    ` vertex width
    nw=w+1
    
    for y=0 to h
        for x=0 to w
            ` get height map data
            hgt=point(x,y) : hgt=hgt and 255
            
            ` set vertex position
            set vertexdata position y*nw+x, size_x*x, hgt, size_y*y
            
            ` set vertex uv
            set vertexdata uv y*nw+x, us#*x, vs#*y
        next
    next
    
    ` create the faces
    for y=0 to h-1
        for x=0 to w-1
            ` face index offset
            fi=(y*nw+x)*6
            
            ` first triangle
            set indexdata fi+0,y*nw+x
            set indexdata fi+2,(y+1)*nw+x+1
            set indexdata fi+1,(y+1)*nw+x
            
            ` second triangle
            set indexdata fi+3,y*nw+x
            set indexdata fi+5,y*nw+x+1
            set indexdata fi+4,(y+1)*nw+x+1
        next
    next
    
    unlock vertexdata
    
    delete bitmap bm
    
    set object normals obj
    calculate object bounds obj
    
    set object cull obj,1
    
    color object obj,0xff0000
    
endfunction obj

function create_texture(size, seed)
    randomize seed
    bm = find free bitmap()
    create bitmap bm, size, size
    red_range = rnd(256)
    green_range = rnd(256)
    blue_range = rnd(256)
    select rnd(2)
        case 0
            red_range = red_range / 2
            endcase
        case 1
            green_range = green_range / 2
            endcase
        case 2
            blue_range = blue_range / 2
            endcase
    endselect
    red_half = red_range / 2
    green_half = green_range / 2
    blue_half = blue_range / 2
    lock pixels
    red_value = rnd( 255 )
    green_value = rnd( 255 )
    blue_value = rnd( 255 )
    for x = 0 to size - 1
        for y = 0 to size - 1
            red_new = red_value + ( rnd( red_range ) - red_half )
            if red_new < 0
                red_new = 0
            else
                if red_new > 255
                    red_new = 255
                endif
            endif
            green_new = green_value + ( rnd( green_range ) - green_half )
            if green_new < 0
                green_new = 0
            else
                if green_new > 255
                    green_new = 255
                endif
            endif
            blue_new = blue_value + ( rnd( blue_range ) - blue_half )
            if blue_new < 0
                blue_new = 0
            else
                if blue_new > 255
                    blue_new = 255
                endif
            endif
            ink rgb( red_new, green_new, blue_new ),0
            dot x, y 
        next
    next
    unlock pixels
    img = find free image()
    get image img, 0,0, size-1, size-1
    delete bitmap bm
endfunction img

` %%%%%%%%%%%%%%%%%%%%%%%%%%%%
` %% PERLIN NOISE functions %%
` %%%%%%%%%%%%%%%%%%%%%%%%%%%%

` I will admit that I don't fully understand how this works but I managed to get
` the general idea.
` (credits go to http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain)
` (which is from what I've converted this from)

function PN_init(_persistance as float, _frequency as float, _amplitude as float, _octaves as integer, _randomseed as integer)
    global PN_persistance   as float
    global PN_frequency     as float
    global PN_amplitude     as float
    global PN_octaves       as float
    global PN_randomseed    as float
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_randomseed   = _randomseed
endfunction

function PN_getheight( x as float, y as float )
    result as float
    result = PN_amplitude * PN_total( x, y )
endfunction result

function PN_total( i as float, j as float )
    ` properties of one octave (changing each loop)
    t as float
    _amplitude as float
    freq as float
    
    t = 0.0
    _amplitude = 1
    freq = PN_frequency
    
    for k=0 to PN_octaves-1
        t = t + PN_getvalue( j * freq + PN_randomseed, i * freq + PN_randomseed ) * _amplitude
        _amplitude = _amplitude * PN_persistance
        freq = freq * 2.0
    next
endfunction t

function PN_getvalue( x as float, y as float )
    xint as integer
    yint as integer
    
    xint = x
    yint = y
    
    xfrac as float
    yfrac as float
    
    xfrac = x - xint
    yfrac = y - yint
    
    ` noise values
    n01 as float : n02 as float : n03 as float : n04 as float
    n05 as float : n06 as float : n07 as float : n08 as float
    n09 as float
    n12 as float : n14 as float : n16 as float
    n23 as float : n24 as float : n28 as float
    n34 as float
    
    n01 = PN_noise( xint - 1, yint - 1 )
    n02 = PN_noise( xint + 1, yint - 1 )
    n03 = PN_noise( xint - 1, yint + 1 )
    n04 = PN_noise( xint + 1, yiny + 1 )
    n05 = PN_noise( xint - 1, yint )
    n06 = PN_noise( xint + 1, yint )
    n07 = PN_noise( xint, yint - 1 )
    n08 = PN_noise( xint, yint + 1 )
    n09 = PN_noise( xint, yint )
    
    n12 = PN_noise( xint + 2, yint - 1 )
    n14 = PN_noise( xint + 2, yint + 1 )
    n16 = PN_noise( xint + 2, yint )
    
    n23 = PN_noise( xint - 1, yint + 2 )
    n24 = PN_noise( xint + 1, yint + 2 )
    n28 = PN_noise( xint, yint + 2 )
    
    n34 = PN_noise( xint + 2, yint + 2 )
    
    ` fint the noise values of the four corners
    x0y0 as float : x1y0 as float
    x0y1 as float : x1y1 as float
    
    x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09)
    x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06)
    x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08)
    x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04)
    
    ` interpolate between those values according to the x and y fractions
    v1 as float : v2 as float : fin as float
    
    v1 = PN_interpolate(x0y0, x1y0, Xfrac) ` interpolate in x direction (y)
    v2 = PN_interpolate(x0y1, x1y1, Xfrac) ` interpolate in x direction (y+1)
    fin = PN_interpolate(v1, v2, Yfrac)    `interpolate in y direction
endfunction fin

function PN_interpolate( x as float, y as float, a as float )
    nega as float : negasqr as float : fac1 as float
    asqr as float : fac2 as float : result as float
    
    nega = 1.0 - a
    negasqr = nega * nega
    fac1 = ( 3.0 * negasqr ) - ( 2.0 * ( negasqr * nega ) )
    asqr = a * a
    fac2 = ( 3.0 * asqr ) - ( 2.0 * ( asqr * a ) )
    
    result = ( x * fac1 ) + ( y * fac2 )
endfunction result

function PN_noise( x as integer, y as integer )
    n as integer
    
    n = x + y * 57
    n = ( n << 13 ) ^ n
    
    t as integer
    
    t = (n * (n * n * 15731 + 789221) + 1376312589) and 0x7fffffff
    
    result as float
    
    result = t
    result = 1.0 - t * 0.931322574615478515625
endfunction result

autocam off
sync on
sync rate 60

` load the height map
`noise=find free image() : load image "terrain.png",noise

noise = create_noise_map(64,100);

obj=create_terrain(noise)
img=create_texture(1024,320)
texture object obj,img

global light as integer
light=find free light()
make light light
set ambient light 20
set light range light,1000
set spot light light,10,30
set object specular obj,0xffffff
set object specular power obj,5
`set bump mapping on obj,img
set object smoothing obj,60

position camera 100,100,100
point camera 200,0,200

while escapekey() = 0
    control_camera()
    paste image noise,0,0
    sync
endwhile

end

function create_noise_map(size,seed)
    PN_init(0.5, 8.0, 0.9999, 6, seed)
    
    bm = find free bitmap()
    create bitmap bm, size, size
    
    lock pixels
    
    for x = 0 to size - 1
        for y = 0 to size - 1
            sx# = x : sx# = sx#` / size
            sy# = y : sy# = sy#` / size
            h# = PN_getheight( sx#, sy# ) * 127.0 + 128.0
            col = h#
            ink rgb(col,col,col),0xffffff
            dot x,y
        next
    next
    
    unlock pixels
    
    img = find free image()
    get image img,0,0,size-1,size-1
    
    delete bitmap bm
endfunction img

function control_camera()
    mx#=mousemovex():mx#=mx#/4.0
    my#=mousemovey():my#=my#/4.0
    
    move camera upkey()-downkey()*2
    move camera right rightkey()-leftkey()*2
    
    xr#=wrapvalue(camera angle x() + my#)
    yr#=wrapvalue(camera angle y() + mx#)
    rotate camera xr#,yr#,camera angle z()
    
    rotate light light,xr#,yr#,camera angle z()
    position light light,camera position x(),camera position y(),camera position z()
endfunction

#constant size_x 20
#constant size_y 20

function create_terrain(noise)
    w=image width(noise)
    h=image height(noise)
    
    bm=find free bitmap()
    create bitmap bm,w,h
    paste image noise,0,0
    
    ` vertex count
    vc=(w+1)*(h+1)
    
    ` face count
    fc=w*h*2
    
    ` UV multipliers
    us#=1.0 / w
    vs#=1.0 / h
    
    ` object id
    obj=find free object()
    make object new obj,vc,fc*3
    
    lock vertexdata for limb obj,0
    
    ` vertex width
    nw=w+1
    
    for y=0 to h
        for x=0 to w
            ` get height map data
            hgt=point(x,y) : hgt=hgt and 255
            
            ` set vertex position
            set vertexdata position y*nw+x, size_x*x, hgt, size_y*y
            
            ` set vertex uv
            set vertexdata uv y*nw+x, us#*x, vs#*y
        next
    next
    
    ` create the faces
    for y=0 to h-1
        for x=0 to w-1
            ` face index offset
            fi=(y*nw+x)*6
            
            ` first triangle
            set indexdata fi+0,y*nw+x
            set indexdata fi+2,(y+1)*nw+x+1
            set indexdata fi+1,(y+1)*nw+x
            
            ` second triangle
            set indexdata fi+3,y*nw+x
            set indexdata fi+5,y*nw+x+1
            set indexdata fi+4,(y+1)*nw+x+1
        next
    next
    
    unlock vertexdata
    
    delete bitmap bm
    
    set object normals obj
    calculate object bounds obj
    
    set object cull obj,1
    
    color object obj,0xff0000
    
endfunction obj

function create_texture(size, seed)
    randomize seed
    bm = find free bitmap()
    create bitmap bm, size, size
    red_range = rnd(256)
    green_range = rnd(256)
    blue_range = rnd(256)
    select rnd(2)
        case 0
            red_range = red_range / 2
            endcase
        case 1
            green_range = green_range / 2
            endcase
        case 2
            blue_range = blue_range / 2
            endcase
    endselect
    red_half = red_range / 2
    green_half = green_range / 2
    blue_half = blue_range / 2
    lock pixels
    red_value = rnd( 255 )
    green_value = rnd( 255 )
    blue_value = rnd( 255 )
    for x = 0 to size - 1
        for y = 0 to size - 1
            red_new = red_value + ( rnd( red_range ) - red_half )
            if red_new < 0
                red_new = 0
            else
                if red_new > 255
                    red_new = 255
                endif
            endif
            green_new = green_value + ( rnd( green_range ) - green_half )
            if green_new < 0
                green_new = 0
            else
                if green_new > 255
                    green_new = 255
                endif
            endif
            blue_new = blue_value + ( rnd( blue_range ) - blue_half )
            if blue_new < 0
                blue_new = 0
            else
                if blue_new > 255
                    blue_new = 255
                endif
            endif
            ink rgb( red_new, green_new, blue_new ),0
            dot x, y 
        next
    next
    unlock pixels
    img = find free image()
    get image img, 0,0, size-1, size-1
    delete bitmap bm
endfunction img

` %%%%%%%%%%%%%%%%%%%%%%%%%%%%
` %% PERLIN NOISE functions %%
` %%%%%%%%%%%%%%%%%%%%%%%%%%%%

` I will admit that I don't fully understand how this works but I managed to get
` the general idea.
` (credits go to http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain)
` (which is from what I've converted this from)

function PN_init(_persistance as double float, _frequency as double float, _amplitude as double float, _octaves as integer, _randomseed as integer)
    global PN_persistance   as double float
    global PN_frequency     as double float
    global PN_amplitude     as double float
    global PN_octaves       as integer
    global PN_randomseed    as integer
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_randomseed   = 2.0 + _randomseed * _randomseed
endfunction

function PN_getheight( x as double float, y as double float )
    result as double float
    result = PN_amplitude * PN_total( x, y )
endfunction result

function PN_total( i as double float, j as double float )
    ` properties of one octave (changing each loop)
    t as double float
    _amplitude as double float
    freq as double float
    
    t = 0.0
    _amplitude = 1
    freq = PN_frequency
    
    for k=0 to PN_octaves-1
        t = t + PN_getvalue( j * freq + PN_randomseed, i * freq + PN_randomseed ) * _amplitude
        _amplitude = _amplitude * PN_persistance
        freq = freq * 2.0
    next
endfunction t

function PN_getvalue( x as double float, y as double float )
    xint as integer
    yint as integer
    
    xint = x
    yint = y
    
    xfrac as double float
    yfrac as double float
    
    xfrac = x - xint
    yfrac = y - yint
    
    ` noise values
    n01 as double float : n02 as double float : n03 as double float : n04 as double float
    n05 as double float : n06 as double float : n07 as double float : n08 as double float
    n09 as double float
    n12 as double float : n14 as double float : n16 as double float
    n23 as double float : n24 as double float : n28 as double float
    n34 as double float
    
    n01 = PN_noise( xint - 1, yint - 1 )
    n02 = PN_noise( xint + 1, yint - 1 )
    n03 = PN_noise( xint - 1, yint + 1 )
    n04 = PN_noise( xint + 1, yiny + 1 )
    n05 = PN_noise( xint - 1, yint )
    n06 = PN_noise( xint + 1, yint )
    n07 = PN_noise( xint, yint - 1 )
    n08 = PN_noise( xint, yint + 1 )
    n09 = PN_noise( xint, yint )
    
    n12 = PN_noise( xint + 2, yint - 1 )
    n14 = PN_noise( xint + 2, yint + 1 )
    n16 = PN_noise( xint + 2, yint )
    
    n23 = PN_noise( xint - 1, yint + 2 )
    n24 = PN_noise( xint + 1, yint + 2 )
    n28 = PN_noise( xint, yint + 2 )
    
    n34 = PN_noise( xint + 2, yint + 2 )
    
    ` fint the noise values of the four corners
    x0y0 as double float : x1y0 as double float
    x0y1 as double float : x1y1 as double float
    
    x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09)
    x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06)
    x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08)
    x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04)
    
    ` interpolate between those values according to the x and y fractions
    v1 as double float : v2 as double float : fin as double float
    
    v1 = PN_interpolate(x0y0, x1y0, Xfrac) ` interpolate in x direction (y)
    v2 = PN_interpolate(x0y1, x1y1, Xfrac) ` interpolate in x direction (y+1)
    fin = PN_interpolate(v1, v2, Yfrac)    `interpolate in y direction
endfunction fin

function PN_interpolate( x as double float, y as double float, a as double float )
    nega as double float : negasqr as double float : fac1 as double float
    asqr as double float : fac2 as double float : result as double float
    
    nega = 1.0 - a
    negasqr = nega * nega
    fac1 = ( 3.0 * negasqr ) - ( 2.0 * ( negasqr * nega ) )
    asqr = a * a
    fac2 = ( 3.0 * asqr ) - ( 2.0 * ( asqr * a ) )
    
    result = ( x * fac1 ) + ( y * fac2 )
endfunction result

function PN_noise( x as integer, y as integer )
    n as integer
    
    n = x + y * 57
    n = ( n << 13 ) ^ n
    
    t as integer
    
    t = (n * (n * n * 15731 + 789221) + 1376312589) and 0x7fffffff
    
    result as double float
    
    result = t
    result = 1.0 - result * 0.931322574615478515625e-9
endfunction result

#include "main.h"

PerlinNoise::PerlinNoise()
{
  persistence = 0;
  frequency = 0;
  amplitude  = 0;
  octaves = 0;
  randomseed = 0;
}

PerlinNoise::PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
  persistence = _persistence;
  frequency = _frequency;
  amplitude  = _amplitude;
  octaves = _octaves;
  randomseed = 2 + _randomseed * _randomseed;
}

void PerlinNoise::Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
  persistence = _persistence;
  frequency = _frequency;
  amplitude  = _amplitude;
  octaves = _octaves;
  randomseed = 2 + _randomseed * _randomseed;
}

double PerlinNoise::GetHeight(double x, double y) const
{
  return amplitude * Total(x, y);
}

double PerlinNoise::Total(double i, double j) const
{
    //properties of one octave (changing each loop)
    double t = 0.0f;
    double _amplitude = 1;
    double freq = frequency;

    for(int k = 0; k < octaves; k++) 
    {
        t += GetValue(j * freq + randomseed, i * freq + randomseed) * _amplitude;
        _amplitude *= persistence;
        freq *= 2;
    }

    return t;
}

double PerlinNoise::GetValue(double x, double y) const
{
    int Xint = (int)x;
    int Yint = (int)y;
    double Xfrac = x - Xint;
    double Yfrac = y - Yint;

  //noise values
  double n01 = Noise(Xint-1, Yint-1);
  double n02 = Noise(Xint+1, Yint-1);
  double n03 = Noise(Xint-1, Yint+1);
  double n04 = Noise(Xint+1, Yint+1);
  double n05 = Noise(Xint-1, Yint);
  double n06 = Noise(Xint+1, Yint);
  double n07 = Noise(Xint, Yint-1);
  double n08 = Noise(Xint, Yint+1);
  double n09 = Noise(Xint, Yint);

  double n12 = Noise(Xint+2, Yint-1);
  double n14 = Noise(Xint+2, Yint+1);
  double n16 = Noise(Xint+2, Yint);

  double n23 = Noise(Xint-1, Yint+2);
  double n24 = Noise(Xint+1, Yint+2);
  double n28 = Noise(Xint, Yint+2);

  double n34 = Noise(Xint+2, Yint+2);

    //find the noise values of the four corners
    double x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09);  
    double x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06);  
    double x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08);  
    double x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04);  

    //interpolate between those values according to the x and y fractions
    double v1 = Interpolate(x0y0, x1y0, Xfrac); //interpolate in x direction (y)
    double v2 = Interpolate(x0y1, x1y1, Xfrac); //interpolate in x direction (y+1)
    double fin = Interpolate(v1, v2, Yfrac);  //interpolate in y direction

    return fin;
}

double PerlinNoise::Interpolate(double x, double y, double a) const
{
	double negA = 1.0 - a;
	double negASqr = negA * negA;
	double fac1 = 3.0 * (negASqr) - 2.0 * (negASqr * negA);
	double aSqr = a * a;
	double fac2 = 3.0 * aSqr - 2.0 * (aSqr * a);

    return x * fac1 + y * fac2; //add the weighted factors
}

double PerlinNoise::Noise(int x, int y) const
{
	int n = x + y * 57;
	n = (n << 13) ^ n;
	int t = (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff;
	return 1.0 - double(t) * 0.931322574615478515625e-9;/// 1073741824.0);
}

autocam off
sync on

x1 as float
x2 as float
x3 as float
x3b as float
y1 as float
y2 as float
y3 as float
y3b as float
z1 as float
z2 as float
z3 as float
z3b as float

`Loading terraing and heightmap texture
load image "terreno.jpg",1
load image "altura.jpg",2
paste image 2,0,0

`grid of 50*50
o=15000
for i= 1 to 51
   for a= 1 to 51
       col#=rgbr(point(a*1.96,i*1.96))/3
       inc o
       make object box o,0.2,0.2,0.2
       position object o,-125+a*5,col#,125-i*5
       hide object o
   next a
next i

`5000 triangles to make 2500 square faces
for i= 1 to 2500

   x1=object position x(15001+d+f)
   y1=object position y(15001+d+f)
   z1=object position z(15001+d+f)

   x2=object position x(15002+d+f)
   y2=object position y(15002+d+f)
   z2=object position z(15002+d+f)

   x3=object position x(15053+d+f)
   y3=object position y(15053+d+f)
   z3=object position z(15053+d+f)

   x3b=object position x(15052+d+f)
   y3b=object position y(15052+d+f)
   z3b=object position z(15052+d+f)

 make object triangle i,x1,y1,z1,x2,y2,z2,x3,y3,z3
 make object triangle i+2500,x3,y3,z3,x3b,y3b,z3b,x1,y1,z1

inc d
if d=50 then d=0:f=f+51

for j=1 to 50
  if i+50>j*50 then d2=j
next j
`Udjusting the texture to all the triangles
  scale object texture i,0.02,0.02
  scroll object texture i,0.02*d-0.02,0.02*d2-0.02

  scale object texture i+2500,-0.02,-0.02
  scroll object texture i+2500,0.02*d,0.02*d2

next i

`texturing triangles
for i= 1 to 5000
 texture object i,1
 set object normals i
next i

position camera 10,30,-10
point camera 0,0,0

`deleting point of reference
for i= 15000 to 17601
   delete object i
next i

`we can save our matrix to .x or .dbo
make object box 10000,0,0,0      `pivot
for i= 1 to 5000
  make mesh from object i,i
  delete object i
  add limb 10000,i,i
  delete mesh i
next i

make mesh from object 1,10000
delete object 10000
rem save mesh "50x50matrix.x",1
make object 1,1,1
set object smoothing 1,50
rem save object "matrix.dbo",10000
do
set cursor 0,0
print screen fps()

control camera using arrowkeys 0,0.1,0.1
a#=wrapvalue(a#+mousemovex()/2)
cam#=wrapvalue(cam#+mousemovey()/2)
rotate camera cam#,a#,0
if leftkey() then move camera left 0.1
if rightkey() then move camera right 0.1

sync
loop

void terraingen::create(int size, int seed) {
	map = new char[size*size];
	width = height = size;

	srand(seed);

	// init the perlin noise
	PerlinNoise noise;

	double pers = 0.5f + ( ( (double)( rand() % 60 ) - 30.0f ) / 100.0f );
	double freq = 4.0f + ( (double)( rand() % 50 ) );
	double ampl = 0.999999999999f;
	int		oct = 3 + ( rand() % 8 );
	int		new_seed = rand();

	noise.Set( pers, freq, ampl, oct, new_seed );

	// store the noise in the array
	int		x, y, hgt;
	double	dsize = (double)size;

	for ( x = 0; x < size; x++ ) {
		for ( y = 0; y < size; y++ ) {
			double sx = (double)x / dsize;
			double sy = (double)y / dsize;
			hgt = (int)( noise.GetHeight(sx,sy) * 127.0 + 128.0 );
			map[y*size+x] = hgt;
		}
	}

}

autocam off
sync on
sync rate 60

` load the height map
noise=find free image()
load image "terrain.png",noise

obj=create_terrain(noise)
img=create_texture(1024,3)
texture object obj,img

global light as integer
light=find free light()
make light light
set ambient light 0
set light range light,1000
set spot light light,10,30
set object specular obj,0xffffff
set object specular power obj,5

while escapekey() = 0
    control_camera()
    paste image noise,0,0
    sync
endwhile

end

function control_camera()
    mx#=mousemovex():mx#=mx#/4.0
    my#=mousemovey():my#=my#/4.0
    
    move camera upkey()-downkey()*2
    move camera right rightkey()-leftkey()*2
    
    xr#=wrapvalue(camera angle x() + my#)
    yr#=wrapvalue(camera angle y() + mx#)
    rotate camera xr#,yr#,camera angle z()
    
    rotate light light,xr#,yr#,camera angle z()
    position light light,camera position x(),camera position y(),camera position z()
endfunction

#constant size_x 20
#constant size_y 20

function create_terrain(noise)
    w=image width(noise)
    h=image height(noise)
    
    bm=find free bitmap()
    create bitmap bm,w,h
    paste image noise,0,0
    
    ` vertex count
    vc=(w+1)*(h+1)
    
    ` face count
    fc=w*h*2
    
    ` UV multipliers
    us#=1.0 / w
    vs#=1.0 / h
    
    ` object id
    obj=find free object()
    make object new obj,vc,fc*3
    
    lock vertexdata for limb obj,0
    
    ` vertex width
    nw=w+1
    
    for y=0 to h
        for x=0 to w
            ` get height map data
            hgt=point(x,y) : hgt=hgt and 255
            
            ` set vertex position
            set vertexdata position y*nw+x, size_x*x, hgt, size_y*y
            
            ` set vertex uv
            set vertexdata uv y*nw+x, us#*x, vs#*y
        next
    next
    
    ` create the faces
    for y=0 to h-1
        for x=0 to w-1
            ` face index offset
            fi=(y*nw+x)*6
            
            ` first triangle
            set indexdata fi+0,y*nw+x
            set indexdata fi+2,(y+1)*nw+x+1
            set indexdata fi+1,(y+1)*nw+x
            
            ` second triangle
            set indexdata fi+3,y*nw+x
            set indexdata fi+5,y*nw+x+1
            set indexdata fi+4,(y+1)*nw+x+1
        next
    next
    
    unlock vertexdata
    
    delete bitmap bm
    
    set object normals obj
    calculate object bounds obj
    
    set object cull obj,1
    
    color object obj,0xff0000
    
endfunction obj

function create_texture(size, seed)
    randomize seed
    bm = find free bitmap()
    create bitmap bm, size, size
    red_range = rnd(256)
    green_range = rnd(256)
    blue_range = rnd(256)
    select rnd(2)
        case 0
            red_range = red_range / 2
            endcase
        case 1
            green_range = green_green / 2
            endcase
        case 2
            blue_range = blue_range / 2
            endcase
    endselect
    red_half = red_range / 2
    green_half = green_range / 2
    blue_half = blue_range / 2
    lock pixels
    red_value = rnd( 255 )
    green_value = rnd( 255 )
    blue_value = rnd( 255 )
    for x = 0 to size - 1
        for y = 0 to size - 1
            red_new = red_value + ( rnd( red_range ) - red_half )
            if red_new < 0
                red_new = 0
            else
                if red_new > 255
                    red_new = 255
                endif
            endif
            green_new = green_value + ( rnd( green_range ) - green_half )
            if green_new < 0
                green_new = 0
            else
                if green_new > 255
                    green_new = 255
                endif
            endif
            blue_new = blue_value + ( rnd( blue_range ) - blue_half )
            if blue_new < 0
                blue_new = 0
            else
                if blue_new > 255
                    blue_new = 255
                endif
            endif
            dot x, y, rgb( red_new, green_new, blue_new )
        next
    next
    unlock pixels
    img = find free image()
    get image img, 0,0, size-1, size-1
    delete bitmap bm
endfunction img

    double persistence, frequency, amplitude;
    int octaves, randomseed;

PerlinNoise::PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
  persistence = _persistence;
  frequency = _frequency;
  amplitude  = _amplitude;
  octaves = _octaves;
  randomseed = 2 + _randomseed * _randomseed;
}

function PN_init(_persistance as float, _frequency as float, _amplitude as float, _octaves as integer, _randomseed as integer)
    global PN_persistance   as float
    global PN_frequency     as float
    global PN_amplitude     as float // This should not be a float
    global PN_octaves       as float
    global PN_randomseed    as float
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_randomseed   = _randomseed
endfunction

` %%%%%%%%%%%%%%%%%%%%%%%%%%%%
` %% PERLIN NOISE functions %%
` %%%%%%%%%%%%%%%%%%%%%%%%%%%%

` I will admit that I don't fully understand how this works but I managed to get
` the general idea.
` (credits go to http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain)
` (which is from what I've converted this from)

function PN_init(_persistance as double float, _frequency as double float, _amplitude as double float, _octaves as integer, _randomseed as integer)
    global PN_persistance   as double float
    global PN_frequency     as double float
    global PN_amplitude     as double float
    global PN_octaves       as integer
    global PN_randomseed    as integer
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_randomseed   = 2.0 + _randomseed * _randomseed
endfunction

function PN_getheight( x as double float, y as double float )
    result as double float
    result = PN_amplitude * PN_total( x, y )
endfunction result

function PN_total( i as double float, j as double float )
    ` properties of one octave (changing each loop)
    t as double float
    _amplitude as double float
    freq as double float
    
    t = 0.0
    _amplitude = 1
    freq = PN_frequency
    
    for k=0 to PN_octaves-1
        t = t + PN_getvalue( j * freq + PN_randomseed, i * freq + PN_randomseed ) * _amplitude
        _amplitude = _amplitude * PN_persistance
        freq = freq * 2.0
    next
endfunction t

function PN_getvalue( x as double float, y as double float )
    xint as integer
    yint as integer
    
    xint = x
    yint = y
    
    xfrac as double float
    yfrac as double float
    
    xfrac = x : xfrac = xfrac - xint
    yfrac = y : yfrac = yfrac - yint
    
    ` noise values
    n01 as double float : n02 as double float : n03 as double float : n04 as double float
    n05 as double float : n06 as double float : n07 as double float : n08 as double float
    n09 as double float
    n12 as double float : n14 as double float : n16 as double float
    n23 as double float : n24 as double float : n28 as double float
    n34 as double float
    
    n01 = PN_noise( xint - 1, yint - 1 )
    n02 = PN_noise( xint + 1, yint - 1 )
    n03 = PN_noise( xint - 1, yint + 1 )
    n04 = PN_noise( xint + 1, yiny + 1 )
    n05 = PN_noise( xint - 1, yint )
    n06 = PN_noise( xint + 1, yint )
    n07 = PN_noise( xint, yint - 1 )
    n08 = PN_noise( xint, yint + 1 )
    n09 = PN_noise( xint, yint )
    
    n12 = PN_noise( xint + 2, yint - 1 )
    n14 = PN_noise( xint + 2, yint + 1 )
    n16 = PN_noise( xint + 2, yint )
    
    n23 = PN_noise( xint - 1, yint + 2 )
    n24 = PN_noise( xint + 1, yint + 2 )
    n28 = PN_noise( xint, yint + 2 )
    
    n34 = PN_noise( xint + 2, yint + 2 )
    
    ` fint the noise values of the four corners
    x0y0 as double float : x1y0 as double float
    x0y1 as double float : x1y1 as double float
    
    x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09)
    x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06)
    x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08)
    x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04)
    
    ` interpolate between those values according to the x and y fractions
    v1 as double float : v2 as double float : fin as double float
    
    v1 = PN_interpolate(x0y0, x1y0, xfrac) ` interpolate in x direction (y)
    v2 = PN_interpolate(x0y1, x1y1, xfrac) ` interpolate in x direction (y+1)
    fin = PN_interpolate(v1, v2, yfrac)    ` interpolate in y direction
endfunction fin

function PN_interpolate( x as double float, y as double float, a as double float )
    nega as double float : negasqr as double float : fac1 as double float
    asqr as double float : fac2 as double float : result as double float
    
    nega = 1.0 - a
    negasqr = nega * nega
    fac1 = ( 3.0 * negasqr ) - ( 2.0 * ( negasqr * nega ) )
    asqr = a * a
    fac2 = ( 3.0 * asqr ) - ( 2.0 * ( asqr * a ) )
    
    result = ( x * fac1 ) + ( y * fac2 )
endfunction result

function PN_noise( x as integer, y as integer )
    n as integer
    
    n = x + y * 57
    n = ( n << 13 ) ^ n
    
    t as integer
    
    t = (n * (n * n * 15731 + 789221) + 1376312589) and 0x7fffffff
    
    result as double float
    
    result = t
    result = 1.0 - result * 0.931322574615478515625e-9
endfunction result