# 3d turtle graphics

3d turtle graphics is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Create a 3d representation of a house and bar chart, similar to that of Simple turtle graphics, but

• (you can) use a cube for the house and an equilateral square pyramid for the roof, and
• (likewise if it helps) use columns with a square cross section for the bar chart.

## J

Assumes jqt and a "recent" (2022) version of J.

```NB. pre-requisites:
NB. ;install each cut 'gl2 gles github:zerowords/tgsjo'
stop''
clearscreen ''
createTurtle 0 0 0

EYE_tgsjo_=: 0 0 _90
rotR 180+94 10 0

column=: {{
4 repeats {{'height width'=. y
2 repeats {{'height width'=. y
forward width
pitch 90
forward height
pitch 90
}} y
forward width
right 90
}} y
}}

cube=: {{ column y,y }}

codihedral=: 180p_1*_3 o.%%:2
pyramid=: {{
4 repeats {{
roll codihedral
pitch triangle y
roll-codihedral
forward y
left 90
}} y
}}

NB. in 3d, we want to know which turning mechanism to use, when drawing a plane figure
triangle=: {{
3 repeats (u {{
forward y
u 120
}}) y
}}

house=: {{
cube y
roll 180
pyramid y
}}

barchart=: {{'lst size'=. y
if.#lst do.
scale=. size%>./lst
width=. size%#lst
for_j. lst do.
column (j * scale),width
forward width
end.
back size
end.
}}

penColor Red
house 150
pen 0
back 30
right 180
pen 1
penColor Blue
barchart 0.5 0.3333 2 1.3 0.5; 200
pen 0
left 180
forward 30
roll 180
```

## Phix

Fairly straightforward extension of Simple_turtle_graphics.exw, apart from the time spent staring at my own hand figuring out the sequences of angles.
Reuses turtle.e, however the code I really wanted to squirrel away has ended up in turtle_projection.e. You can run this online here.

```--
-- demo\rosetta\3D_turtle_graphics.exw
-- ===================================
--
--  Fairly straightforward extension of Simple_turtle_graphics.exw, apart from
--  the time spent staring at my own hand figuring out the sequences of angles.
--
--  The turtle itself always draws in normal space, ie with the y axis vertical,
--  the x axis horizontal, and the z axis effectively a point, with any and all
--  3D effects generated by projection onto a camera plane, which can be moved
--  about with the usual four arrow and +/- keys. Note the camera handling was
--  cribbed from demo/pGUI/rubik.e, less than perfect here but will have to do.
--
--  Invoking turn() (aka yaw) does pretty much what you would expect, whereas
--  roll() rotates about the direction of travel. To simulate pitch() (aka to
--  climb or nosedive) perform a roll(90), turn(pitch) sequence, avoiding any
--  temptation to "level off" before moving, as that just complicates angles.
--
with javascript_semantics
include turtle.e -- (common code for 2D and 3D versions)
include turtle_projection.e -- (final 3D projection stuff)

atom px = 0, py = 0, pz = 0,    -- position
hx = 1, hy = 0, hz = 0,    -- heading
nx = 0, ny = 0, nz = 1     -- normal

procedure walk3D(atom d)
//
// Move forward by distance d pixels.
//
// Aside: not entirely sure why rounding to 4dp (and normalising
//  to 8dp) helps, but without it errors seem to build quickly..
//  Of course in my opinion regularly teleporting the turtle back
//  to {0,0,0} would just be cheating whereas this makes it exact
//
sequence p1 = {px,py,pz}
px = round(px+d*hx,10000)
py = round(py+d*hy,10000)
pz = round(pz+d*hz,10000)
if pen_down then
-- (not entirely sure why it's "{y,x} =" either, but it is.)
atom {{y1,x1},{y2,x2}} = rotate_and_project({p1,{px,py,pz}})
cdCanvasLine(cdcanvas,x1,y1,x2,y2)
end if
end procedure

function left_unit_vector()
return {ny*hz-nz*hy,nz*hx-nx*hz,nx*hy-ny*hx}
end function

function normalize(sequence v)
v = sq_round(sq_mul(v,1/sqrt(sum(sq_power(v,2)))),100000000)
return v
end function

enum ROLL,TURN

procedure rot3D(atom angle, integer tp)
atom cos_a = cos(angle),
sin_a = sin(angle),
{ux,uy,uz} = left_unit_vector()
if tp=ROLL then
{nx,ny,nz} = normalize({nx*cos_a-ux*sin_a,
ny*cos_a-uy*sin_a,
nz*cos_a-uz*sin_a})

else -- tp=TURN
-- aka rotation about the normal
{hx,hy,hz} = normalize({hx*cos_a+ux*sin_a,
hy*cos_a+uy*sin_a,
hz*cos_a+uz*sin_a})
end if
end procedure

procedure rtm3D(sequence s)
-- s is a list of {roll,turn,dist}, any of which can be 0.
for i=1 to length(s) do
atom {roll,turn,dist} = s[i]
if roll then rot3D(roll,ROLL) end if
if turn then rot3D(turn,TURN) end if
if dist then walk3D(dist) end if
end for
end procedure

procedure rectangle(atom width, height, depth=width)
rtm3D({{ 0, 0,height},{  0,90,width},{0,90,height},{0,90,width},
{90,-90,depth},{-90,90,height},{0,90,depth},{0,90,height},{0,90,depth},
{90,-90,width},{-90,90,height},{0,90,width},{0,90,height},{0,90,width},
{90,-90,depth},{-90,90,height},{0,90,depth},{0,90,height},{0,90,depth},
{-90,90,width},{ 90,90,0}})
end procedure

procedure draw_house(atom width, height)
//
// Draw a house at the current position
// heading must be {1,0,0} for house to be upright
//
// house walls
pendown()
rectangle(width, height)

// door
penup()
rtm3D({{0,90,width/7},{0,-90,0}})
pendown(CD_GREEN)
rectangle(width/8,height/2.5,0)
penup()
rtm3D({{0,-90,width/7},{0,90,0}})

// roof
walk3D(height)
pendown(CD_ORANGE)
rtm3D({{-45,45,width},{0,90,width}})
penup()
rtm3D({{0,-45,0},{90,-135,width},{0,45,0}})
pendown(CD_ORANGE)
rtm3D({{90,135,width},{0,90,width}})

penup()
rtm3D({{0,-45,0},{90,135,width},{90,90,-height}})

end procedure

procedure draw_barchart(sequence nums, atom w, h)
// draw a barchart occupying the middle 60% of w,h
// nums can contain +ve and/or -ve values.
integer n = length(nums)
atom mx = max(max(nums),0),
mn = min(min(nums),0),
r = mx-mn,                 -- range
zl = abs(mn)/r*h*0.6+h/5,  -- zero line
bw = w*0.6/n               -- bar width
rtm3D({{0,90,w/5},{0,-90,zl}})
pendown()
for i=1 to n do
atom ni = nums[i]/r*h*0.6
pendown(iff(ni<0?CD_ORANGE:CD_NAVY))
rectangle(bw,ni)
rtm3D({{0,90,bw},{0,-90,0}})
end for
penup()
rtm3D({{0,180,zl},{0,90,w/5+bw*n},{0,90,0}})
end procedure

function redraw_cb(Ihandle /*ih*/)
integer {width, height} = IupGetIntInt(canvas, "DRAWSIZE")
atom hw = width/2, qw = width/4, qh = height/4
cdCanvasActivate(cdcanvas)
cdCanvasClear(cdcanvas)
rtm3D({{0,0,qh},{0,90,qw},{0,-90,0}})

draw_house(qw,qh)               -- house in the left half

rtm3D({{0,90,hw},{0,-90,0}})    -- barchart in the right half

draw_barchart({0.5, -4/3, 2, 1.3, 0.5},width/2,height)

-- sanity checks (but I got a 0.0002 under pwa/p2js when dev tools open...)
if platform()!=JS then
assert({px,py,pz}={0,0,0})
assert({hx,hy,hz}={1,0,0})
assert({nx,ny,nz}={0,0,1})
end if

cdCanvasFlush(cdcanvas)
return IUP_DEFAULT
end function

function key_cb(Ihandle ih, atom c)
if c=K_ESC then return IUP_CLOSE end if
integer axis = find(c,{K_RIGHT,K_DOWN,'+',K_LEFT,K_UP,'-'})
if axis then
integer angle = 1
if axis>3 then
angle = 359
axis -= 3
end if
if length(view_rotations)
and view_rotations[\$][1] = axis then
view_rotations[\$][2] = mod(view_rotations[\$][2]+angle,360)
else
view_rotations = append(view_rotations,{axis,angle})
end if
IupRedraw(canvas)
elsif c='0' then
view_rotations = {}
IupRedraw(canvas)
end if
return IUP_CONTINUE
end function

IupOpen()
canvas = IupCanvas(Icallback("redraw_cb"),"RASTERSIZE=600x400")
dlg = IupDialog(canvas,`TITLE="3D turtle graphics"`)
IupMap(dlg)
cdcanvas = cdCreateCanvas(CD_IUP, canvas)
IupShow(dlg)
IupSetAttribute(canvas, "RASTERSIZE", NULL) -- release minimum limit
IupSetCallback(dlg, "KEY_CB",  Icallback("key_cb"))
IupSetAttributeHandle(NULL, "PARENTDIALOG", dlg)
if platform()!=JS then
IupMainLoop()
IupClose()
end if
```

## Wren

Library: DOME
Library: Wren-turtle
```import "dome" for Window
import "graphics" for Canvas, Color
import "math" for Math
import "./turtle" for Turtle

class Main {
construct new(width, height) {
Window.resize(width, height)
Canvas.resize(width, height)
Window.title = "3d turtle graphics"
_w = width
_h = height
}

init() {
Canvas.cls(Color.white)
_t = Turtle.new()
drawHouse3D(_w/4)
barChart([15, 10, 50, 35, 20], _w/3)
}

drawRectCuboid(x, y, hsize, vsize) {
// draw front rectangle
_t.drawRect(x, y, hsize, vsize)

// draw back rectangle
_t.drawRect(x + hsize/2, y - hsize/2, hsize, vsize)

var side = ((2 * hsize * hsize).sqrt/2).floor

// turn right 45 degrees
_t.right(45)

// goto bottom left front
_t.goto(x, y + vsize)
_t.walk(side)

// goto top left front
_t.goto(x, y)
_t.walk(side)

// goto bottom right front
_t.goto(x + hsize, y + vsize)
_t.walk(side)

// goto top right front
_t.goto(x + hsize, y)
_t.walk(side)
}

drawHouse3D(size) {
// save initial turtle position and direction
var saveX = _t.x
var saveY = _t.y
var saveD = _t.dir

_t.pen.width = 2

// draw house
drawRectCuboid(_w/8, _h/2, size, size)

// draw roof
_t.left(10)
_t.goto(_w/8, _h/2)
_t.walk(size)

_t.dir = 63
_t.walk((size*15/16).floor)
_t.back((size*15/16).floor)

_t.left(44)
_t.walk((size*31/32).floor)
_t.back((size*31/32).floor)
_t.dir = 102
_t.walk((size/3).floor)

// draw door
var doorWidth  = (size/4).floor
var doorHeight = (size/2.5).floor
_t.drawRect(_w/4 + doorWidth/2, _h/2 + (size/2).floor - doorHeight, doorWidth, doorHeight)

// draw window
var windWidth  = (size/3).floor
var windHeight = (size/4).floor
_t.drawRect(_w/4 + size/1.8, _h/2 + (size/2.8).floor - windHeight, windWidth, windHeight)

// restore initial turtle position and direction
_t.x = saveX
_t.y = saveY
_t.dir = saveD
}

// nums assumed to be all non-negative
barChart(nums, size) {
_t.pen.color = Color.brown

// save intial turtle position and direction
var saveX = _t.x
var saveY = _t.y
var saveD = _t.dir

// find maximum
var max = 0
for (n in nums) if (n > max) max = n

// scale to fit within a square with sides 'size' and draw chart
var barWidth = (size / nums.count).floor
var startX = _w / 2 + 20
var startY = _h / 2
for (i in 0...nums.count) { // nums.count) {
var barHeight = (nums[i] * size / max).round
drawRectCuboid(startX, startY - barHeight, barWidth, barHeight)
startX = startX + barWidth
}

// restore intial turtle position and direction
_t.x = saveX
_t.y = saveY
_t.dir = saveD
}

update() {}

draw(alpha) {}
}

var Game = Main.new(800, 800)
```