Keith Vetter 2002-11-11 - This program draws mountain landscapes using fractals. It is based on an article at [1].The fractal algorithm it uses is a fairly common one. It takes an equilateral triangle (actually two of them that together form a parallelogram for easier coding) and assigns heights to each vertex. For each iteration level, it subdivides every triangle into four similar, smaller triangles. The vertices of the new triangles are assigned height values based on the average height of the neighboring vertices with a random deviation added in. This random deviation is smaller for deeper iterations, thereby giving the fractal quality of scaled similar details.Generating the fractal mountain is only the first step, you also have to display it. For hidden surface removal it uses a painter's algorithm (back-to-front drawing). The basic color is based on altitude: blue for below sea level, green up to the treeline, white above the snowline and some shade of green to brown in between treeline and snowline. The brightness of the color is determined by the angle of incidence from a fixed light source.On my fairly fast Windows machine, iteration level 6 takes about 10 seconds and looks okay; level 7 takes about 1 minute and looks very good; level 8 and 9 take too long.Available as a Starkit from the Starkit Distribution Archive at http://tcl.tk/starkits/fractal.kit
Discussion edit
Wow... this is brilliant! davidwKPV 2002-11-12 -- added two new features: you can vary the altitude of the water level; and redraw does some fancy footwork to keep the same mountain data even if you vary the number of iterations.The mountains this makes are so nice that I wanted to look at them from all directions. So I put together some code to display the mountain using TkOGL (over on the OpenGL page). Unfortunately I don't know much about OpenGL so the lighting doesn't work right, and it could probably be optimized better for OpenGL. But its nifty nontheless. GL Fractal Mountains
Code edit
##+##########################################################################
#
# Fractal Mountain
#
# Builds and displays a fractal mountain. Based on code at
# http://www.mactech.com/articles/mactech/Vol.07/07.05/FractalMountains/
# by Keith Vetter
#
# Revisions:
# KPV Nov 07, 2002 - initial revision
# KPV Nov 12, 2002 - added variable water level; better redraw for new depths
#
##+##########################################################################
package require Tk
if {[catch {package require Tcl 8.4}]} {
package require Tcl 8.3
proc lset {_lvar idx value} { ;# Need lset from 8.4
upvar 1 $_lvar lvar
set lvar [lreplace $lvar $idx $idx $value]
}
}
interp alias {} = {} expr
set S(version) 1.2
set S(date) "Nov 12, 2002"
# S(v,*) = GUI S(w,*) = what user wants to see M(d,*) = what's in $map
set S(params) [list depth contour roughness nHeight profile xTilt flood]
set S(v,depth) 6 ;# Number of iterations
set S(v,contour) 1.00 ;# The contour of the mountain
set S(v,roughness) 2.75 ;# How jagged the mountain
set S(v,nHeight) 7 ;# Max height of mountain
set S(v,profile) 1 ;# Profile number (1-4)
set S(v,xTilt) 80 ;# Tilt angle (in degrees)
set S(v,flood) 50
set M(d,depth) -1 ;# No map yet
set S(maxIter) 9 ;# Bounds our height
set S(normalHeightBase) 10000 ;# Normalized height
set S(normalHeightBase) 10000 ;# Normalized height
set S(water) 0 ;# Water level altitude
set S(nocolor) 0
set S(seed) 0
# Unit vector to our light source
set S(lx) [= {-1 / sqrt(3)}]; set S(ly) [= {-$S(lx)}]; set S(lz) [= {-$S(lx)}]
set MIN_INT 0x80000000
set DEG2RAD [= {4*atan(1)*2/360}]
proc LMAP {a b v} { lset ::map [= {$a + $b*$::M(S)}] $v; return}
proc LMAP {a b v} { lset ::map [= {$a + $b*$::M(S)}] $v}
proc LMAP1 {a v} { lset ::map $a $v; return}
proc RMAP {a b} { return [lindex $::map [= {$a + $b*$::M(S)}]]}
proc RMAP1 {a} { return [lindex $::map $a]}
##+##########################################################################
#
# Go - Computes the new mountain and draws it.
#
proc Go {{how 1}} {
global S M
set start [clock click -milliseconds]
clear
if {$how == 1} {
set M(d,depth) -1 ;# Force recalculation
set S(seed) [clock clicks -milliseconds]
}
set S(draw) 1
ToggleButtons 1
CalcMountains
DrawMountains
set start [= {([clock click -milliseconds] - $start) / 1000}]
Stop
set msg "Iterations: $S(w,depth) Contour: $M(d,contour) "
append msg "Smoothness: $M(d,roughness) Height: $M(d,nHeight) "
append msg "Profile: $M(d,profile) Tilt: $S(w,xTilt) ([Duration $start])"
INFO $msg
}
proc Stop {} {
global S
set S(draw) 0
ToggleButtons 0
ProgressBar 1 0
}
##+##########################################################################
#
# CopyParameters
#
# Copies gui/want/data parameter values to g/w/d as requested
#
proc CopyParameters {from to} {
global S M
foreach v [array names S $from,*] {
foreach {a b} [split $v ,] break
if {$to == "d"} {
set M($to,$b) $S($v)
} else {
set S($to,$b) $S($v)
}
}
}
##+##########################################################################
#
# CalcMountains
#
# Initializes our mountain grid for the profile and then does the
# recursive iterations to build up our fractal. It then normalizes
# all the data to be under a certain height.
#
proc CalcMountains {} {
global M S
CopyParameters v w ;# Params the user wants to use
set n [CompareParameters] ;# Is data still valid???
if {$n == 2} {
INFO "Reusing existing mountain data"
return
}
# Generate each main triangle recursively
InitMountains $n
INFO "Calculating the [comma [= {1 + $M(N)}]] points in the display"
IterCalc 0 $M(D) $M(N) [= {$S(maxIter)+1}]
IterCalc [= {$M(S) * $M(D)}] $M(N) 0 [= {$S(maxIter)+1}]
NormalizeMap
CopyParameters w d ;# Parameters for our data
return
}
##+##########################################################################
#
# CompareParameters: returns TRUE if data is still ok for S(w,*) params
# 0 - total mismatch
# 1 - new depth is greater
# 2 - compatible
#
proc CompareParameters {} {
global M S
if {$M(d,depth) == -1} {return 0} ;# No map data
foreach v [array names S w,*] {
if {$v == "w,depth"} continue
if {$v == "w,xTilt"} continue ;# Only visual affects
if {$v == "w,flood"} continue ;# Only visual affects
foreach {a b} [split $v ,] break
if {$M(d,$b) != $S(w,$b)} { return 0}
}
if {$S(w,depth) <= $M(d,depth)} { return 2} ;# Less deep, okay
return 1
}
##+##########################################################################
#
# InitMountains
#
# Creates the initial grid for our mountain.
#
proc InitMountains {up} {
global map M S MIN_INT
if {$up} {
set map2 $map ; set D $M(d,depth) ; set MD $M(D) ; set MS $M(S)
}
= {srand($S(seed))}
set M(D) [= {1 << $S(w,depth)}]
set M(S) [= {$M(D) + 1}] ;# Points along side of triangle
set M(N) [= {$M(S) * $M(S) - 1}] ;# Last point in our grid
set S(normalHeight) [= {$S(normalHeightBase) * $S(w,nHeight)}]
set map [string repeat " $MIN_INT" [= {1+$M(N)}]] ;# Our mountain
if {$up} {
GoDeeper $map2 $D $MD $MS
return
}
# Generate starting profile to build on
set q [MaxDeviation [= {$S(maxIter)+1}]]
set q [= {$q / 2}]
set nq [= {-$q}]
set d2 [= {$M(D) / 2}]
if {$S(w,profile) == 1} { ;# Back up, front down, corner 0
LMAP 0 0 $q
LMAP $M(D) 0 0
LMAP 0 $M(D) 0
LMAP $M(D) $M(D) $nq
} elseif {$S(w,profile) == 2} { ;# Back up; side/corners 0
LMAP 0 0 $q
LMAP $M(D) 0 0
LMAP 0 $M(D) 0
LMAP $M(D) $M(D) 0
if {$d2 > 0} {
LMAP $d2 $d2 0
LMAP $d2 $M(D) 0
LMAP $M(D) $d2 0
}
} elseif {$S(w,profile) == 3} { ;# front down, corners 0
LMAP 0 0 0
LMAP $M(D) 0 0
LMAP 0 $M(D) 0
LMAP $M(D) $M(D) $nq
} elseif {$S(w,profile) == 4} {
LMAP 0 0 0
LMAP $M(D) 0 0
LMAP 0 $M(D) 0
LMAP $M(D) $M(D) 0
if {$d2 > 0} {
LMAP $d2 $d2 [= {$q/2}]
LMAP $d2 0 $q
LMAP 0 $d2 $q
}
} elseif {$S(w,profile) == 5} {
LMAP 0 0 $q
LMAP $M(D) 0 0
LMAP $d2 0 [= {$q / 2}]
LMAP 0 $M(D) 0
LMAP $M(D) $M(D) $nq
} else {
error "profile out of range (1-4): $S(w,profile)"
}
}
##+##########################################################################
#
# GoDeeper - Transfers all elevation info from old map at level D
# into the current map. IterCalc still needs to be called to fill
# in the rest of the slots.
#
proc GoDeeper {map2 D MD MS} {
global map S M
set step [= {1 << ($S(w,depth) - $D)}]
set idx -1
for {set y 0} {$y < $M(S)} {incr y $step} {
for {set x 0} {$x < $M(S)} {incr x $step} {
LMAP $x $y [lindex $map2 [incr idx]]
}
}
}
##+##########################################################################
#
# MaxDeviation
#
# Returns the maximum deviation allowed for a given recursion depth.
# The function is strictly decreasing monotonic as depth increases.
#
proc MaxDeviation {ic} {
global S
if {$S(w,roughness) == 0} { return 100000 }
return [= {int(8.0 * pow ($S(w,roughness), $ic-1))}]
}
##+##########################################################################
#
# NormalizeMap
#
# Scales all heights to be w/i normalHeight and applies contour transformation.
#
proc NormalizeMap {} {
global map S M MIN_INT
set max [lindex $map 0] ;# Get max height
foreach v $map {
if {$v > $max} { set max $v}
}
if {$max <= 0} {set max 10000} ;# All water, avoid divide by 0
set z [= {pow($max, $S(w,contour))}]
set z [= {$S(normalHeight) / $z}]
set map2 {}
set min [set max 0]
foreach k $map {
if {$k >= 0} {
set i [= {pow($k, $S(w,contour)) * $z}]
set val [= {int($i)}]
if {$val > $max} {set max $val}
} else {
set i [= {pow(-$k, $S(w,contour)) * $z}]
set val [= {int(-$i)}]
if {$val < $min} {set min $val}
}
lappend map2 $val
}
set map $map2
set M(min) $min
set M(max) $max
return
}
##+##########################################################################
#
# IterCalc
#
# Given three points of a triangle it calculates the midpoints of each
# side and recurses. Parameter c is the depth.
#
proc IterCalc {s1 s2 a c} {
global map MIN_INT
incr c -1 ;# Decrement iteration count
set ns1 [= {($s1 + $a) / 2}] ;# Midpoints of sub-triangle
set ns2 [= {($s2 + $a) / 2}]
set na [= {($s1 + $s2) / 2}]
set vs1 [RMAP1 $s1]
set vs2 [RMAP1 $s2]
set va [RMAP1 $a]
if {[RMAP1 $ns1] == $MIN_INT} {
LMAP1 $ns1 [= {($vs1 + $va) / 2}]
DeviatePoint $ns1 $c
}
if {[RMAP1 $ns2] == $MIN_INT} {
LMAP1 $ns2 [= {($vs2 + $va) / 2}]
DeviatePoint $ns2 $c
}
if {[RMAP1 $na] == $MIN_INT} {
LMAP1 $na [= {($vs1 + $vs2) / 2}]
DeviatePoint $na $c
}
# Recurse on sub-triangles if we haven't bottomed out
if {$ns1 + 1 >= $ns2} return
IterCalc $s1 $na $ns1 $c
IterCalc $na $s2 $ns2 $c
IterCalc $ns1 $ns2 $na $c
IterCalc $ns1 $ns2 $a $c
}
##+##########################################################################
#
# DeviatePoint
#
# Deviates a point up or down by a random amount between
# -MaxDeviation to +MaxDeviation.
#
proc DeviatePoint {o ic} {
global map S
if {$S(w,roughness) < 0} return
set v [MaxDeviation $ic]
set r [Rand [= {-$v}] $v]
LMAP1 $o [= {[RMAP1 $o] + $r}]
}
##+##########################################################################
#
# Rand
#
# Returns a random number between first and last.
#
proc Rand {first last} {
set delta [= {$last - $first + 1}]
set r [= {$first + int(rand() * $delta)}]
return $r
}
proc PrintData {} {
global map M
set cnt 0
foreach v $map {
if {$v == 0x80000000} {
puts -nonewline [format "%9s" --]
} else {
puts -nonewline [format "% 9ld" $v]
}
if {([incr cnt] % $M(S)) == 0} { puts ""}
}
}
#
# Drawing routines
#
##+##########################################################################
#
# DrawMountains
#
# Sets up the transformation variables and then draws all the triangles.
#
proc DrawMountains {{lvl ""}} {
global tm M S xc sc wx wy
if {$lvl == ""} { ;# Called from Go
set lvl $S(w,depth)
update
if {$S(draw) == 0} return
}
if {$lvl > $M(d,depth)} { error "ERROR: Can't display level $lvl" }
if {$lvl <= 0} {
set lvl [= {$M(d,depth) + $lvl}]
if {$lvl < 0} { set lvl 0 }
}
set D [= {1 << $lvl}] ;# Nodes per side
set step [= {1 << ($M(d,depth) - $lvl)}] ;# Step size for this data set
INFO "Drawing the [comma [= {2*$D*$D}]] triangles in the display"
set S(draw) 1
set wx [winfo width .c]
set wy [winfo height .c]
set wd [expr {$wx > $wy ? $wy : $wx}]
set xc [= {0.4073 * (1 << ($S(maxIter) - $S(w,depth)))}]
set xc [= {0.4073 * (1 << ($S(maxIter) - $M(d,depth)))}]
set sc [= {$wd / 630.0}]
# Make transformation matrix for rotating around x axis
set tm(0,0) 1
set tm(1,0) 0
set tm(2,0) 0
set tm(0,1) 0
set tm(1,1) [= {cos(-$S(w,xTilt) * $::DEG2RAD)}]
set tm(2,1) [= {sin(-$S(w,xTilt) * $::DEG2RAD)}]
set tm(0,2) 0
set tm(1,2) [= {-sin(-$S(w,xTilt) * $::DEG2RAD)}]
set tm(2,2) [= {cos(-$S(w,xTilt) * $::DEG2RAD)}]
# Figure out water level
set S(water) [= {$M(min) + $S(w,flood) * ($M(max) - $M(min)) / 100.0}]
# Go back to front, left to right, and draw each triangle
.c delete triag2
for {set y 0} {$y < $M(D)} {incr y $step} {
set y1 [= {$y + $step}]
for {set x 0} {$x < $M(D)} {incr x $step} {
set x1 [= {$x + $step}]
DrawTriangle $x $y $x $y1 $x1 $y1
DrawTriangle $x $y $x1 $y1 $x1 $y
}
ProgressBar $y $M(D)
update
if {! $S(draw)} break
}
ProgressBar 1 0
set sr [.c bbox all]
}
##+##########################################################################
#
# DrawTriangle
#
# Draw a given triangle. This routine is mainly concerned with the
# possibility that a triangle could span the waterline. If this
# occurs, this procedure breaks it up into three smaller triangles,
# each of which is either above or below water. All actual drawing or
# coloration is delegated to _DrawTriangle.
#
proc DrawTriangle {x0 y0 x1 y1 x2 y2} {
global S
set z0 [RMAP $x0 $y0]
set z1 [RMAP $x1 $y1]
set z2 [RMAP $x2 $y2]
# Easy cases: all underwater or all above water
if {$z0 <= $S(water) && $z1 <= $S(water) && $z2 <= $S(water)} {
_DrawTriangle $x0 $y0 $S(water) $x1 $y1 $S(water) $x2 $y2 $S(water)
} elseif {$z0 >= $S(water) && $z1 >= $S(water) && $z2 >= $S(water)} {
_DrawTriangle $x0 $y0 $z0 $x1 $y1 $z1 $x2 $y2 $z2
} else { ;# Spans the water line
set p0 [list $x0 $y0 $z0]
set p1 [list $x1 $y1 $z1]
set p2 [list $x2 $y2 $z2]
set w(0) [= {$z0 < $S(water)}]
set w(1) [= {$z1 < $S(water)}]
set w(2) [= {$z2 < $S(water)}]
if {$w(0) != $w(1) && $w(0) != $w(2)} {
set ap $p0
set s0 $p1
set s1 $p2
} elseif {$w(1) != $w(0)} {
set s1 $p0
set ap $p1
set s0 $p2
} else {
set s0 $p0
set s1 $p1
set ap $p2
}
foreach {apx apy apz} $ap break
foreach {s(0,x) s(0,y) s(0,z)} $s0 break
foreach {s(1,x) s(1,y) s(1,z)} $s1 break
# At this point, ap is the "odd man out" - either it is above
# water and the other two are below, or it is below and the
# other two are above. Which corner s[0] is and which s[1] is
# *is* important - if we get the wrong order, the normal
# vector used to find the shading coefficient is the wrong
# sign. This is true whenever we are manipulating corners -
# the ordering is always important.
# Find the "midpoints" between ap and s[0]&s[1] - this is
# where we split our big triangle into smaller triangles.
# Actually it is not a normal midpoint, but a weighted
# midpoint, such that the z component is 0 - waterline.
foreach n {0 1} {
set f($n) [= {-1.0 * ($apz - $S(water)) / ($s($n,z) - $apz)}]
set m($n,x) [= {$apx - ($apx - $s($n,x)) * $f($n)}]
set m($n,y) [= {$apy - ($apy - $s($n,y)) * $f($n)}]
set m($n,z) $S(water)
}
# Set whichever triangles are below water to 0 altitude
if {$apz < $S(water)} {set apz $S(water)} else {
set s(0,z) $S(water); set s(1,z) $S(water)}
# Draw our three triangles
_DrawTriangle $apx $apy $apz $m(0,x) $m(0,y) $m(0,z) \
$m(1,x) $m(1,y) $m(1,z)
_DrawTriangle $m(0,x) $m(0,y) $m(0,z) $s(0,x) $s(0,y) $s(0,z) \
$s(1,x) $s(1,y) $s(1,z)
_DrawTriangle $m(0,x) $m(0,y) $m(0,z) $s(1,x) $s(1,y) $s(1,z) \
$m(1,x) $m(1,y) $m(1,z)
}
}
##+##########################################################################
#
# _DrawTriangle
#
# This routine actually draws a triangle, given by a set of three
# (x,y,z) triplets. It determines the color and shading according to
# altitude and lighting, and draws the triangle.
#
proc _DrawTriangle {x1 y1 z1 x2 y2 z2 x3 y3 z3} {
global S
# Transform into viewing space
foreach {X1 Y1 Z1} [CalcPoint3 $x1 $y1 $z1] break
foreach {X2 Y2 Z2} [CalcPoint3 $x2 $y2 $z2] break
foreach {X3 Y3 Z3} [CalcPoint3 $x3 $y3 $z3] break
set coords [list $X1 $Y1 $X2 $Y2 $X3 $Y3]
# Figure out what color we want: blue, green or gray
if {$z1 == $S(water) && $z2 == $S(water) && $z3 == $S(water)} {
set color "#9fff9fffffff" ;# Water
} else {
set treeline [= {.4 * $S(normalHeight) + 10000}]
set snowcap [= {$treeline + 19000}]
set az [= {($z1 + $z2 + $z3) / 3.0}] ;# Average height
if {$az > $snowcap} {
set color 150 ;# Gray
} elseif {$az < $treeline} {
set color 0 ;# Green
} else {
set color [= {($az - $treeline) / (($snowcap - $treeline)/150)}]
}
# Determine the normal to surface via the cross product
set v1x [= {$X2-$X1}]; set v1y [= {$Y2-$Y1}]; set v1z [= {$Z2-$Z1}]
set v2x [= {$X3-$X1}]; set v2y [= {$Y3-$Y1}]; set v2z [= {$Z3-$Z1}]
set nx [= {$v1y*$v2z - $v1z*$v2y}]
set ny [= {$v1z*$v2x - $v1x*$v2z}]
set nz [= {$v1y*$v2x - $v1x*$v2y}]
if {$nx > 10000 || $ny > 10000 || $nz > 10000} {
set nx [= {$nx / 10000.0}]
set ny [= {$ny / 10000.0}]
set nz [= {$nz / 10000.0}]
}
# Blend to brown and white over treeline (work in hsv color model)
set C [= {(150-$color) / 150.0}]
set h [= {$C * (120 - 45) + 45}] ;# 120 -> 45
set s $C ;# 1 -> 0
set v [= {.94 - $C * (.94 - 2.0/3)}] ;# .94 -> .667
# Scale brightness according to the incidence of light
set len [= {sqrt(double($nx)*$nx + $ny*$ny + $nz*$nz)}]
if {$len == 0} return
set i [= {(($S(lx)*$nx + $S(ly)*$ny + $S(lz)*$nz) / $len) / 2.0 + .5}]
set vv [= {$i * $v}]
set color [hsv2rgb $h $s $vv]
}
if {$S(nocolor)} {
.c create poly $coords -fill {} -tag triag2 -outline black
} else {
.c create poly $coords -fill $color -tag triag -outline $S(triag)
}
}
##+##########################################################################
#
# CalcPoint3
#
# Transform from map coordinates to screen coordinates
#
proc CalcPoint3 {x y z} {
global M xc sc tm
set xp [= {$xc * (2*$x - $y + $M(D))}]
set yp [= {$xc * (2*$y)}]
set zp [= {$z * 0.00217}]
set x [= {$xp*$tm(0,0) + $yp*$tm(1,0) + $zp*$tm(2,0)}]
set y [= {$xp*$tm(0,1) + $yp*$tm(1,1) + $zp*$tm(2,1)}]
set z [= {$xp*$tm(0,2) + $yp*$tm(1,2) + $zp*$tm(2,2)}]
set x [= {round ($sc * $x)}]
set y [= {round ($sc * ($y + 230))}]
set z [= {round ($sc * $z)}]
return [list $x $y $z]
}
##+##########################################################################
#
# hsv2rgb
#
# Convert from HSV color model to RGB model. h is 0.0 to 360.0, s and v
# are 0.0 to 1.0.
#
proc hsv2rgb {h s v} {
set v [= {double($v)}]
set r [set g [set b 0.0]]
if {$h == 360 || $h == -1} { set h 0 }
set h [= {$h/60}]
set i [= {int(floor($h))}]
set f [= {$h - $i}]
set p1 [= {$v*(1-$s)}]
set p2 [= {$v*(1-($s*$f))}]
set p3 [= {$v*(1-($s*(1-$f)))}]
switch -- $i {
0 { set r $v ; set g $p3 ; set b $p1 }
1 { set r $p2 ; set g $v ; set b $p1 }
2 { set r $p1 ; set g $v ; set b $p3 }
3 { set r $p1 ; set g $p2 ; set b $v }
4 { set r $p3 ; set g $p1 ; set b $v }
5 { set r $v ; set g $p1 ; set b $p2 }
}
set color [format "#%04X%04X%04X" [= {int($r * 65535)}] \
[= {int($g * 65535)}] [= {int($b * 65535)}]]
return $color
}
#
# GUI stuff
#
proc DoDisplay {} {
wm title . "Fractal Mountains"
wm protocol . WM_DELETE_WINDOW exit
DoMenus
frame .bottom -bd 2 -relief ridge
canvas .c -width 600 -height 600 -bd 2 -relief raised -highlightthickness 0
canvas .msg -bd 1 -relief sunken -height 20 -highlightthickness 0
.msg xview moveto 0 ; .msg yview moveto 0
.msg create text 5 2 -tag txt -anchor nw
pack .bottom -side right -fill y
pack .msg -side bottom -fill x
pack .c -side top -fill both -expand 1
myOptMenu .f1 Iterations S(v,depth) 1 2 3 4 5 6 7 8 9
myOptMenu .f2 Contour S(v,contour) \
0.25 0.50 0.75 1.00 1.25 1.50 1.75 2.00 3.00 5.00
myOptMenu .f3 Smoothness S(v,roughness) \
1.00 1.25 1.50 1.75 2.00 2.25 2.75 3.50 5.00
myOptMenu .f4 Height S(v,nHeight) 1 2 3 4 5 6 7 8 9
myOptMenu .f5 Profile S(v,profile) 1 2 3 4 5
myOptMenu .f6 Tilt S(v,xTilt) 0 10 20 30 45 50 60 70 80 90
myScale .f7 " Water\n Level" S(v,flood) 0 100
frame .spacer
button .go -text "Draw Mountain" -command {Go 1} -bd 4
button .redraw -text "Redraw Mountain" -command {Go 2} -bd 4 -state disabled
button .stop -text "Stop Drawing" -command Stop -bd 4 -state disabled
.go configure -font "[font actual [.go cget -font]] -weight bold"
.redraw configure -font [.go cget -font]
.stop configure -font [.go cget -font]
button .fill -text "Clear Coloring" -command ClearColoring -bd 4 \
-state disabled
checkbutton .triag -text "Show Triangles" -command ShowTriangles \
-variable S(triag) -relief raised -anchor w -bd 4 \
-onvalue black -offvalue {}
grid .f1 - - -in .bottom -sticky ew -row 0
grid .f2 - - -in .bottom -sticky ew
grid .f3 - - -in .bottom -sticky ew
grid .f4 - - -in .bottom -sticky ew
grid .f5 - - -in .bottom -sticky ew
grid .f6 - - -in .bottom -sticky ew
grid .f7 - - -in .bottom -sticky ew
grid .spacer -in .bottom -pady 10 -row 50
grid x .go x -in .bottom -sticky ew
grid x .redraw x -in .bottom -sticky ew
grid x .stop x -in .bottom -sticky ew -pady 10
grid rowconfigure .bottom 100 -weight 1
grid x .fill x -in .bottom -sticky ew -row 101
grid x .triag x -in .bottom -sticky ew
bind all <Alt-c> {console show}
update
}
proc myScale {f lbl var from to} {
frame $f -bd 2 -relief raised
label $f.lbl -text $lbl -bd 0 -anchor w
label $f.lbl2 -text "value%"
scale $f.s -orient h -from $from -to $to -showvalue 0 -variable $var
$f.s config -command [list myScale2 $f.lbl2]
pack $f.lbl -side left -expand 1 -fill x
pack $f.lbl2 -side top
pack $f.s -side bottom
return $f
}
proc myScale2 {w value} {
$w config -text "$value%"
}
proc DoMenus {} {
. configure -menu [menu .m -tearoff 0]
.m add cascade -menu [menu .m.file -tearoff 0] -label "File" -underline 0
.m add cascade -menu [menu .m.help -tearoff 0] -label "Help" -underline 0
.m.file add command -label "Draw Mountain" -under 0 -command {Go 1}
.m.file add command -label "Redraw Mountain" -under 0 -command {Go 2}
.m.file add command -label "Stop Drawing" -under 0 -command {Go 0}
.m.file add separator
.m.file add command -label Exit -under 0 -command exit
.m.help add command -label Help -under 0 -command Help
.m.help add separator
.m.help add command -label About -under 0 -command About
}
set SplashData {
{{ 56 35 93 50 74 32} E2E2E2} {{ 93 50 112 33 74 32} D8D8D8}
{{ 93 50 130 56 112 33} CED19D} {{130 56 149 56 112 33} 97C35A}
{{162 87 159 89 168 89} 9f9fff} {{149 56 130 56 162 87} 00A700}
{{130 56 159 89 162 87} 00A700} {{174 86 162 87 168 89} 9f9fff}
{{186 64 149 56 174 86} 00A200} {{149 56 162 87 174 86} 00A200}
{{174 86 193 84 186 64} 00A700} {{168 89 205 89 174 86} 9f9fff}
{{205 89 193 84 174 86} 9f9fff} {{223 82 193 84 205 89} 9f9fff}
{{186 64 193 84 223 82} 00A500} {{ 37 57 74 66 56 35} D4D6A4}
{{ 74 66 93 50 56 35} DCDCB0} {{ 74 66 112 59 93 50} 6FA13F}
{{112 59 130 56 93 50} 88B251} {{144 93 140 95 149 95} 9f9fff}
{{130 56 112 59 144 93} 00A800} {{112 59 140 95 144 93} 00A800}
{{144 93 159 89 130 56} 00A900} {{149 95 168 89 144 93} 9f9fff}
{{168 89 159 89 144 93} 9f9fff} {{149 95 186 95 168 89} 9f9fff}
{{186 95 205 89 168 89} 9f9fff} {{ 19 81 56 82 37 57} 009B00}
{{ 56 82 74 66 37 57} 00A100} {{ 56 82 93 90 74 66} 00A000}
{{ 93 90 112 59 74 66} 009200} {{ 93 90 130 101 112 59} 00A400}
{{140 95 132 101 149 95} 9f9fff} {{112 59 130 101 140 95} 00A500}
{{130 101 132 101 140 95} 00A500} {{131 102 132 101 130 101} 00A500}
{{168 102 149 95 131 102} 9f9fff} {{149 95 132 101 131 102} 9f9fff}
{{168 102 186 95 149 95} 9f9fff} {{ 33 107 5 108 37 108} 9f9fff}
{{ 19 81 5 108 33 107} 00A000} {{ 5 108 5 108 33 107} 9f9fff}
{{ 42 107 33 107 37 108} 9f9fff} {{ 56 82 19 81 42 107} 009C00}
{{ 19 81 33 107 42 107} 009C00} {{ 55 108 42 107 37 108} 9f9fff}
{{ 74 102 56 82 55 108} 008A00} {{ 56 82 42 107 55 108} 008A00}
{{ 74 102 93 90 56 82} 009E00} {{100 104 83 108 112 108} 9f9fff}
{{ 93 90 74 102 100 104} 00AA00} {{ 74 102 83 108 100 104} 00AA00}
{{130 102 100 104 112 108} 9f9fff} {{130 101 93 90 130 102} 00A400}
{{ 93 90 100 104 130 102} 00A400} {{130 102 131 102 130 101} 00A900}
{{112 108 149 108 130 102} 9f9fff} {{149 108 131 102 130 102} 9f9fff}
{{131 102 131 102 130 101} 00A900} {{149 108 168 102 131 102} 9f9fff}
{{168 102 131 102 131 102} 9f9fff}}
##+##########################################################################
#
# Splash
#
# Draws our startup screen
#
proc Splash {{w .c}} {
$w delete all
font create myfont -family Times -size 72
foreach cmd $::SplashData {
$w create poly [lindex $cmd 0] -fill "\#[lindex $cmd 1]" \
-tag [list triag [lindex $cmd 1]]
}
foreach {l t r b} [$w bbox triag] break
set x $r
set y [= {($t + $b)/2}]
$w create text $x $y -text "Fractal" -anchor w -font myfont -tag {L1 txt}
set x [= {[winfo width $w] / 2}]
if {$x == 0} { set x [= {[winfo reqwidth $w] / 2}]}
foreach {l t r b} [$w bbox L1] break
set y [= {$y + $b - $t}]
$w create text $x $y -text "Mountains" -anchor c -font myfont -tag {L2 txt}
foreach {l t r b} [$w bbox L2] break
set y [= {$y + $b - $t}]
$w create text $x $y -text "by" -font {Times 24} -tag by
foreach {l t r b} [$w bbox by] break
set y [= {$y + $b - $t}]
$w create text $x $y -text "Keith Vetter" -font {Times 24}
set y [= {$y + $b - $t}]
$w create text $x $y -text "Version $::S(version) $::S(date)" \
-font {Times 12}
font delete myfont
}
##+##########################################################################
#
# About - simple about dialog
#
proc About {} {
catch {destroy .about}
toplevel .about
wm title .about "About Fractal Mountains"
button .about.dismiss -text "Dismiss" -command {destroy .about}
canvas .about.c -bd 2 -relief raised -width 600 -height 450
pack .about.dismiss -side bottom -pady 10
pack .about.c -side top -fill both -expand 1
Splash .about.c
}
##+##########################################################################
#
# Help -- a simple help screen
#
proc Help {} {
catch {destroy .help}
toplevel .help
wm title .help "Fractal Mountains Help"
wm geom .help "+[expr {[winfo x .] + [winfo width .] + 10}]+[winfo y .]"
text .help.t -relief raised -wrap word -width 70 -height 23 \
-padx 10 -pady 10 -cursor {} -yscrollcommand {.help.sb set}
scrollbar .help.sb -orient vertical -command {.help.t yview}
button .help.dismiss -text Dismiss -command {destroy .help}
pack .help.dismiss -side bottom -pady 10
pack .help.sb -side right -fill y
pack .help.t -side top -expand 1 -fill both
set bold "[font actual [.help.t cget -font]] -weight bold"
set italic "[font actual [.help.t cget -font]] -slant italic"
.help.t tag config title -justify center -foregr red -font "Times 20 bold"
.help.t tag configure title2 -justify center -font "Times 12 bold"
.help.t tag configure bullet -font $bold
.help.t tag configure ital -font $bold -lmargin1 15
.help.t tag configure bn -lmargin1 15 -lmargin2 15
.help.t tag configure bn2 -lmargin1 15 -lmargin2 40
.help.t insert end "Fractal Mountains\n" title
.help.t insert end "by Keith Vetter\n\n" title2
set m "Fractal Mountains displays a landscape generated using fractals. "
append m "It is based on code and article by Ben Haller at "
append m "http://www.mactech.com/articles/mactech/ "
append m "Vol.07/07.05/FractalMountains/.\n\n"
.help.t insert end $m
.help.t insert end "Display Parameters\n" bullet
.help.t insert end "Iterations" ital
.help.t insert end "how detailed the mountain will be.\n" bn2
.help.t insert end "Contour" ital
.help.t insert end "controls relative steepness at different " bn2
.help.t insert end "heights, with higher numbers giving steep peaks " bn2
.help.t insert end "and flatter lowlands.\n" bn2
.help.t insert end "Smoothness" ital
.help.t insert end "controls how jagged the sides of the mountains " bn2
.help.t insert end "will be.\n"
.help.t insert end "Height" ital
.help.t insert end "controls the overall height of the mountain.\n" bn2
.help.t insert end "Profile" ital
.help.t insert end "selects from a number of initial shapes.\n" bn2
.help.t insert end "Tilt" ital
.help.t insert end "selects the viewing angle.\n" bn2
.help.t insert end "Water Level" ital
.help.t insert end "selects altitude for the water as a percantage " bn2
.help.t insert end "of maximun height or depth.\n\n" bn2
set m "Fractal Mountains starts with two side-by-side equilateral "
append m "triangles in the shape of a parallelogram and assigns an "
append m "altitude to each vertex. Next, each triangle is subdivided "
append m "into four similar smaller triangles by adding vertices at the "
append m "midpoint of each side. These new vertices are given an altitude "
append m "which is the average of the two vertices at the end of that side "
append m "with a random deviation added in. Thus, each iteration "
append m "quadruples the number of triangles, thereby increasing the "
append m "details of the mountain.\n\n"
.help.t insert end "Generating a Fractal Mountain\n" bullet $m bn
set m "Redraw lets you see the affects of changing different parameters on "
append m "the same shaped mountain. For example, you could change the "
append m "height parameter, hit Redraw Mountain, and see the same mountain "
append m "at different heights. For all parameters except iterations, "
append m "this can be done by using the same sequence of random numbers. "
append m "For iterations we must do something different. If we decrease "
append m "iterations, we sub-sample the existing data. If we increase it, "
append m "we transfer existing data into the new template and call our "
append m "fractal engine to fill in the missing slots.\n\n"
append m "The ability to redraw at an increased depth is very useful in "
append m "generating pretty mountains at high detail. You can't tell if "
append m "a random scene is a good one until you've drawn it, but at "
append m "level 7 and above this takes a long time. The solution is to "
append m "draw the scene at a lower level, say 5 or 6, then if you like "
append m "the basic shape, increase the iteration level and redraw it.\n\n"
.help.t insert end "Redraw Mountain Button\n" bullet $m bn
.help.t config -state disabled
}
##+##########################################################################
#
# myOptMenu - creates a label and optionMenu combination
#
proc myOptMenu {f lbl var args} {
frame $f -bd 2 -relief raised
label $f.lbl -text " $lbl" -bd 0 -anchor w
eval tk_optionMenu $f.opt $var $args
$f.opt config -bd 0 -highlightthickness 0
pack $f.lbl -side left -fill x -expand 1
pack $f.opt -side right
return $f
}
##+##########################################################################
#
# ShowTriangles -- makes all triangles visible
#
proc ShowTriangles {} {
global S
.c itemconfig triag -outline $S(triag)
}
##+##########################################################################
#
# ClearColoring -- removes fill from all the triangles
#
proc ClearColoring {} {
global S
set S(triag) black
.c itemconfig triag -fill {} -outline black
.fill config -state disabled
}
##+##########################################################################
#
# ProgressBar -- draws colored progress bar the right length in .msg
#
proc ProgressBar {num max} {
global state
set w .msg
$w delete progress
if {$max == 0} return
set width [winfo width $w]
set height [winfo height $w]
set x [= {$num * $width / double($max)}]
$w create rect 0 0 $x $height -tag progress -fill cyan -outline cyan
$w lower progress
}
##+##########################################################################
#
# ToggleButtons -- enables/disables command buttons
#
proc ToggleButtons {onoff} {
set offon [= {! $onoff}]
array set state {0 disabled 1 normal}
.go config -state $state($offon)
.m.file entryconfig 0 -state $state($offon)
.redraw config -state $state($offon)
.m.file entryconfig 1 -state $state($offon)
.stop config -state $state($onoff)
.m.file entryconfig 2 -state $state($onoff)
if {$onoff} {
.fill config -state normal
}
}
proc INFO {txt} {
.msg itemconfig txt -text $txt
update
}
proc clear {} {
.c delete all
ProgressBar 1 0
}
##+##########################################################################
#
# comma -- adds commas to a number
#
proc comma {n} {
while {[regsub {^([-+]?\d+)(\d{3})} $n {\1,\2} n]} {}
return $n
}
##+##########################################################################
#
# Duration - Prints out seconds in a nice format
#
proc Duration { int_time } {
if {$int_time == 0} {return "0 secs"}
set timeList [list]
foreach div {86400 3600 60 1} mod {0 24 60 60} name {day hr min sec} {
set n [expr {$int_time / $div}]
if {$mod > 0} {set n [expr {$n % $mod}]}
if {$n > 1} {
lappend timeList "$n ${name}s"
} elseif {$n == 1} {
lappend timeList "$n $name"
}
}
return [join $timeList]
}
DoDisplay
Splash
