Library Graphics Release v2.2a -A library of classes and functions relating to graphical things.

1aTabOrder

Library Graphics Tab Order
------------------------------
This file should not be included in the Codea project.
#ChangeLog
#Main
#Bezier
#Explosion
#Path
#TextNode
#View
#Fireworks
#DataSeries
#Frame
#TrendGraph
#Zoom

Bezier.lua

--[==[
-- Bezier path drawing

Bezier = class()

local __makeBezier = function(nsteps)
    -- nsteps doesn't make a huge difference in the range 50,300
    nsteps = nsteps or 150
    local m = mesh()
    m.shader = shader([[
//
// A basic vertex shader
//

//This is the current model * view * projection matrix
// Codea sets it automatically
uniform mat4 modelViewProjection;

//This is the current mesh vertex position, color and tex coord
// Set automatically
attribute vec4 position;
attribute vec4 color;
attribute vec2 texCoord;

//This is an output variable that will be passed to the fragment shader
varying highp vec2 vTexCoord;
varying highp float vWidth;
uniform float len;
uniform float width;
uniform float taper;
uniform float blur;
float swidth = width + blur;
float ewidth = taper*width - width;
uniform vec2 pts[4];

void main()
{
    highp float t = position.y/len;
    highp float w = smoothstep(0.,1.,t);
    vWidth = w*ewidth + swidth;
    highp float tt = 1.0 - t;
    highp vec2 bpos = tt*tt*tt*pts[0] + 3.0*tt*tt*t*pts[1] 
    + 3.0*tt*t*t*pts[2] + t*t*t*pts[3];
    highp vec2 bdir = tt*tt*(pts[1]-pts[0])
         + 2.0*tt*t*(pts[2]-pts[1]) + t*t*(pts[3]-pts[2]);
    bdir = vec2(bdir.y,-bdir.x);
    bdir = vWidth*position.x*normalize(bdir);
    bpos = bpos + bdir;
    highp vec4 bzpos = vec4(bpos.x,bpos.y,0,1);
    //Pass the mesh color to the fragment shader
    vTexCoord = vec2(texCoord.x, 1.0 - texCoord.y);
    //Multiply the vertex position by our combined transform
    gl_Position = modelViewProjection * bzpos;
}
]],[[
//
// A basic fragment shader
//

//This represents the current texture on the mesh
uniform lowp sampler2D texture;
//uniform highp float width;
uniform highp float blur;

uniform lowp vec4 colour;

//The interpolated texture coordinate for this fragment
varying highp vec2 vTexCoord;
varying highp float vWidth;

void main()
{
    //Sample the texture at the interpolated coordinate
    lowp vec4 col = colour;
    highp float edge = blur/(vWidth+blur);
    col.a = mix( 0., col.a,
    smoothstep( 0., edge, min(vTexCoord.x,1. - vTexCoord.x) ) );
    gl_FragColor = col;
}
]])

    for n=1,nsteps do
        m:addRect(0,(n-.5),1,1)
    end
    m.shader.len = nsteps
    return m
end

local m = __makeBezier()
m.shader.blur = 2

function bezier(a,b,c,d,e)
    if type(a) == "table" then
        e = b
        a,b,c,d = unpack(a)
    end
    if type(c) ~= "userdata" then
        e = e or c
        d = b
        b = 2*a/3 + d/3
        c = a/3 + 2*d/3
    elseif type(d) ~= "userdata" then
        e = e or d
        d = c
        b = 2*b/3
        c = b + d/3
        b = b + a/3
    end
    m.shader.taper = e or 1
    m.shader.width = strokeWidth()
    m.shader.colour = color(stroke())
    m.shader.pts = {a,b,c,d}
    m:draw()
end

function Bezier:init(...)
    self:setPoints(...)
end

function Bezier:clone()
    return Bezier(self.points)
end

function Bezier:makeDrawable(t)
    t = t or {}
    local m = __makeBezier(t.steps)
    m.shader.taper = t.taper or 1
    m.shader.blur = t.blur or 2
    m.shader.width = t.width or strokeWidth()
    m.shader.colour = t.colour or color(stroke())
    m.shader.pts = self.points
    self.curve = m
    self.draw = function(self) self.curve:draw() end
end

function Bezier:draw(t)
    self:makeDrawable(t)
    self.curve:draw()
end

function Bezier:setPoints(a,b,c,d)
    if type(a) == "table" then
        a,b,c,d = unpack(a)
    end
    if not c then
        d = b
        b = 2*a/3 + d/3
        c = a/3 + 2*d/3
    elseif not d then
        d = c
        b = 2*b/3
        c = b + d/3
        b = b + a/3
    elseif type(b) == "number" then
        a,b,c,d = __hobby(a,b,c,d)
    end
    self.points = {a,b,c,d}
    if self.curve then
        self.curve.shader.pts = self.points
    end
end

function Bezier:setStyle(t)
    if not self.curve then 
        self:makeDrawable(t)
        return
    end
    t = t or {}
    if t.colour then
        self.curve.shader.colour = t.colour
    end
    if t.width then
        self.curve.shader.width = t.width
    end
    if t.taper then
        self.curve.shader.taper = t.taper
    end
    if t.blur then
        self.curve.shader.blur = t.blur
    end
end

function Bezier:point(t)
    local s = 1 - t
    return s^3 * self.points[1]
        + 3*s*s*t * self.points[2]
        + 3*s*t*t * self.points[3]
        + t^3 * self.points[4]
end

function Bezier:tangent(t)
    local s = 1 - t
    return 3*s^2 * (self.points[2] - self.points[1])
        + 6*s*t * (self.points[3] - self.points[2])
        + 3*t^2 * (self.points[4] - self.points[3])
end

function Bezier:normal(t)
    return self:tangent(t):rotate90()
end

function Bezier:unitNormal(t)
    local pt = self:normal(t)
    local l = pt:len()
    if l == 0 then
        return vec2(0,0)
    else
        return pt/l
    end
end

function Bezier:unitTangent(t)
    local pt = self:tangent(t)
    local l = pt:len()
    if l == 0 then
        return vec2(0,0)
    else
        return pt/l
    end
end

local ha = math.sqrt(2)
local hb = 1/16
local hc = (3 - math.sqrt(5))/2
local hd = 1 - hc
function __hobby(a,tha,phb,b)
    local c = b - a
    local sth = math.sin(tha)
    local cth = math.cos(tha)
    local sph = math.sin(phb)
    local cph = math.cos(phb)
    local alpha = ha * (sth - hb * sph) * (sph - hb * sth) * (cth - cph)
    local rho = (2 + alpha)/(1 + hd * cth + hc * cph)
    local sigma = (2 - alpha)/(1 + hd * cph + hc * cth)
    return a,a + rho*c:rotate(tha)/3, b - sigma*c:rotate(-phb)/3,b
end

function QuickHobby(a,b,c,tha)
    if type(a) == "table" then
        tha = b
        a,b,c = unpack(a)
    end
    local da = a:dist(b)
    local db = b:dist(c)
    local wa = vec2(1,0):angleBetween(b-a)
    local wb = vec2(1,0):angleBetween(c-b)
    local psi = wb - wa
    if psi > math.pi then
        psi = psi - 2*math.pi
    end
    if psi <= -math.pi then
        psi = psi + 2*math.pi
    end
    local thb,phb,phc
    if tha then
        thb = -(2*psi + tha) * db / (2*db + da)
        phb = - psi - thb
        phc = thb
    else
        thb = - psi * db / (da + db)
        tha = - psi - thb
        phb = tha
        phc = thb
    end
    return Bezier(__hobby(a,tha,phb,b)),Bezier(__hobby(b,thb,phc,c)),thb
end

function QHobbyGenerator(a,b)
    local th
    return function(c)
        local p,q
        p,q,th = QuickHobby(a,b,c,th)
        a = b
        b = c
        return p,q
    end
end

function QHobby(pts,th)
    local n = #pts
    if n == 1 then
        return {}
    end
    if n == 2 then
        th = th or 0
        return {Bezier(pts[1], th, -th, pts[2] )},th
    end
    local a,b = pts[1],pts[2]
    local p,q
    local cvs = {}
    for k=3,n do
        p,q,th = QuickHobby(pts[k-2],pts[k-1],pts[k],th)
        table.insert(cvs,p)
    end
    table.insert(cvs,q)
    return cvs,th
end

function Hobby(pts,extra)
    local z = {}
    local d = {}
    local omega = {}
    local psi = {}
    local it = {}
    local ot = {}
    local n = -1
    local A = {}
    local B = {}
    local C = {}
    local D = {}
    local icurl = 1
    local ocurl = 1
    local theta = {}
    local phi = {}
    local rho ={}
    local sigma = {}
    local a = math.sqrt(2)
    local b = 1/16
    local c = (3 - math.sqrt(5))/2
    local cpta = {}
    local cptb = {}
    local dten = 1
    local curves = {}
    if extra then
        dten = extra.tension or 1
        icurl = extra.inCurl or 1
        ocurl = extra.outCurl or 1
    end

    for _,t in ipairs(pts) do
        n = n + 1
        if type(t) == "table" then
            z[n] = t[1]
            it[n] = t[2] or dten
            ot[n] = t[3] or dten
        else
            z[n] = t
            it[n] = dten
            ot[n] = dten
        end
    end
    if n < 1 then
        return {}
    end
    if n == 1 then
        local th,ph
        if extra then
            th = extra.inAngle
            ph = extra.outAngle
        end
        if not th and ph then
            th = -ph
        elseif not ph and th then
            ph = - th
        elseif not th and not ph then
            ph,th = 0,0
        end
        return {Bezier(__hobby(z[0],th,ph,z[1]))}
    end
    local ang
    for k=0,n-1 do
        d[k] = z[k]:dist(z[k+1])
        omega[k] = vec2(1,0):angleBetween(z[k+1]-z[k])
        if k > 0 then
          ang = omega[k] - omega[k-1]
           if ang > math.pi then
             ang = ang - 2*math.pi
            end
            if ang < -math.pi then
                ang = ang + 2*math.pi
             end
          psi[k] = ang
       end
    end

    if extra then
        theta[0] = extra.inAngle
        phi[n] = extra.outAngle
    end

   for k=1,n-1 do
      A[k] = d[k] * it[k+1] * it[k]^2
   end

   if theta[0] then
      B[0] = 1
   else
      B[0] = ot[0]^3 * (3 * it[1] - 1) + icurl * it[1]^3
   end
   for k = 1,n-2 do
      B[k] = d[k] * it[k+1] * it[k]^2 * (3 * ot[k-1] - 1) + d[k-1] * ot[k-1] * ot[k]^2 * (3 * it[k+1] - 1)
   end
   B[n-1] = d[n-1] * it[n] * it[n-1]^2 * (3 * ot[n-2] - 1) + d[n-2] * ot[n-2] * ot[n-1]^2 * (3 * it[n] - 1)
   if not phi[n] then
      B[n-1] = B[n-1] - d[n-2] * ot[n-2] * ot[n-1]^2 * (it[n]^3 + ocurl * ot[n-1]^3 * (3 * it[n] - 1)) / (it[n]^3 * (3 * ot[n-1] - 1) + ocurl * ot[n-1]^3)
   end

   if theta[0] then
      C[0] = 0
   else
      C[0] = ot[0]^3 + icurl * it[1]^3 * (3 * ot[0] - 1)
   end
   for i=1,n do
      C[i] = d[i-1] * ot[i-1] * ot[i]^2
   end

   if theta[0] then
      D[0] = theta[0]
   else
      D[0] = - (ot[0]^3 + icurl * it[1]^3 * (3 * ot[0] - 1)) * psi[1]
   end
   for i=1,n-2 do
      D[i] = - d[i] * it[i+1] * it[i]^2 * (3 * ot[i-1] - 1) * psi[i] - d[i-1] * ot[i-1] * ot[i]^2 * psi[i+1]
   end
   D[n-1] = - d[n-1] * it[n] * it[n-1]^2 * (3 * ot[n-2] - 1) * psi[n-1]
   if phi[n] then
      D[n-1] = D[n-1] - d[n-2] * ot[n-2] * ot[n-1]^2 * phi[n]
   end

   for i=1,n-1 do
      B[i] = B[i-1] * B[i] - A[i] * C[i-1]
      C[i] = B[i-1] * C[i]
      D[i] = B[i-1] * D[i] - A[i] * D[i-1]
   end
   theta[n-1] = D[n-1]/B[n-1]
   for i=n-2,1,-1 do
      theta[i] = (D[i] - C[i] * theta[i+1])/B[i]
   end
   for i=1,n-1 do
      phi[i] = -psi[i] - theta[i]
   end
   if not theta[0] then
      theta[0] = (ot[0]^3 + icurl * it[1]^3 * (3 * ot[0] - 1)) / (ot[0]^3 * (3 * it[1] - 1) + icurl * it[1]^3) * phi[1]
   end
   if not phi[n] then
      phi[n] = (it[n]^3 + ocurl * it[n-1]^3 * (3 * it[n] - 1)) / (it[n]^3 * (3 * ot[n-1] - 1) + ocurl * ot[n-1]^3) * theta[n-1]
   end

   local alpha
   for i = 0,n-1 do
      alpha = a * (math.sin(theta[i]) - b * math.sin(phi[i+1])) * (math.sin(phi[i+1]) - b * math.sin(theta[i])) * (math.cos(theta[i]) - math.cos(phi[i+1]))
      rho[i] = (2 + alpha) / (1 + (1 - c) * math.cos(theta[i]) + c * math.cos(phi[i+1]))
      sigma[i+1] = (2 - alpha) / (1 + (1 - c) * math.cos(phi[i+1]) + c * math.cos(theta[i]))
   end

   for i = 0,n-1 do
    table.insert(curves,Bezier(
        z[i],
        z[i] + d[i]*rho[i] * vec2(math.cos(theta[i] + omega[i]), math.sin(theta[i] + omega[i]))/3,
        z[i+1] - d[i] * sigma[i+1] * vec2(math.cos(omega[i] - phi[i+1]), math.sin(omega[i] - phi[i+1]))/3,
        z[i+1]
        ))
   end
    return curves
end

cmodule.gexport {
   QuickHobby = QuickHobby,
   HobbyPoints = HobbyPoints,
    QHobbyGenerator = QHobbyGenerator,
    Hobby = Hobby,
    QHobby = QHobby,
    bezier = bezier
}

return Bezier

--]==]

ChangeLog.lua

--[[
ChangeLog
=========

v2.2a Added and developed Bezier class and bezier shader.

v2.1 Updated to latest version of cmodule.  Cleaned up Main

v2.0 Split into separate projects: "Library Graphics" is a suite of
     mainly graphical functions.

v1.0 Converted to use toadkick's cmodule for importing 
     and Briarfox's AutoGist for versionning.
     It needs toadkick's code from 
        https://gist.github.com/apendley/5411561
     tested with version 0.0.8
     To use without AutoGist, comment out the lines in setup.

--]]

DataSeries.lua

--[==[
-- Data Series

DataSeries = class()

local Colour = unpack(cimport "Colour",nil)

function DataSeries:init(name, length, min, max, symbol, symbolsize, thick, clr, value)
    self.name = name
    self.symbol = symbol
    self.symbolsize = symbolsize
    self.nextpt = 0
    self.length = length
    self.lineclr = clr
    self.linethick = thick
    self.points = {}
    self.min = min
    self.max = max
    if self.min < 0 and self.max > 0 then
        self.axis = true
        self.acolour = Colour.shade(self.lineclr,50)
    end
    self.value = value
end

function DataSeries:addValue(y)
    self.nextpt = self.nextpt + 1
    if self.nextpt > self.length then
        self.nextpt = 1
    end
    self.points[self.nextpt] = vec2(i, y)
end

function DataSeries:update()
    if self.value then
        self:addValue(self.value())
    end
end

function DataSeries:addBreak()
    self.nextpt = self.nextpt + 1
    if self.nextpt > self.length then
        self.nextpt = 1
    end
    self.points[self.nextpt] = nil
end

function DataSeries:draw(frame)
    pushStyle()
    local ox, oy, w, h, x, y, p, dx, dy
    
    strokeWidth(self.linethick)
    w = frame.x2 - frame.x1
    h = frame.y2 - frame.y1
    dx = w / (self.length + 1)
    dy = h / (self.max - self.min)
    pushMatrix()
    translate(frame.x1, frame.y1)
    clip(frame.x1, frame.y1, w, h)
    if self.axis then 
        stroke(self.acolour)
        line(0,-self.min*dy,w,-self.min*dy)
    end
    ox = 0
    x = 0
    stroke(self.lineclr)
    for i = self.nextpt + 1, self.length do
        x = x + dx
        p = self.points[i]
        if p ~= nil then
            y = (p.y - self.min) * dy
            if ox > 0 then
                line(ox,oy,x,y)
            end
            ox = x
            oy = y
            if self.symbol == 1 then
                noFill()
                ellipse(x, y, self.symbolsize)
            end
        else
            ox = 0
        end
    end

    for i = 1, self.nextpt do
        x = x + dx
        p = self.points[i]
        if p ~= nil then
            y = (p.y - self.min) * dy
            if ox > 0 then
                line(ox,oy,x,y)
            end
            ox = x
            oy = y
            if self.symbol == 1 then
                noFill()
                ellipse(x, y, self.symbolsize)
            end
        else
            ox = 0
        end
    end
    popMatrix()
    noClip()
    popStyle()
end

return DataSeries

--]==]

Explosion.lua

--[==[
-- Explosion

local Explosion = class()

function Explosion:init(t)
    t = t or {}
    self.mesh = mesh()
    local s = shader()
    s.vertexProgram, s.fragmentProgram = expshader()
    self.mesh.shader = s
    self.mesh.texture = t.image
    self.mesh.shader.friction = t.friction or .1
    self.mesh.shader.separation = 0
    local ft = t.factor or 10
    self.mesh.shader.factor = ft
    local vels = self.mesh:buffer("velocity")
    local origin = self.mesh:buffer("origin")
    local angv = self.mesh:buffer("angvel")
    local lvl = self.mesh:buffer("level")
    local m = t.rows or 20
    local n = t.cols or 20
    vels:resize(m*n*6)
    origin:resize(m*n*6)
    angv:resize(m*n*6)
    lvl:resize(m*n*6)
    local c = t.centre
    local w,h
    if type(t.image) == "string" then
        local img = readImage(t.image)
        w,h = img.width,img.height
    else
        w,h = t.image.width,t.image.height
    end
    local w = t.width or w
    local h = t.height or h
    local om = t.angularSpeed or 1/ft
    local xx,y = c.x - w/2,c.y - h/2
    local cl = vec2(w,h):len()/2
    w,h = w/m,h/n
    xx,y = xx+w/2,y+h/2
    local r,th,sf,x,df,tth
    sf = .3
    df = math.random()
    for i=1,m do
        x = xx
        for j = 1,n do
            r = self.mesh:addRect(x,y,w,h)
            self.mesh:setRectTex(r,(j-1)/n,(i-1)/m,1/n,1/m)
            th = 2*noise(i*sf+df,j*sf+df)*math.pi
            tth = 2*om*noise(j*sf+df,i*sf+df)*math.pi
            for k=1,6 do
                vels[6*r-k+1] = 20*(2-(c:dist(vec2(x,y))/cl))^2
                        *vec4(math.cos(th),math.sin(th),0,0)
                origin[6*r-k+1] = vec2(x,y)
                angv[6*r-k+1] = vec2(tth,0)
                lvl[6*r-k+1] = 0
            end
            x = x + w
        end
        y = y + h
    end
    if t.trails then
        local ntr = t.trailLength or 16
        self.trails = mesh()
        self.trails:setColors(255,255,255,255)
        s = shader()
        s.vertexProgram, s.fragmentProgram = expshader()
        self.trails.shader = s
        self.trails.texture = t.image
        self.trails.shader.friction = t.friction or .1
        self.trails.shader.factor = ft
        self.trails.shader.separation = t.trailSeparation or .5
        vels = self.trails:buffer("velocity")
        origin = self.trails:buffer("origin")
        angv = self.trails:buffer("angvel")
        lvl = self.trails:buffer("level")
        vels:resize(ntr*m*n*6)
        origin:resize(ntr*m*n*6)
        angv:resize(ntr*m*n*6)
        lvl:resize(ntr*m*n*6)
        local yy
        xx,yy = c.x - (m-1)*w/2,c.y - (n-1)*h/2
        for l=1,ntr do
            y = yy
            for i=1,m do
                x = xx
                for j = 1,n do
                    r = self.trails:addRect(x,y,w,h)
                    self.trails:setRectTex(r,(j-1)/n,(i-1)/m,1/n,1/m)
                    self.trails:setRectColor(r,255,255,255,l*127/ntr)
                    th = 2*noise(i*sf+df,j*sf+df)*math.pi
                    tth = 2*om*noise(j*sf+df,i*sf+df)*math.pi
                    for k=1,6 do
                        vels[6*r-k+1] = 20*(2-(c:dist(vec2(x,y))/cl))^2
                                *vec4(math.cos(th),math.sin(th),0,0)
                        origin[6*r-k+1] = vec2(x,y)
                        angv[6*r-k+1] = vec2(tth,0)
                        lvl[6*r-k+1] = l - ntr - 1
                    end
                    x = x + w
                end
                y = y + h
            end
        end
    end
    self.start = ElapsedTime
end

function Explosion:draw()
    if not self.active then
        return
    end
    pushStyle()
    local time = ElapsedTime - self.start
    if not self.paused then
        if self.trails then
            blendMode(SRC_ALPHA,ONE)
            self.trails.shader.time = time
            self.trails:draw()
        end
        self.mesh.shader.time = time
    end
    blendMode(NORMAL)
    self.mesh:draw()
    if not self.paused then
        if self.stop and ElapsedTime > self.start + self.stop then
            self:deactivate()
        end
    end
    popStyle()
end

function Explosion:activate(t,s)
    t = t or 0
    self.start = ElapsedTime + t
    self.stop = s
    self.active = true
    self.paused = false
end

function Explosion:deactivate()
    self.active = false
end

function Explosion:pause()
    if self.paused then
        self.start = ElapsedTime - self.pausetime
        self.paused = false
    else
        self.paused = true
        self.pausetime = ElapsedTime - self.start
    end
end

expshader = function()
    return [[
//
// The explosion vertex shader
//
precision highp float;
//This is the current model * view * projection matrix
// Codea sets it automatically
uniform mat4 modelViewProjection;
uniform float time;
uniform float friction;
uniform float factor;
uniform float separation;

lowp vec4 gravity = vec4(0.,-1.,0.,0.);
mediump float mtime = max(0.,time)*factor;
//This is the current mesh vertex position, color and tex coord
// Set automatically
attribute vec4 position;
attribute vec4 color;
attribute vec2 texCoord;
// These are vertex buffers: initial velocity of the square,
// angular velocity,
// centre of square
attribute vec4 velocity;
attribute vec2 angvel;
attribute vec2 origin;
attribute float level;

//This is an output variable that will be passed to the fragment shader
varying lowp vec4 vColor;
varying highp vec2 vTexCoord;
//varying mediump float vLevel;

// ODE: x'' = -friction x' + gravity
// Solution: A exp(- friction * time) + B + time*gravity/friction
// Initial conditions:
// A = gravity/(friction*friction) - x'(0)/friction
// B = x(0) -A

void main()
{
    //Pass the mesh color to the fragment shader
    vColor = color;
    vTexCoord = texCoord;
    //vLevel = level;
    lowp vec4 pos;
    mediump float t = mtime + level * separation;

    lowp float angle = t*angvel.x;
    highp vec4 A = gravity/(friction*friction) - velocity/friction;
    highp vec4 B = vec4(origin,0.,0.) - A;
    lowp mat2 rot = mat2(cos(angle), sin(angle), -sin(angle), cos(angle));

    pos = (position - vec4(origin,0.,0.));
    pos.xy = rot * pos.xy;
    pos += exp(-t*friction)*A + B + t * gravity/friction;
    if (level != 0. && t < 1.) pos = vec4(0.,0.,0.,1.);
    //Multiply the vertex position by our combined transform
    gl_Position = modelViewProjection * pos;
}
]],[[
//
// A basic fragment shader
//

//This represents the current texture on the mesh
uniform lowp sampler2D texture;

//The interpolated vertex color for this fragment
varying lowp vec4 vColor;

//The interpolated texture coordinate for this fragment
varying highp vec2 vTexCoord;

void main()
{
    //Sample the texture at the interpolated coordinate
    lowp vec4 col = texture2D( texture, vTexCoord );
    col *= vColor;
    //Set the output color to the texture color
    gl_FragColor = col;
}
]]
end

return Explosion

--]==]

Fireworks.lua

--[==[
-- Firework display
-- Authors: Stavrogin (original standalone program)
--          Andrew Stacey (conversion to "celebration" class)
-- Websites: http://pagantongue.posterous.com/fireworks
--           http://www.math.ntnu.no/~stacey/HowDidIDoThat/iPad/Codea.html
-- Licence: unknown

local NUMSTARS = 50
local COLOURS = {
        color(255, 0, 0, 125),
        color(255, 227, 0, 125),
        color(99, 255, 0, 125),
        color(0, 140, 255, 125),
        color(238, 0, 255, 125),
        color(255, 156, 0, 125),
        color(0, 255, 189, 125),
        color(255, 0, 146, 125)
        }

local Stars = 1
local See_Smoke = 1
local Firework_Parts = 100
local Life = 30
local Life_Variation = 100
local Air_Resistance = 0.1
local PartSize = 35
local PartSize_Variation = 50
local Velocity = 10
local Velocity_Variation = 100
local Color_Variation = 50

local Fireworks = class()

function Fireworks:init()
    self.stars = {}
    self.fireworks = {}
    self.smokes = {}
    for i=0,NUMSTARS do
        self.stars[i] = {x=math.random(WIDTH),y=math.random(HEIGHT)}
    end
    self.active = false
end

function Fireworks:draw()
    pushStyle()
    noSmooth()
        fill(0, 0, 0, 125)
        rect(0,0,WIDTH,HEIGHT)
    
    -- draw stars
    if Stars == 1 then
        for i=0, NUMSTARS do
            fill(255, 255, 255, math.random(255))
            rect(self.stars[i].x,
                self.stars[i].y,
                math.random(3),
                math.random(3))
        end
    end
    local dead = true
    if self.ftimes[self.nfw] then
        if ElapsedTime - self.fstart > self.ftimes[self.nfw] then
            self.nfw = self.nfw + 1
            self.fstart = ElapsedTime
            sound(SOUND_EXPLODE)
        end
        dead = false
    end
    local sm,fw
    for k = 1,self.nfw do
        sm = self.smokes[k]
        fw = self.fireworks[k]
        
        if not sm:isDead() then
            dead = false
            sm:draw()
        end
        if not fw:isDead() then
            dead = false
            fw:draw()
        end
    end
    if dead then
        self.active = false
    end
    popStyle()
    return self.nfw
end

function Fireworks:newshow(p)
    self.fireworks = {}
    self.smokes = {}
    self.ftimes = {}
    if not p then
        local n = math.random(4,8)
        p = {}
        for i = 1,n do
            table.insert(p,{
                math.random(50,WIDTH - 50),
                math.random(HEIGHT/2,HEIGHT - 50)
                })
        end
    end
        local m,t
        for k,v in ipairs(p) do
            m = math.random(#COLOURS)
            
            table.insert(self.fireworks,Firework(v[1],v[2],COLOURS[m]))
            if See_Smoke == 1 then
                table.insert(self.smokes,Smoke(v[1],v[2],3))
            end
            t = math.random() + .5
            table.insert(self.ftimes,t)
            self.fstart = ElapsedTime
            self.nfw = 1
        end
        table.remove(self.ftimes)
        self.active = true
        sound(SOUND_EXPLODE)
end

local Firework = class()

function Firework:init(x,y,colour)
    -- you can accept and set parameters here
    self.p = {}
    self.numParticles = Firework_Parts
    for i=1,self.numParticles do
        local psize = genNumber(PartSize,PartSize_Variation)
        
        local v = vec2(math.random(-100,100),math.random(-100,100))
        v = v:normalize()
        v = v * genNumber(Velocity,Velocity_Variation)
        
        local c = color(genNumber(colour.r,Color_Variation),
                        genNumber(colour.g,Color_Variation),
                        genNumber(colour.b,Color_Variation),
                        colour.a
                        )
        
        self.p[i] = Particle(x,
                        y,
                        psize,
                        genNumber(Life,Life_Variation),
                        c,
                        v)
    end
end

function Firework:draw()
    local resistance = 1/(Air_Resistance + 1)
    local g = vec2(Gravity.x,Gravity.y)
    for i=1,self.numParticles do
        local p = self.p[i]
        
        p.x = p.x + p.v.x
        p.y = p.y + p.v.y
        
        p.v = p.v + g
        p.v = p.v * resistance
        
        local size = math.random(PartSize) * (p.lifeLeft/p.life)
        p.width = size
        p.height = size
        p:draw()
    end
end

function Firework:isDead()
    for i=1,self.numParticles do
        p = self.p[i]
        if p.lifeLeft ~= 0 and
            (p.x>0 and p.x<WIDTH and p.y>0 and p.y<HEIGHT)then
            return false
        end
    end
    return true
end

local Particle = class()

local Particle.DEFAULT_OPACITY = 125
local Particle.DEFAULT_ANGLE = 0
local Particle.DEFAULT_MASS = 1

function Particle:init(posx,posy,size,life,colour,
    velocity,mass,angle,sprite)
    -- position
    self.x = posx
    self.y = posy
    self.ox = 0
    self.oy = 0
    
    -- size
    self.width = size
    self.height = size
    
    -- color
    if colour == nil then
        self.color = color(255, 255, 255, 255)
    else
        self.color = colour
    end
    
    -- velocity
    self.v = velocity
    
    -- life
    self.life = life
    self.lifeLeft= life
    
    -- sprite
    self.sprite = sprite
    
    -- mass
    if mass == nil then
        self.mass = DEFAULT_MASS
    else
        self.mass = mass
    end
    
    -- angle
    if angle == nil then
        self.angle = self.DEFAULT_ANGLE
    else
        self.angle = angle
    end
end

function Particle:draw()
    if self.lifeLeft > 0 then
        self.lifeLeft = self.lifeLeft - 1
    end
    
    if self.lifeLeft ~= 0 then
        if self.sprite == nil then
            fill(self.color)
            ellipse(self.x,self.y,self.width,self.height)
        else
            pushMatrix()
            translate(self.x,self.y)
            rotate(self.angle)
            tint(self.color)
            sprite(self.sprite,0,0,self.width,self.height)
            popMatrix()
        end
    end
end

local function genNumber(number,variation)
    ret = variation*0.01*number
    ret = number + math.random(-ret,ret)
    return ret
end

local Smoke = class()

function Smoke:init(x,y,n)
    self.numparts = n
    -- color used to tint the particle
    local c = color(73, 73, 73, 69)
    -- name of the sprite of each smoke particle
    local s = "Tyrian Remastered:Dark Orb"
    
    self.parts = {}
    for i=0,n do
        -- initial size of the smoke particle
        local sz = genNumber(60,100)
        self.parts[i] = Particle(genNumber(x,20),
                            genNumber(y,20),sz,-7,c,nil,-1,genNumber(180,100),s)
    end
    -- rotation speed
    self.rSpeed = 0.5
    self.windX = 1
    self.windY = 1
end

function Smoke:draw()
    for i=1,self.numparts do
        local p = self.parts[i]
        if p.color.a > 0 then
        p.angle = p.angle + self.rSpeed
        p.width = p.width + 3
        p.height = p.height + 3
        p.color.a = p.color.a - 0.2
        p.x = p.x + self.windX
        p.y = p.y + self.windY
        p:draw()
        end
    end
end

function Smoke:isDead()
    for i=1,self.numparts do
        local p = self.parts[i]
        if p.color.a > 0 then
            return false
        end
    end
    return true
end

return Fireworks

--]==]

Frame.lua

--[==[
-- Frame

-- ====================
-- Frame 
-- ver. 0.1
-- a simple rectangle to act as a base for controls
-- ====================

local Frame = class()

function Frame:init(x1, y1, x2, y2)
    self.x1 = x1
    self.x2 = x2
    self.y1 = y1
    self.y2 = y2
end

function Frame:draw()
    pushStyle()
    rectMode(CORNERS)
    rect(self.x1, self.y1, self.x2, self.y2)
    popStyle()
end

function Frame:gloss()
    local i, t, r, y
    pushStyle()
    fill(255, 255, 255, 255)
    rectMode(CORNERS)
    rect(self.x1, self.y1, self.x2, self.y2)
    r = (self.y2 - self.y1) / 2
    for i = 1 , r do
        t = 255 - i 
        stroke(t, t, t, 255)
        y = (self.y1 + self.y2) / 2
        line(self.x1, y + i, self.x2, y + i)
        line(self.x1, y - i, self.x2, y - i)
    end
    popStyle()
end


function Frame:touched(touch)
    if touch.x >= self.x1 and touch.x <= self.x2 then
        if touch.y >= self.y1 and touch.y <= self.y2 then
            return true
        end
    end
    return false
end

function Frame:midx()
    return (self.x1 + self.x2) / 2
end
    
function Frame:midy()
    return (self.y1 + self.y2) / 2
end

return Frame

--]==]

Main.lua

VERSION = "2.2a"
clearProjectData()
-- DEBUG = true
-- Use this function to perform your initial setup
function setup()
    autogist = AutoGist("Library Graphics","A library of classes and functions relating to graphical things.",VERSION)
    autogist:backup(true)

    --displayMode(FULLSCREEN_NO_BUTTONS)
    cmodule "Library Graphics"
    cmodule.path("Library Base", "Library UI", "Library Utilities", "Library Maths")
    cimport "TestSuite"
    local Touches = cimport "Touch"
    local UI = cimport "UI"
    local Debug = cimport "Debug"
    local Colour = unpack(cimport "Colour")
    local Explosion = cimport "Explosion"
    local TextNode = cimport "TextNode"
    local View = cimport "View"
    Bezier = cimport "Bezier"
    touches = Touches()
    ui = UI(touches)

    debug = Debug({ui = ui})
    ui:systemmenu()
    testsuite.initialise({ui = ui})

    debug:log({
        name = "Screen north west",
        message = function() local x,y = RectAnchorOf(Screen,"north west") return x .. ", " .. y end
    })
    --debug:activate()

    tn = TextNode({
        pos = function() return WIDTH/2,800 end,
        anchor = "centre",
        --angle = 30,
        ui = ui,
        fit = true,
        maxHeight = HEIGHT,
    })


    touches:pushHandler(tn)

    view = View(ui,touches)
    parameter.watch("view.baseRotation")

    shape = mesh()
    
    shape.texture = "Documents:Daniel at barnehage"
    local x,y,z = 1,1,1
    shape.vertices = {
        vec3(x,0,0),
        vec3(0,y,0),
        vec3(0,0,z),
        vec3(0,0,0),
        vec3(0,y,0),
        vec3(0,0,z),
        vec3(x,0,0),
        vec3(0,0,0),
        vec3(0,0,z),
        vec3(x,0,0),
        vec3(0,y,0),
        vec3(0,0,0)
    }
    shape.colors = {
        Colour.svg.Red,
        Colour.svg.Green,
        Colour.svg.Blue,
        Colour.svg.White,
        Colour.svg.Green,
        Colour.svg.Blue,
        Colour.svg.Red,
        Colour.svg.White,
        Colour.svg.Blue,
        Colour.svg.Red,
        Colour.svg.Green,
        Colour.svg.White
    }

    view.eye = vec3(5,0,0)
    view.range = .25

    tw = {t = 0,s=0}
    ui:setTimer(5,function() tween(5,tw,{t = 1,s = 0}) return true end)
    ui:setTimer(12,function() tween(5,tw,{t = 1,s = 1}) return true end)
    ui:setTimer(18,function() tw = {t = 0,s = 1} return true end)
    ui:setTimer(19,function() tween(5,tw,{t = 1,s = 0}) return true end)

    explosion = Explosion({
        image = "Cargo Bot:Codea Icon",
        trails = true,
        centre = vec2(WIDTH/2,HEIGHT/2)
    })
    explosion:activate(1,5)
    --ui:addNotice({text = "Watch carefully"})

    strokeWidth(5)
    stroke(255, 0, 0, 255)
    ncurves = {}
    --[[
    local b
    for k=1,300 do
        b = Bezier(vec2(100,100),
                    vec2(100,200),
                    vec2(200,100),
                    vec2(200,200)
                    )
        b:makeDrawable()
        table.insert(ncurves,b)
    end
    --]]
    fps = {}
    for k=1,20 do
        table.insert(fps,1/60)
    end
    afps = 60
    parameter.watch("math.floor(20/afps)")
    --displayMode(FULLSCREEN)
    local width = 10

    pts = {vec2(width/2,0),
        vec2(width/2,3*HEIGHT-width/2),
        vec2(WIDTH - width/2,-2*HEIGHT+width/2),
        vec2(WIDTH - width/2,HEIGHT)}

    --[[
    vcurves = {}
    local n = 200
    for k=1,n do
        table.insert(vcurves,{
            function(t) return vec2(0,HEIGHT*(1+math.sin(t + 2*math.pi*k/n))/2) end,
            function(t) return vec2(WIDTH/3,HEIGHT*(1+math.sin(t + 2*math.pi*(k+1)/n))/2) end,
            function(t) return vec2(2*WIDTH/3,HEIGHT*(1+math.sin(t + 2*math.pi*(k+2)/n))/2) end,
            function(t) return vec2(WIDTH,HEIGHT*(1+math.sin(t + 2*math.pi*(k+3)/n))/2) end
                })
    end
    --]]
    parameter.watch("math.floor(20/afps)")
    curves = {}
    hcurves = {}
    parameter.watch("#curves")
    tpts = {}
    cpts = {}
end

function draw()
    table.remove(fps,1)
    table.insert(fps,DeltaTime)
    afps = 0
    for k,v in ipairs(fps) do
        afps = afps + v
    end
    background(75, 104, 90, 255)
    strokeWidth(5)

    stroke(151, 115, 115, 255)
    for i=1,3 do
        line(pts[i].x,pts[i].y,pts[i+1].x,pts[i+1].y)
    end
    fill(160, 172, 22, 255)
    noStroke()
    for i = 1,4 do
        ellipse(pts[i].x,pts[i].y,20)
    end
    strokeWidth(5)
    stroke(255, 255, 255, 255)
    for k,v in ipairs(ncurves) do
        v:draw()
    end
    bezier(pts)
    stroke(81, 255, 0, 255)
    bezier(vec2(10,10),vec2(WIDTH/2,2*HEIGHT-20),vec2(WIDTH-10,10))
    for k,v in ipairs(curves) do
        v:draw()
    end
    stroke(0, 0, 0, 255)
    strokeWidth(3)
    for k,v in ipairs(hcurves) do
        v:draw()
    end
    noStroke()
    for k,v in ipairs(cpts) do
        ellipse(v.x,v.y,15)
    end
    --[[
    for _,v in ipairs(vcurves) do
        bezier({v[1](ElapsedTime),v[2](ElapsedTime),v[3](ElapsedTime),v[4](ElapsedTime)})
    end
    --]]

end

function touched(touch)
    local tv = vec2(touch.x,touch.y)
    if touch.state == BEGAN then
        mpoint = nil
        for k,v in ipairs(cpts) do
            if v:distSqr(tv) < 900 then
                mpoint = k
            end
        end
        if not mpoint then
        table.insert(tpts,vec2(touch.x,touch.y))
        table.insert(cpts,vec2(touch.x,touch.y))
        if #tpts == 3 then
            local a,b,aa,bb
            a,b,th = QuickHobby(tpts,th)
            aa = a:clone()
            bb = b:clone()
            aa:setStyle({width = 8, colour = color(75, 104, 90, 255)})
            bb:setStyle({width = 8, colour = color(75, 104, 90, 255)})
            table.remove(curves)
            table.remove(curves)
            table.insert(curves,aa)
            table.insert(curves,a)
            table.insert(curves,bb)
            table.insert(curves,b)
            table.remove(tpts,1)
        elseif #tpts == 2 then
            cvs = QHobby(tpts)
            curves = {}
            for _,v in ipairs(cvs) do
                vv = v:clone()
                vv:setStyle({width = 8, colour = color(75, 104, 90, 255)})
                table.insert(curves,vv)
                table.insert(curves,v)
            end
        end
        end
    elseif mpoint then
        cpts[mpoint] = tv
        if mpoint == #cpts then
            tpts[#tpts] = tv
        elseif mpoint == #cpts - 1 then
            tpts[1] = tv
        end
    end
    if touch.state == ENDED then
        --if #cpts > 2 then
            hcurves = Hobby(cpts)
        --end
        if mpoint then
            local cvs,vv
            cvs, th = QHobby(cpts)
            curves = {}
            for _,v in ipairs(cvs) do
                vv = v:clone()
                vv:setStyle({width = 8, colour = color(75, 104, 90, 255)})
                table.insert(curves,vv)
                table.insert(curves,v)
            end
        end
    end
end
--[[
-- This function gets called once every frame
function draw()
    -- process touches and taps
    table.remove(fps,1)
    table.insert(fps,DeltaTime)
    afps = 0
    for k,v in ipairs(fps) do
        afps = afps + v
    end
    touches:draw()
    background(34, 47, 53, 255)
--[=[
    tn:draw()
    pushMatrix()
    view:draw()
    vm = viewMatrix()
    qt = qslp(tw.t)
    qt = qt*qlp(tw.s)
    modelMatrix(qt:tomatrix())
    perspective(40,WIDTH/HEIGHT)
    camera(10,10,10,0,0,0,0,1,0)
    shape:draw()
    popMatrix()
    resetMatrix()
    viewMatrix(matrix())
    ortho()
    --]=]
    strokeWidth(5)
    stroke(255, 0, 0, 255)
    for k,v in ipairs(curves) do
        v:draw()
    end
    explosion:draw()
    ui:draw()
    debug:draw()
    touches:show()
end

function touched(touch)
    touches:addTouch(touch)
end
--]]
function orientationChanged(o)
    if ui then
         ui:orientationChanged(o)
    end
end

function fullscreen()
end

function reset()
end

Path.lua

--[==[
-- Path object

local Path = class()

local PATH_STEP = 1
local PATH_RES = .05*.05
local PATH_RENDER = 0
local PATH_CREATE = 1
local PATH_POINTS = 2

function Path:init(t)
    t = t or {}
    self.style = t.style or {}
    self.lastPoint = vec2(0,0)
    self.elements = t.elements or {}
    if t.touchHandler then
        t.touchHandler:pushHandler(self)
    end
    
    self.touchpt = {}
    self.m = mesh()
end

function Path:deletePoints()
    self.elements = {}
    self.lastPoint = vec2(0,0)
end

function Path:draw()
    pushStyle()
    resetStyle()
    self:applyStyle(PATH_RENDER)
    self.m:draw()
    if self.edit then
        self:applyStyle(PATH_POINTS)
        local r = self.ptRadius
        local lpt
        pushStyle()
        noStroke()
        for k,v in ipairs(self.elements) do
            ellipse(v[2].x,v[2].y,r)
            if v[1] == "curve" then
                popStyle()
                line(lpt.x,lpt.y,v[2].x,v[2].y)
                line(v[3].x,v[3].y,v[4].x,v[4].y)
                pushStyle()
                noStroke()
                ellipse(v[3].x,v[3].y,r)
                ellipse(v[4].x,v[4].y,r)
                lpt = v[4]
            else
                lpt = v[2]
            end
        end
        popStyle()
    end
    popStyle()
end

function Path:generate()
    self:applyStyle(PATH_CREATE)
    local ver = {}
    local s,h
    for k,v in ipairs(self.elements) do
        ver,s,h = self:getPoints(v,ver,s,h)
    end
    if h then
        ver,s = HobbyPoints(ver,s,h)
    end
    self.lastPoint = s
    --debug:log({name = "path", message = "got called"})
    print("got called")
    self:makeMesh(ver)
end

function Path:applyStyle(t)
    local s = self.style or {}
    if t == PATH_CREATE then
        self.linewidth = s.linewidth or 5
        self.blur = s.blur or 1
        self.smooth = s.smooth or false
        self.drawColour = s.drawColour or Colour.svg.Black
    elseif t == PATH_RENDER then
    elseif t == PATH_POINTS then
        self.ptRadius = s.pointRadius or 15
        local l = s.pointLineWidth or 3
        strokeWidth(l)
        local l = s.pointLineCap or SQUARE
        lineCapMode(l)
    end
end

function Path:addElement(e)
    table.insert(self.elements,e)
end

function Path:moveto(v)
    self:addElement({"move",v})
    self.lastPoint = v
end

function Path:lineto(v)
    self:addElement({"line",v})
    self.lastPoint = v
end

function Path:curveto(b,c,d)
    self:addElement({"curve",b,c,d})
    self.lastPoint = d
end

function Path:curvethrough(v)
    self:addElement({"hobby",v})
    self.lastPoint = v
end

function Path:getPoints(e,ver,s,h)
    local t = e[1]
    if h and t ~= "hobby" then
        ver,s = HobbyPoints(ver,s,h)
    end
    if t == "move" then
        table.insert(ver,{e[2]})
        return ver, e[2]
    elseif t == "line" then
        local n = e[2] - s
        n = n:rotate90()
        n = n/n:len()
        table.insert(ver,{s,n})
        table.insert(ver,{e[2],n})
        return ver,e[2]
    elseif e[1] == "curve" then
        return BezierPoints(ver,s,e[2],e[3],e[4])
    elseif e[1] == "hobby" then
        h = h or {}
        table.insert(h,e[2])
        return ver,s,h
    else
        return ver,s
    end
end

function Path:makeMesh(pts)
    local ver = {}
    local col = {}
    local l = self.linewidth/2
    local b = self.blur + l
    local s = false -- self.smooth
    local c = self.drawColour
    local ct = Colour.opacity(c,0)
    local p,n
    local m = 0
    for k,v in ipairs(pts) do
        if v[2] and n then
        table.insert(ver,p + l*n)
        table.insert(ver,p - l*n)
        table.insert(ver,v[1] + l*v[2])
        table.insert(ver,v[1] + l*v[2])
        table.insert(ver,v[1] - l*v[2])
        table.insert(ver,p - l*n)
        for i=1,6 do
            table.insert(col,c)
        end
    m = m + 6
        if s then
        table.insert(ver,p + l*n)
        table.insert(ver,p + b*n)
        table.insert(ver,v[1] + l*v[2])
        table.insert(ver,v[1] + l*v[2])
        table.insert(ver,v[1] + b*v[2])
        table.insert(ver,p + b*n)
        table.insert(ver,p - l*n)
        table.insert(ver,p - b*n)
        table.insert(ver,v[1] - l*v[2])
        table.insert(ver,v[1] - l*v[2])
        table.insert(ver,v[1] - b*v[2])
        table.insert(ver,p - b*n)
        for i=1,12 do
            table.insert(col,ct)
        end
        end
        end
        p,n = unpack(v)
        
    end
    self.m.vertices = ver
    self.m.colors = col
end

function Path:isTouchedBy(touch)
    local p = vec2(touch.x,touch.y)
    for k,v in ipairs(self.elements) do
        if p:distSqr(v[2]) < 625 then
            self.touchpt[touch.id] = v[2]
            self.edit = true
            return true
        end
        if v[1] == "curve" then
            if p:distSqr(v[3]) < 625 then
                self.touchpt[touch.id] = v[3]
                self.edit = true
                return true
            end
            if p:distSqr(v[4]) < 625 then
                self.touchpt[touch.id] = v[4]
                self.edit = true
                return true
            end
        end
    end
    self.edit = false
    return false
end

function Path:processTouches(g)
    local regenerate = false
    if g.updated then
        for k,t in ipairs(g.touchesArr) do
            if t.updated then
                regenerate = true
                self.touchpt[t.touch.id].x = 
                    self.touchpt[t.touch.id].x
                    + t.touch.deltaX
                self.touchpt[t.touch.id].y = 
                    self.touchpt[t.touch.id].y
                    + t.touch.deltaY
            end
            if t.touch.state == ENDED then
                self.touchpt[t.touch.id] = nil
            end
        end
        g:noted()
        if regenerate then
            self:generate()
        end
    end
    if g.type.ended then
        g:reset()
    end
end

function Path:setLineWidth(l)
    self.style.linewidth = l
end

function Path:setBlur(l)
    self.style.blur = l
end

function Path:setSmooth(l)
    self.style.smooth = l
end

function Path:setColour(c)
    self.style.drawColour = c
end

function BezierPoints(pts,a,b,c,d)
    pts = pts or {}
    if not(type(a) == "table" and a.is_a and a:is_a(Bezier)) then
        a = Bezier(a,b,c,d)
    end
    local t = 0
    local r = PATH_RES
    local s = PATH_STEP
    local tpt = a
    table.insert(pts,{tpt,a:unitNormal(0)})
    local dis
    local p
    while t < 1 do
        dis = 0
        while dis < r do
            t = t + s
            p = a:point(t)
            dis = p:distSqr(tpt)
        end
        if t > 1 then
            t = 1
            p = d
        end
        table.insert(pts,{p,a:unitNormal(t)})
        tpt = p
    end
    return pts
end

function HobbyPoints(ver,s,pts,extra)
    ver = ver or {}
    if #pts == 1 then
        local v = pts[1]
        if type(v) == "table" then
            v = v[1]
        end
        local n = v - s
        n = n:rotate90()
        n = n/n:len()
        table.insert(ver,{s,n})
        table.insert(ver,{v,n})
        return ver
    end
    local apts = {}
    table.insert(apts,s)
    for _,v in ipairs(pts) do
        table.insert(apts,v)
    end
    local bcurves = Hobby(apts,extra)
    for _,v in ipairs(bcurves) do
        ver = BezierPoints(v,ver)
    end
    return ver
end

return Path

--]==]

TextNode.lua

--[==[
-- Text Node


local Font,_,Textarea = unpack(cimport "Font",nil)
local Colour = unpack(cimport "Colour",nil)
local UTF8 = cimport "utf8"
cimport "Keyboard"
--cimport "RoundedRect"
cimport "ColourNames"
local TextNode = class(Textarea)

function TextNode:init(t)
    t = t or {}
    t.font = t.font or Font({name = "AmericanTypewriter", size = 12})
    t.width = t.width or "32em"
    t.height = t.height or "1lh"
    if t.fit == nil then
        t.fit = true
    end
    t.angle = t.angle or 0
    Textarea.init(self,t)
    self.keyboard = t.keyboard or "fullqwerty"
    self.ui = t.ui
    self:activate()
    self.edit = t.edit or true
    self.savecolour = self.colour
    self:setColour(Colour.opacity(Colour.svg.Black,50))
    self.ui:useKeyboard(self.keyboard,
        function(k) return self:processKey(k) end)
end

function TextNode:processTouches(g)
    if g.type.ended and g.type.tap and g.num == 2 then
        self:setEdit()
        g:reset()
        return
    end
    if g.updated then
        if g.num == 1 then
            local t = g.touchesArr[1]
        if self.edit then
            local td = 
                vec2(t.touch.deltaX,
                    t.touch.deltaY):rotate(-math.rad(self.angle))
            self:setSize({
                width = self.width + td.x,
                height = self.height + td.y,
                maxWidth = self.mwidth + td.x,
                maxHeight = self.mheight + td.y,
                })
        else
            self.anchor = nil
            self.opos = function() return self.x, self.y end
            self.x = self.x + t.touch.deltaX
            self.y = self.y + t.touch.deltaY
        end
            
        elseif g.num == 2 then
        local ta,tb = g.touchesArr[1],g.touchesArr[2]
        local sa,sb,ea,eb
        ea = --OrientationInverse(PORTRAIT,
            vec2(ta.touch.x,ta.touch.y)
        eb = --OrientationInverse(PORTRAIT,
            vec2(tb.touch.x,tb.touch.y)
        if ta.updated and ta.state ~= BEGAN then
            sa = --OrientationInverse(PORTRAIT,
            vec2(ta.touch.prevX,ta.touch.prevY)
        else
            sa = ea
        end
        if tb.updated and tb.state ~= BEGAN then
            sb = --OrientationInverse(PORTRAIT,
            vec2(tb.touch.prevX,tb.touch.prevY)
        else
            sb = eb
        end
        local o = vec2(self.x,self.y)
        local ang = (sb - sa):angleBetween(eb - ea)
        local sc = ((sb + sa)/2 - o):rotate(ang)
        local ec = (ea + eb)/2 - o
        self.angle = self.angle + math.deg(ang)
        self.anchor = nil
            self.opos = function() return self.x, self.y end
            self.x = self.x + ec.x - sc.x
            self.y = self.y + ec.y - sc.y
        end
    end
    g:noted()
    if g.type.ended and not g.type.tap then
        g:reset()
    end
end

function TextNode:processKey(k)
    if k == BACKSPACE then
        self:delChar()
    elseif k == RETURN then
        self:addChar(UTF8("\n"))
    else
        self:addChar(k)
    end
    return false
end

function TextNode:setEdit(e)
    if e == nil then
        e = not self.edit
    end
    if e then
        self.edit = true
        self.savecolour = self.colour
        self:setColour(Colour.opacity(Colour.svg.Black,50))
        self.ui:useKeyboard(self.keyboard,
                function(k) return self:processKey(k) end)
    else
        self.edit = false
        self:setColour(self.savecolour)
        self.ui:unuseKeyboard()
    end
end

return TextNode

--]==]

TrendGraph.lua

--[==[
-- Trend Graph

local TrendGraph = class()

function TrendGraph:init(t)
    self.outer = Frame(t.x, t.y, t.x + t.width, t.y + t.height)
    self.inner = Frame(t.x + 20, t.y + 10, t.x + t.width - 10, t.y + t.height - 20)
    self.title = t.title or ""
    self.font = t.font or "Copperplate"
    self.fontSize = t.fontSize or 16
    self.colour = t.colour or Colour.svg.SlateGray
    self.icolour = Colour.tint(self.colour,50)
    self.rate = t.rate or 1
    self.series = {}
    self.xlabel = ""
    self.ylabel = ""
    font(self.font)
    fontSize(self.fontSize)
    local w,h = textSize(self.title)
    self.titlex = self.outer:midx() - w/2
    self.titley = self.outer.y2 - h - 5
    self.frame = 0
end

function TrendGraph:addSeries(name, len, min, max, sym, size, thick, clr, value)
    local i
    i = table.getn(self.series)
    self.series[i + 1] = DataSeries(name, len, min, max, sym, size, thick, clr, value)
end

function TrendGraph:draw(pts)
    pushMatrix()
    pushStyle()
    self.frame = self.frame + 1
    fill(self.colour)
    self.outer:draw()
    stroke(253, 3, 3, 255)
    fill(self.icolour)
    self.inner:draw()
    fill(0, 0, 0, 255)
    noSmooth()
    font(self.font)
    fontSize(self.fontSize)
    textMode(CORNER)
    text(self.title,self.titlex,self.titley)
    for s, series in ipairs(self.series) do
        if self.frame%self.rate == 0 and not self.paused then
            series:update()
        end
        series:draw(self.inner, self.min, self.max)
    end
    popMatrix()
    popStyle()
end

function TrendGraph:pause(p)
    self.paused = p
    for s, series in ipairs(self.series) do
        series:addBreak()
    end
end

return TrendGraph

--]==]

View.lua

--[==[
-- View

--[[
The "View" class defines an object which handles positioning of
things in 3-dimensions and how they project to the 2-dimensional iPad
screen.  It handles transformations and certain other aspects that are
more to do with the surrounding View than a particular object in it.

In this class, the term "internal" refers to the 3-dimensional
representation of View.  The term "external" refers to things after
the projection to the plane of the iPad screen.
--]]

local View = class()

local Quaternion = cimport "Quaternion"
cimport "Coordinates"

--[[
We need to know the user interface object as we want to have our own
menu for the user to choose various options.
--]] 

function View:init(ui,t,p)
    p = p or {}
    self.baseRotation = Quaternion.Rotation(0,vec3(1,0,0))
    self.orientRotation = Quaternion.unit()
    self.intScale = 1
    self.extScale = 1
    self.fishEye = 1
    self.speed = 1/600
    self.origin = vec3(0,0,0)
    self.velocity = vec3(0,0,0)
    self.acceleration = 1
    self.friction = .2
    self.bgColour = color(0,0,0,255)
    self.eye = vec3(0,0,15)
    self.looking = -self.eye
    self.up = vec3(0,1,0)
    self.light = vec3(0,1,0)
    self.currentGravity = self.orientRotation:Gravity()
    self.useGravity = true
    self.rotation = self.baseRotation
    self.matrix = matrix()
    self.initials = {}
    self.ui = ui
    for k,v in pairs(p) do
        self[k] = v
    end

    if Menu then
    local m = ui:addMenu({title = "View", attach = true})
    m:addItem({
        title = "Use Gravity",
        action = function()
            self:gravityOnOff()
            return true
        end,
        highlight = function()
            return self.useGravity
        end
    })
    ui:addHelp({title = "View", text = {"Instructions:",
    "Single tap: toggle the reaction to tilt",
    "Double tap: restore initial spatial settings",
    "Single swipe: rotate the object about an axis in the plane of the screen",
    "Double swipe: translate the object in 3-View",
    "Triple swipe: translate the projected image of the object",
    "Vertical pinch: scale the object in 3-View",
    "Horizontal pinch: scale the projected image"
    }}
    )
    end
    t:pushHandler(self)
    self:saveInitials()
end

--[[
Make sure we can get back to where we started.
--]]

function View:saveInitials()
    self.initials.baseRotation = self.baseRotation
    self.initials.intScale = self.intScale
    self.initials.extScale = self.extScale
    self.initials.origin = self.origin
    self.initials.eye = self.eye
    self.initials.currentGravity = self.currentGravity
    self.initials.fishEye = self.fishEye
    self.initials.light = self.light
end

--[[
Get us back to where we started.
--]]

function View:restoreInitials()
    self.baseRotation = self.initials.baseRotation
    self.intScale = self.initials.intScale
    self.extScale = self.initials.extScale
    self.origin = self.initials.origin
    self.eye = self.initials.eye
    self.currentGravity = self.initials.currentGravity
    self.fishEye = self.initials.fishEye
    self.light = self.initials.light
end

function View:reset()
    self:restoreInitials()
end

--[[
This is the main draw function.  It does not actually do much drawing
but rather sets up various things for use by other objects.
--]]

function View:draw()
    self.orientRotation:updateReferenceFrame()
    if self.angVelocity then
        if ElapsedTime - self.angvTime > 1 then
            self.angVelocity = nil
        else
            qa = self.angVelocity(ElapsedTime - self.angvTime)
            self.baseRotation = self.baseRotation * qa
        end
    end
    if self.moving then
        self.origin = self.origin + DeltaTime*self.velocity
    end
    local q = self.baseRotation * self:getGravity()
    local s = self.fishEye * self.intScale
    local o = self.origin
    local e = self.eye
    local up = self.up
    e = s*e^q + o
    up = up^q
    self.looking = o - e
    if self.moving then
        self.velocity = self.velocity 
                + DeltaTime * self.acceleration * (o-e)
                - DeltaTime * self.friction * self.velocity:len() * self.velocity
    end
    camera(e.x,e.y,e.z,o.x,o.y,o.z,up.x,up.y,up.z)
    local fe = math.atan(self.fishEye)*180/math.pi
    if self.near then
        perspective(fe,WIDTH/HEIGHT,self.near,self.far)
    else
        perspective(fe,WIDTH/HEIGHT)
    end
    self.matrix = viewMatrix() * projectionMatrix()
end

--[[
If we are noticing gravity then this figures out the rotation defined
by our current gravity vector as a quatertion.
--]]

function View:getGravity()
    if self.useGravity then
        return self.currentGravity * self.orientRotation:Gravity()^""
    else
        return self.currentGravity
    end
end

--[[
This applies the current internal transformation to the given vector;
this is before stereographic projection has occured.
--]]

function View:applyIntTransformation(v)
    local q = self.baseRotation * self:getGravity()
    local s = self.fishEye * self.intScale
    local o = self.origin
    return s * (v^q + o)
end

function View:applyIntDirTransformation(v)
    local q = self.baseRotation * self:getGravity()
    local s = self.fishEye * self.intScale
    return s * v^q
end

function View:invertIntTransformation(v)
    local q = self.baseRotation * self:getGravity()
    local s = self.fishEye * self.intScale
    local o = self.origin
    q = q^""
    return (v / s - o)^q
end

function View:invertIntDirTransformation(v)
    local q = self.baseRotation * self:getGravity()
    local s = self.fishEye * self.intScale
    q = q^""
    return v^q / s
end

--[[
This applies the current external transformation to the given vector;
this is after stereographic projection has occured.
--]]

function View:applyExtTransformation(v)
    return (self.extScale/self.fishEye) * (v + self.extTranslate)
end

function View:applyExtDirTransformation(v)
    return (self.extScale/self.fishEye) * v
end

--[[
This projects the vector onto the screen, taking into account the
current internal and external transformations.
--]]

function View:Project(v)
    local u,w,r,l
    -- u = self.intScale * ((v + self.intTranslate)^self.rotation)
    u = self:applyIntTransformation(v)
        w = u + Vec3.e1
        w = w:stereoProject(self.eye) - u:stereoProject(self.eye)
        r = w:len()
        l = u:stereoLevel(self.eye)
        u = self:applyExtTransformation(u:stereoProject(self.eye))
        return {u,r,l,v:isInFront(self.eye)}
end

function View:ProjectDirection(v)
    local u
    u = self:applyIntDirTransformation(v)
    return u
end

--[[
This inverts the projection to the z-level of the second vector.
--]]

function View:invProject(v,w)
    local u,q,h
    u = v / self.extScale - self.extTranslate
    q = self.rotation
    w = self.intScale * (w^q + self.intTranslate)
    u = Vec3.stereoInvProject(u,self.eye,w.z)
    u = u / self.intScale - self.intTranslate
    q = q^""
    u = u^q
    return u
end

--[[
We should be pretty far down the "touch" queue so we take anything we
can.
--]]

function View:isTouchedBy(touch)
    return true
end

--[[
Our possible touches and their actions are:

Single tap: freeze or unfreeze the gravitational effect.

Double tap: restore stuff to initial conditions.

Single move: rotate View, if it is short then we carry on spinning
for a bit.

Pinch: scale View, either internally or externally

Double swipe: translate internally

Triple swipe: translate externally
--]]

function View:processTouches(g)
    if g.type.long and g.num == 1 then
        self:singleLongTap(g.touchesArr[1])
        if g.type.ended then
            g:reset()
        end
    elseif g.type.tap then
        if g.type.finished then
            if g.num == 1 then
                self:singleShortTap()
            elseif g.num == 2 then
                self:doubleTap()
            end
        end
    else
        if g.numactives == 1 then
            self:singleTouch(g.actives[1])
            if g.type.ended and g.type.short then
                 self:saveVelocity(g.actives[1])
            end
        elseif g.numactives == 2 then
            self:doubleTouch(g.actives[1],g.actives[2])
        elseif g.numactives == 3 then
            if not g.type.ViewTriple then
                g.type.ViewTripleType = self:isTriangle(
                    g.actives[1],
                    g.actives[2],
                    g.actives[3])
                g.type.ViewTriple = true
            end
            if g.type.ViewTripleType then
                self:triplePinch(
                    g.actives[1],
                    g.actives[2],
                    g.actives[3])
            else
                self:tripleSwipe(
                    g.actives[1],
                    g.actives[2],
                    g.actives[3])
            end
        end
        if g.type.ended then
            g:reset()
        end
    end
    g:noted()
    if g.type.finished then
        g:reset()
    end
end

--[[
Rotate View according to the movement, saving the velocity so that we
can carry on spinning for a bit if the total movement was short.
--]]

function View:singleTouch(thisTouch)
    local r,p,v,lp,lv,ox,oy,u,qa,qg,touch
    if not thisTouch.updated then
        return
    end
    touch = thisTouch.touch
    if touch.state == MOVING or touch.state == ENDED then
        r =RectAnchorOf(Screen,"width")/2
        ox,oy = RectAnchorOf(Screen,"centre")
        p = vec2(touch.prevX - ox,touch.prevY - oy)/r
        v = vec2(touch.x - ox,touch.y - oy)/r
        lv = v:lenSqr()
        lp = p:lenSqr()
        if lp > .9 or lv > .9 then
            return
        end
        p = vec3(p.x,p.y,math.sqrt(1 - lp))
        v = vec3(v.x,v.y,math.sqrt(1 - lv))
        qa = v:rotateTo(p)
        local b = SO3(self.eye,self.up)
        qa = Quaternion(qa.q.x,-qa.q.y*b[3] + qa.q.z*b[2] + qa.q.w*b[1])
        qg = self:getGravity()
        self.baseRotation = self.baseRotation * qg * qa * qg^""
    end
end

--[[
Saves our velocity.
--]]

function View:saveVelocity(touch)
    local ft,t,dt,r,p,ox,oy,v,lp,lv,qa,qg
    ft = touch.firsttouch
    t = touch.touch
    dt = ElapsedTime - touch.createdat
    r = RectAnchorOf(Screen,"width")/2
    ox,oy = RectAnchorOf(Screen,"centre")
    p = vec2(ft.x - ox,ft.y - oy)/r
    v = vec2(t.x - ox,t.y - oy)/r
    v = p + (v-p)*2*DeltaTime/dt
    lp = p:lenSqr()
    lv = v:lenSqr()
    if lp < .9 and lv < .9 then
        -- raise both to sphere
        p = vec3(p.x,p.y,math.sqrt(1 - lp))
        v = vec3(v.x,v.y,math.sqrt(1 - lv))
        qa = v:rotateTo(p)
        local b = SO3(self.eye,self.up)
        qa = Quaternion(qa.q.x,-qa.q.y*b[3] + qa.q.z*b[2] + qa.q.w*b[1])
        qg = self:getGravity()
        qa = qg * qa * qg^""
        self.angVelocity = qa:make_slerp(Quaternion.unit())
        self.angvTime = ElapsedTime
        touch.container.interrupt = self
    end
end

--[[
This uses the "interrupt" feature of the touch controller so that if
we are rotating then the next touch stops us.
--]]

function View:interruption(t)
    if self.angVelocity then
        self.angVelocity = nil
        t.container.interrupt = nil
        return true
    else
        return false
    end
end

--[[
General handling of double touches
--]]

function View:doubleTouch(ta,tb)
    if not ta.updated and not tb.updated then
        return
    end
    local sa,sb,ea,eb,o,n,u,v,A
    ea = vec2(ta.touch.x,ta.touch.y)
    eb = vec2(tb.touch.x,tb.touch.y)
    if ta.updated then
        sa = vec2(ta.touch.prevX,ta.touch.prevY)
    else
        sa = ea
    end
    if tb.updated then
        sb = vec2(tb.touch.prevX,tb.touch.prevY)
    else
        sb = eb
    end
    local ed = eb - ea
    local sd = sb - sa
    local el = ed:len()
    local sl = sd:len()
    local s = 1
    local theta = 0
    if sl > 0.001 and el > 0.001 then
        s = el/sl
        theta = ed:angleBetween(sd)
    end
    o = (eb + ea)/2
    A = self.matrix
    n = screennormal(o,A)
    u = n:cross(self.up)
    v = u:cross(n)
    o = self.origin
    sa = screentoplane(sa,o,u,v,A)
    ea = screentoplane(ea,o,u,v,A)
    sb = screentoplane(sb,o,u,v,A)
    eb = screentoplane(eb,o,u,v,A)
    ed = (eb + ea)/2
    sd = (sb + sa)/2
    local a = self.eye - ed
    a = a:normalize()
    local q = Quaternion.Rotation(theta,a)
    self.intScale = self.intScale / s
    local tr = ed - sd^q*s
    local qg = self:getGravity()
    local qa = qg * q * qg^""
    self.baseRotation = self.baseRotation * qa
    self.origin = self.origin^qa - tr
end
    



--[[
Triple touch handling - are the coordinates "triangular" or "linear"
--]]

function View:isTriangle(ta,tb,tc)
    local a = vec2(ta.touch.x,ta.touch.y)
    local b = vec2(tb.touch.x,tb.touch.y)
    local c = vec2(tc.touch.x,tc.touch.y)
    local phi = (b - a):angleBetween(c - a)
    local psi = (a - b):angleBetween(c - b)
    phi = phi - math.floor(phi/(2*math.pi))*2*math.pi
    if phi > math.pi then
        phi = 2*math.pi - phi
    end
    psi = psi - math.floor(psi/(2*math.pi))*2*math.pi
    if psi > math.pi then
        psi = 2*math.pi - psi
    end
    if phi > math.pi/2 
        or psi > math.pi/2 
        or phi + psi < math.pi/2
    then
        return false
    else
        return true
    end
end

--[[
A triple swipe to an external translation.
--]]

function View:tripleSwipe(ta,tb,tc)
    if not ta.updated and not tb.updated and not tc.updated then
        return
    end
    local ea,eb,ec,sa,sb,sc,ed,sd
    ea = vec2(ta.touch.x,ta.touch.y)
    eb = vec2(tb.touch.x,tb.touch.y)
    ec = vec2(tc.touch.x,tc.touch.y)
    if ta.updated then
        sa = vec2(ta.touch.prevX,ta.touch.prevY)
    else
        sa = ea
    end
    if tb.updated then
        sb = vec2(tb.touch.prevX,tb.touch.prevY)
    else
        sb = eb
    end
    if tc.updated then
        sc = vec2(tc.touch.prevX,tc.touch.prevY)
    else
        sc = ec
    end
    o = (ec + eb + ea)/2
    A = self.matrix
    n = screennormal(o,A)
    u = n:cross(self.up)
    v = u:cross(n)
    o = self.origin
    sa = screentoplane(sa,o,u,v,A)
    ea = screentoplane(ea,o,u,v,A)
    sb = screentoplane(sb,o,u,v,A)
    eb = screentoplane(eb,o,u,v,A)
    sc = screentoplane(sc,o,u,v,A)
    ec = screentoplane(ec,o,u,v,A)
    ed = (ec + eb + ea)/2
    sd = (sc + sb + sa)/2
    self.origin = self.origin - ed + sd
end

--[[
A triple pinch to alter the "fish eye" effect
--]]

function View:triplePinch(ta,tb,tc)
    local a = vec2(ta.touch.x,ta.touch.y)
    local b = vec2(tb.touch.x,tb.touch.y)
    local c = vec2(tc.touch.x,tc.touch.y)
    local pa,pb,pc
    if ta.updated then
        pa = vec2(ta.touch.prevX,ta.touch.prevY)
    else
        pa = a
    end
    if tb.updated then
        pb = vec2(tb.touch.prevX,tb.touch.prevY)
    else
        pb = b
    end
    if tc.updated then
        pc = vec2(tc.touch.prevX,tc.touch.prevY)
    else
        pc = c
    end
    local d = TriangleArea(a,b,c)
    local pd = TriangleArea(pa,pb,pc)
    self.fishEye = self.fishEye*(1+pd)/(1+d)
end

--[[
A single tap toggles the use of gravity.
--]]

function View:singleShortTap()
    self:gravityOnOff()
end

function View:singleLongTap(t)
    if t.touch.state == ENDED then
        self.moving = false
    else
        self.moving = true
    end
end

--[[
This is the actual toggle function.  As well as toggling the use, it
saves the current rotation so that the effect is to freeze the object.
--]]

function View:gravityOnOff()
    if self.useGravity then
        self.currentGravity = self:getGravity()
    else
        self.currentGravity = self.currentGravity * self.orientRotation:Gravity()
    end
    self.useGravity = not self.useGravity
end

--[[
This is the double tap function that calls the reset function.
--]]

function View:doubleTap()
    self:restoreInitials()
end

return View

--]==]

Zoom.lua

--[==[
-- 2D Zoom

local Zoom = class()

function Zoom:init(t)
    t:pushHandler(self)
    self.ll = vec2(0,0)
    self.size = vec2(1,1)
    -- self.aspect = true
end

function Zoom:draw()
    scale(self.size.x,self.size.y)
    translate(self.ll.x,self.ll.y)
end

function Zoom:isTouchedBy(touch)
    return true
end

function Zoom:processTouches(g)
    if g.updated then
    if g.numactives == 1 then
        local dx = g.actives[1].touch.deltaX/self.size.x
        local dy = g.actives[1].touch.deltaY/self.size.y
        self.ll = self.ll + vec2(dx,dy)
    elseif g.numactives == 2 then
        local ta = g.actives[1]
        local tb = g.actives[2]
        local ea = vec2(ta.touch.x,ta.touch.y)
        local eb = vec2(tb.touch.x,tb.touch.y)
        local sa,sb
        if ta.updated then
            sa = vec2(ta.touch.prevX,ta.touch.prevY)
        else
            sa = ea
        end
        if tb.updated then
            sb = vec2(tb.touch.prevX,tb.touch.prevY)
        else
            sb = eb
        end
        local sc = (sa + sb)/2
        sc.x = sc.x / self.size.x
        sc.y = sc.y / self.size.y
        local sl = (sb - sa):len()
        local el = (eb - ea):len()
        self.size = self.size * el / sl
        local ec = (ea + eb)/2
        ec.x = ec.x / self.size.x
        ec.y = ec.y / self.size.y
        self.ll = self.ll + ec - sc
    end
    end
    if g.type.finished then
        g:reset()
    else
        g:noted()
    end
end

return Zoom

--]==]