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

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 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 double float
    global PN_randomseed    as double float
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_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 double float
    
    t = (n * (n * n * 15731 + 789221) + 1376312589) and 0x7fffffff // 2147483647
    
    result as double float
    
    //result = t
    result = 1.0 - t * 0.931322574615478515625
endfunction result

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

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
    
    wierd_num as double float
    wierd_num = 0.931322574615478515625e-9
    
    result = t
    result = 1.0 - result * wierd_num
endfunction result

autocam off
sync on
sync rate 60

global shownumbera as double float
global shownumberb as double float
global light

` 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

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
    print str$(shownumbera)
    print str$(shownumberb)
    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 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 double float
    global PN_randomseed    as double float
    PN_persistance  = _persistance
    PN_frequency    = _frequency
    PN_amplitude    = _amplitude
    PN_octaves      = _octaves
    PN_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 double float
    
    t = (n * (n  * n * 15731 + 789221) + 1376312589) and 0x7fffffff // 2147483647
    
    result as double float
    shownumbera = t
    // result = t
    result = 1.0 - t * 0.9313225746 //15478515625 // which is part of --> 0.931322574615478515625
    shownumberb = result
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,256,100
point camera 200,0,200

while escapekey() = 0
    text 0,100,str$( 0.931322574615478515625e-9 )
    control_camera()
    paste image noise,0,0
    sync
endwhile

end

function create_noise_map(size,seed)
    PN_init(0.5, 8.0, 3.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# ) * 32.0 + 128.0
            col = h#
            ink rgb(col,col,col),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

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 : 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
    
    wierd_num as double float
    wierd_num = 0.931322574615478515625e-9
    `wierd_num = 0.931322
    
    result = t
    result = 1.0 - result * wierd_num
endfunction result

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

#pragma once

// Perlin Noise (credits go to http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain)

class PerlinNoise
{
public:

  // Constructor
    PerlinNoise();
    PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

  // Get Height
    double GetHeight(double x, double y) const;

  // Get
  double Persistence() const { return persistence; }
  double Frequency()   const { return frequency;   }
  double Amplitude()   const { return amplitude;   }
  int    Octaves()     const { return octaves;     }
  int    RandomSeed()  const { return randomseed;  }

  // Set
  void Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

  void SetPersistence(double _persistence) { persistence = _persistence; }
  void SetFrequency(  double _frequency)   { frequency = _frequency;     }
  void SetAmplitude(  double _amplitude)   { amplitude = _amplitude;     }
  void SetOctaves(    int    _octaves)     { octaves = _octaves;         }
  void SetRandomSeed( int    _randomseed)  { randomseed = _randomseed;   }

private:

    double Total(double i, double j) const;
    double GetValue(double x, double y) const;
    double Interpolate(double x, double y, double a) const;
    double Noise(int x, int y) const;

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

#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);
}

#pragma once

class terraingen
{
public:
	// need a height map
	// Now I've got a working perlin noise class I can just
	// use a basic 2d array
	int		width;
	int		height;
	char*	map;

	// other vars go here

	terraingen(void);
	~terraingen(void);

	void create(int size, int seed);
};

#include "main.h"

terraingen::terraingen(void)
{
	width = height = 0;
	map = 0;
}

terraingen::~terraingen(void)
{
	if ( map ) delete[] map;
}

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;
		}
	}

}

void test2() {
	srand(0);
	create_perlin_terrain(64);
	
	make_texture texture1, texture2;
	texture1.create(256,1);
	texture2.create(256,2);

	float yang = 0;

	dbPositionCamera(128,100,128);
	dbPointCamera(0,0,0);
	
	int		cube = dbCreateObjectCube(10);
	int		light = dbCreateLight();
	dbPositionLight(light,dbCameraPositionX(),dbCameraPositionY(),dbCameraPositionZ());

	dbSetImageChromaKey(255,0,255);
	int		img = dbLoadImage("terrain.bmp",0);
	dbSprite(1,0,0,img); dbHideSprite(1);
	//dbSizeSprite(1,800,600);
	dbColorBackdrop(0);

	int tr = dbCreateTerrain("terrain.bmp");
	make_texture t1; t1.create(256,6);
	dbTextureTerrain(tr,t1.image);

	int pl = dbCreateObjectPlane(256,256);
	dbColorObject(pl,0x000088);
	dbXRotateObject(pl,-90);
	dbPositionObject(pl,128,25,128);

	do {
		dbYRotateCamera(yang);
		yang=fmod((yang+0.7f),360);

		dbPasteSprite(1, 0, 0);

		dbSync();
	}
	while (windowEvent() != WM_CLOSE && dbEscapeKey() == 0);
	dbDeleteObject(cube);
	dbDeleteSprite(1);
	dbDeleteImage(img);
}

void create_perlin_terrain(int size) {
	// 1. Check file exists and delete (actually just delete it
	char fname[] = "terrain.png";
	remove(fname);	// no checking (not needed)
	
	// 2. create a bitmap
	int		bm = dbCreateBitmap(size,size);

	// 3. init the perlin noise
	PerlinNoise mynoise;
	mynoise.Set(0.75, 8, 0.9999, 6, 0);

	// 4. plot the terrain
	int		x, y;
	int		hgt;
	dbLockPixels();
	for (x=0; x<size; x++) {
		for (y=0; y<size; y++) {
			double sx = (double)x / (double)size;
			double sy = (double)y / (double)size;
			hgt = (int)( mynoise.GetHeight(sx,sy) * 127.0 + 128.0 );
			dbInk(dbRGB(hgt,hgt,hgt),0xffffff);
			dbDot(x,y);
		}
	}
	dbUnlockPixels();

	// 5. Save image
	int		img = dbGetImage(0,0,size-1,size-1);
	dbSaveImage(fname,img);
	dbDeleteBitmap(bm);
	dbDeleteImage(img);
}

#include <include/puregdk/core/puregdk.h>
#include <include/puregdk/plugins/puregdk-plugins.h>
#include <windows.h>

#pragma comment(lib, "comctl32.lib")

#include <time.h>
#include <vector>
#include <list>
#include <string>
#include <commctrl.h>
#include <math.h>

using namespace std;

// Project includes here
#include "trace.h"
#include "resource.h"
#include "pgdk_restore.h"
#include "prefs.h"
#include "globals.h"
#include "WL_DIALOG.h"
#include "random.h"
#include "make_texture.h"
#include "IK_constants.h"
#include "perlin_noise.h"
#include "terraingen.h"

// a global temp string (he he)
extern char	gstring[256];

#include <windows.h>
#include <stdio.h>
#include "perlin_noise.h"

int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
	// Right! No console window...

	// Check if the info file exists
	FILE	*fp = fopen( "pn_input.zzz", "r" );
	if ( fp )	// yup the file exists
	{
		FILE	*fpo = fopen( "pn_output.zzz", "w" );
		if ( fp )	// yup, we've also created the output file
		{
			// main perlin noise map generation goes here
			PerlinNoise noise;
			float persistance, frequency, amplitude;
			int octaves, randomseed;
			int size;
			float multiplier, adder;

			// read the input values from the file
			fread( &persistance, sizeof(float), 1, fp );
			fread( &frequency, sizeof(float), 1, fp );
			fread( &litude, sizeof(float), 1, fp );
			fread( &octaves, sizeof(int), 1, fp );
			fread( &randomseed, sizeof(int), 1, fp );
			fread( &size, sizeof(int), 1, fp );
			fread( &multiplier, sizeof(float), 1, fp );
			fread( &adder, sizeof(float), 1, fp );

			double _mult = multiplier;	// re cast it
			double _add  = adder;

			// Init the perlin noise
			noise.Set(persistance, frequency, amplitude, octaves, randomseed);

			int x, y;
			for ( x=0; x<size; x++ ) {
				for ( y=0; y<size; y++ ) {
					double sx = (double)x / (double)size;
					double sy = (double)y / (double)size;
					float hgt = (float)( noise.GetHeight( sx, sy ) * _mult + _add );
					fwrite( &hgt, sizeof(float), 1, fpo );
				}
			}

			fclose( fpo );
		}
		// close the input file
		fclose( fp );
	}

	return 0;
}

pinta:
autocam off
cls
ink rgb(255,255,255),1
box 0,0,128,128

for i= 1 to 400
col=55+rnd(200)
ink rgb(col,col,col),1
b=rnd(128)
ba=rnd(128)
t=5+rnd(25)
box b,ba,b+t,ba+t
next i
ink rgb(0,0,0),1  rem mascara 88888888
box 128,0,256,128
box 0,128,150,256
rem 8888888888888888888888888888888888
get image 2,0,0,128,128,1
paste image 2,0,0
lock pixels
for x= 1 to 128
for z= 1 to 128
col=point(x,z)/50

if col>130000 then ink rgb(200,200,200),1:dot x+128+rnd(5),z+rnd(5)
if col>200000 then ink rgb(155,155,155),1:dot x+128+rnd(5),z+rnd(5)
if col>260000 then ink rgb(180,180,180),1:dot x+128+rnd(5),z+rnd(5)
if col>330000 then ink rgb(75,75,75),1:dot x+128+rnd(5),z+rnd(5)
if col>250000 then ink rgb(200+rnd(55),200+rnd(55),200+rnd(55)): dot 128+x,z
next z
next x
unlock pixels

get image 10,128,0,256,128
create bitmap 1,128,128
paste image 10,0,0
blur bitmap 1,6
get image 10,0,0,128,128
paste image 10,0,0

`*********************
for x= 1 to 128
   for z= 1 to 128
     cal=point(x,z)/50
      if cal>300000 then ink rgb(255,255,255):dot x,z
      if cal<230000 then ink rgb(180+rnd(10),180+rnd(10),180+rnd(10)):dot x,z
      if cal<180000 then ink rgb(100+rnd(30),100+rnd(30),100+rnd(30)):dot x+rnd(1),z+rnd(1)
      if cal<160000 then ink rgb(80+rnd(10),80+rnd(10),80+rnd(10)):dot x,z
      if cal<120000 then ink rgb(60+rnd(10),60+rnd(10),60+rnd(10)):dot x,z
      if cal<80000 then ink rgb(40+rnd(10),40+rnd(10),40+rnd(10)):dot x,z
      if cal<40000 then ink rgb(20+rnd(10),20+rnd(10),20+rnd(10)):dot x,z
      if cal<15000 then ink rgb(0+rnd(50),0+rnd(50),0+rnd(50)):dot x,z

   next z
next x
`*********************

blur bitmap 1,4
get image 10,0,0,128,128
delete bitmap 1
cls
ink rgb(70,70,70),1
box 0,0,640,480
ink rgb(100,100,255),0
box 254,0,386,130
paste image 10,256,1



pe=2
do
if spacekey() then goto pinta
ink rgb(255,255,255),1

if controlkey()
   get image 10,256,1,384,129,1

   create bitmap 1,128,128
   paste image 10,0,0
   blur bitmap 1,6
   get image 10,0,0,128,128,1
   delete bitmap 1
   paste image 10,256,1

   save image "heightmap.bmp",10
endif


color=point(mousex(),mousey())/50
set cursor 0,20
box 0,140,50,180
print "  SPACE     change map ramdomly"
print "  CONTROL   save  map"
print "  MOUSE 1   PAINT"
print "  MOUSE 2   TAKE COLOR "
print "  Buttons 1 to 6  Pencil size "

rem pintar el mapa ***************************************************************
if inkey$()="1" then pe=1
if inkey$()="2" then pe=2
if inkey$()="3" then pe=3
if inkey$()="4" then pe=4
if inkey$()="5" then pe=5
if inkey$()="6" then pe=8

ink rgb(255,0,0),0
set cursor 5,155:print pe


rem paleta de colores
for i= 0 to 10
col=255-i*25.5
ink rgb(col,col,col),0
box i*10,100,i*10+10,110
next




if mouseclick()=2
color=point(mousex(),mousey())
inkcolor=rgb(rgbr(color),rgbg(color),rgbb(color))
endif

ink rgb(255,0,0),0
box 18,148,42,172  // borde rojo
Ink inkcolor,0
box 20,150,40,170  // cuadrado de color


if mouseclick()=1 and mousex()>255 and mousex()<382 and mousey()>0 and mousey()<127
for i= 1 to pe
ellipse mousex(),mousey(),i,i
next i
endif
rem *******************************************************************************

sync
loop

autocam off
sync on
sync rate 60

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

noise = generate_noise_map(64,0)

obj=create_terrain(noise)
img=create_texture(1024,320)
texture object obj,img
set object specular obj,0xffffff
set object specular power obj,5
set object smoothing obj,60

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

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

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

end

function generate_noise_map(size,seed)
    fp_flt as float : fp_int as integer : v as float

    fnum = find free file()
    open to write fnum, "pn_input.zzz"
    
    ` I'm cheating here and using FIXED point precision
    v = (0.75 * 65536.0) :   write long fnum, int(v)
    v = (8.0 * 65536.0) :   write long fnum, int(v)
    v = (1.0 * 65536.0) :   write long fnum, int(v)
    write long fnum, 6
    write long fnum, seed
    write long fnum, size
    v = (127.0 * 65536.0) : write long fnum, int(v)
    v = (128.0 * 65536.0) : write long fnum, int(v)
    close file fnum
    execute file "perlin_noise_cmd.exe","","",1
    delete file "pn_input.zzz"
    
    if file exist("pn_output.zzz")
        open to read fnum, "pn_output.zzz"
        img = find free image()
        bm = find free bitmap()
        create bitmap bm, size,size
        lock pixels
        for y=0 to size-1
            for x=0 to size-1
                read byte fnum, fp_int
                col = fp_int `( fp_int >> 16 ) and 255
                ink rgb(col,col,col),0
                dot x,y
            next
        next
        unlock pixels
        close file fnum
        delete file "pn_output.zzz"
        get image img,0,0,size-1,size-1
    else
        img = 0
    endif
endfunction img

function create_noise_map(size,seed)
    PN_init(0.5, 8.0, 3.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# ) * 32.0 + 128.0
            col = h#
            ink rgb(col,col,col),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

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

int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
	// Right! No console window...

	// Check if the info file exists
	ifstream ifile; ifile.open("pn_input.zzz");
	if ( ifile.is_open() )	// yup the file exists
	{
		//FILE	*fpo = fopen( "pn_output.zzz", "w" );
		ofstream ofile; ofile.open("pn_output.zzz");
		if ( ofile.is_open() )	// yup, we've also created the output file
		{
			// main perlin noise map generation goes here
			PerlinNoise noise;
			double persistance, frequency, amplitude;
			int octaves, randomseed;
			int size;
			double _mult, _add;
			int val;

			// read the input values from the file
			
			ifile.read((char*)&val,sizeof(int)); persistance = (double)val / (double)65536.0;
			ifile.read((char*)&val,sizeof(int)); frequency = (double)val / (double)65536.0;
			ifile.read((char*)&val,sizeof(int)); amplitude = (double)val / (double)65536.0;
			ifile.read((char*)&octaves,sizeof(int));
			ifile.read((char*)&randomseed,sizeof(int));
			ifile.read((char*)&size,sizeof(int));
			ifile.read((char*)&val,sizeof(int)); _mult = (double)val / (double)65536.0;
			ifile.read((char*)&val,sizeof(int)); _add = (double)val / (double)65536.0;

			// Init the perlin noise
			noise.Set(persistance, frequency, amplitude, octaves, randomseed);

			int x, y;
			for ( y=0; y<size; y++ ) {
				for ( x=0; x<size; x++ ) {
					double sx = (double)x / (double)size;
					double sy = (double)y / (double)size;
					double ngh = ( ( noise.GetHeight( sx, sy ) * _mult ) + _add );// * (double)65536.0 );
					unsigned char hgt = (int)ngh;
					
					ofile.write((char*)&hgt,sizeof(char));
				}
			}

			ofile.close();
		}
		// close the input file
		ifile.close();
	}

	return 0;
}

function create_terrain_texture(size,noise,seed)
    dim img(4)      ` space for 5 images
    randomize seed
    for a=0 to 3
        temp=create_texture(size,rnd(65535))
        img(a)=find free bitmap()
        create bitmap img(a),size,size
        paste image temp,0,0
        delete image temp
    next
    
    noise_map_wid# = image width(noise)
    noise_map_hgt# = image height(noise)
    
    img(4) = find free bitmap()
    create bitmap img(4),noise_map_wid#,noise_map_hgt#
    paste image noise,0,0
    
    bm=find free bitmap()
    create bitmap bm,size,size
    
    noise_map_xmult# = noise_map_wid# / size
    noise_map_ymult# = noise_map_hgt# / size
    
    for y=0 to size-1
        for x=0 to size-1
            noise_mapx = noise_map_xmult# * x
            noise_mapy = noise_map_ymult# * y
            
            set current bitmap img(4)
            texture_num = ( point(noise_mapx, noise_mapy) >> 6 ) and 3
            
            set current bitmap img(texture_num)
            col = point( x, y )
            
            set current bitmap bm
            ink col,col
            dot x,y
        next
    next
    
    for a=0 to 4
        delete bitmap img(a)
    next
    
    set current bitmap bm
    img=find free image()
    get image img,0,0,size-1,size-1
    delete bitmap bm
endfunction img