Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- --# Main
- -- BlockTown
- displayMode(FULLSCREEN)
- function setup()
- Settings()
- Move=false
- CreateScene(T2)
- end
- function Settings()
- --lighting
- ambient=0.3
- diffuse=0.6
- lightDirection=vec3(1,1,1):normalize()
- lightIntensity=1
- mist=100
- mistColor=color(230)
- camDist=50 --??
- camY=4
- FPS=60
- --controls
- joy1=JoyStick({radius=150})
- turnSensitivity=0.25
- --joy2=JoyStick({centre=vec2(WIDTH-joy1.centre.x,joy1.centre.y)})
- speed=0
- speedFactor=0.5
- speedSensitivity=0.25
- lookFactor=0.03
- velocity=vec3(0,0,0)
- currTileCode=""
- end
- function draw()
- background(mistColor) --(150*lightIntensity)
- FPS=FPS*0.95+0.05/DeltaTime
- AdjustPosition()
- perspective()
- cam=playerPos+vec3(0,camY,0)
- camLook=cam+look
- camera(cam.x,cam.y,cam.z,camLook.x,camLook.y,camLook.z)
- DrawScene(cam,camLook,mist+math.sin(ElapsedTime*.5)*10)
- DrawHUD()
- end
- function touched(t)
- joy1:touched(t)
- --joy2:touched(t)
- end
- function AdjustPosition()
- --update velocity
- local v1=joy1:update()
- if joy1.touch then
- local t=turnSensitivity
- if v1.y<0 then v1.y=math.min(0,v1.y+t)/(1-t) else v1.y=math.max(0,v1.y-t)/(1-t) end
- speed=v1.y*speedFactor
- --update player position
- local p=playerPos+look*speed --get new position, test if valid
- playerPos=PreventCollision(playerPos,p)
- --update look direction
- local t=speedSensitivity
- if v1.x<0 then v1.x=math.min(0,v1.x+t)/(1-t) else v1.x=math.max(0,v1.x-t)/(1-t) end
- lookAngle=lookAngle-v1.x*lookFactor
- look=vec3(math.cos(lookAngle),0,-math.sin(lookAngle))
- UpdateSettings(playerPos)
- end
- --local v2=joy2:update()
- --if joy2.touch then look=(look+vec3(v2.x,0,-v2.y):normalize()*lookFactor):normalize() end
- end
- function DrawHUD()
- ortho()
- viewMatrix(matrix())
- fill(0,0,0)
- fontSize(16)
- text("FPS="..math.floor(FPS),WIDTH-50,HEIGHT-25)
- joy1:draw()
- --joy2:draw()
- end
- --# Maps
- --Maps
- local M,sceneWidth,sceneDepth,block,prevTileCode
- function CreateScene(map)
- M=map
- local s=M.spawn[math.random(1,#M.spawn)]
- playerPos=PosToPixel(s[1])
- lookAngle=math.deg(s[2])
- look=vec3(math.cos(lookAngle),0,-math.sin(lookAngle))
- mapSize=map.mapSize*map.tileSize
- margin=map.tileSize/2
- spriteSheet=readImage(map.spriteSheet)
- spriteWidth,spriteHeight=spriteSheet.width,spriteSheet.height
- --surface mesh
- surface=CreateSurface(M.images.surface)
- --build fence
- fence=BuildFence(M.images.fence)
- --build basic objects
- objects=BuildObjects()
- --read map and create mesh containing objects
- objMesh=ReadMap()
- print(objMesh.size)
- local x,y,z=M.tileSize*M.mapSize.x/2,M.tileSize*8,M.tileSize*M.mapSize.y
- CullDupFaces(objMesh)
- print(objMesh.size)
- end
- function UpdateSettings(p)
- local t=PixelToPos(p)
- local m=memMap[t.x*1000000+t.y*1000+t.z] or "default"
- if m~=prevTileCode then
- prevTileCode=m
- if M.tileSettings[m] then
- ambient=M.tileSettings[m].ambient
- diffuse=M.tileSettings[m].diffuse
- mist=M.tileSettings[m].mist
- end
- end
- end
- function DrawScene(cam,look,mist)
- local cam4=vec4(cam.x,cam.y,cam.z,1)
- SetLighting(surface,cam4,mist) surface:draw()
- SetLighting(fence,cam4,mist) fence:draw()
- SetLighting(objMesh,cam4,mist)
- objMesh.shader.ambient=ambient
- objMesh.shader.diffuse=diffuse
- objMesh:draw()
- end
- function SetLighting(m,cam4,mist)
- m.shader.intensity=lightIntensity
- m.shader.mModel=modelMatrix()
- m.shader.cam=cam4
- m.shader.mist=mist
- end
- function CullDupFaces(m)
- local bv=m:buffer("position")
- local bt=m:buffer("texCoord")
- local bn=m:buffer("normal")
- local bc=m:buffer("color")
- local A,B={},{}
- local r=100000
- for i=1,m.size,6 do
- local c=bv[i]+bv[i+1]+bv[i+2]+bv[i+4]
- local cc=math.floor(r+c.x*100+0.5)..","..math.floor(r+c.y*100+0.5)..","..math.floor(r+c.z*100+0.5)
- A[cc]=(A[cc] or 0)+1
- for j=0,5 do B[i+j]=cc end
- end
- local v,t,n,c={},{},{},{}
- local u=0
- for i=1,m.size do
- if A[B[i]]==1 then
- u=u+1
- v[u]=bv[i]
- t[u]=bt[i]
- n[u]=bn[i]
- if bc then c[u]=bc[i] end
- end
- end
- m.vertices=v
- m.texCoords=t
- m.normals=n
- if bc then m.colors=c end
- --print(m.size)
- end
- function ReadMap()
- memMap={}
- local A={}
- A.v,A.t,A.n,A.c={},{},{},{}
- for _,a in pairs(M.mapData) do
- local p0=PosToPixel(a.start) --bottom left tile location
- local n=string.len(a.tiles[1])
- for i=#a.tiles,1,-1 do
- for j=1,n do
- e=string.sub(a.tiles[i],j,j)
- memMap[(a.start.x+j-1)*1000000+a.start.y*1000+(a.start.z+i-1)]=e
- local f=objects[e]
- if f then
- for k=1,#f.v do
- A.v[#A.v+1]=f.v[k]+p0+vec3(j-1,0,-i+1)*M.tileSize
- A.t[#A.t+1]=f.t[k]
- A.n[#A.n+1]=f.n[k]
- A.c[#A.c+1]=f.c[k]
- end
- end
- end
- end
- end
- --fill in fence around edge in memMap
- for i=0,M.mapSize.x+1 do
- memMap[i*1000000]="_"
- memMap[i*1000000+M.mapSize.y+1]="_"
- end
- for i=0,M.mapSize.y+1 do
- memMap[i]="_"
- memMap[(M.mapSize.x+1)*1000000+i]="_"
- end
- --create mesh
- local m=mesh()
- m.vertices=A.v
- m.texCoords=A.t
- m.texture=mapImage
- m.normals=A.n
- m.colors=A.c
- m.shader=shader(Diffuse.v,Diffuse.f)
- m.shader.lightDirection=lightDirection
- m.shader.intensity=lightIntensity
- m.shader.ambient=ambient
- m.shader.diffuse=diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function CreateSurface(img)
- local w,d=mapSize.x,mapSize.y
- local x1,x2=-w/2,w/2
- local y=-0.1
- local z1,z2=0,-d
- local v={vec3(x1,y,z1),vec3(x2,y,z1),vec3(x2,y,z2),vec3(x1,y,z2)}
- local tw,td=w/img[3]/img[5],d/img[4]/img[5]
- local t={vec2(0,0),vec2(tw,0),vec2(tw,td),vec2(0,td)}
- local m=mesh()
- m.vertices={v[1],v[2],v[3],v[3],v[4],v[1]}
- m.texCoords={t[1],t[2],t[3],t[3],t[4],t[1]}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- m.colors={c,c,c,c,c,c}
- m.texture=M.spriteSheet
- m.shader=shader(Surface.v,Surface.f)
- m.shader.light=ambient+diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function BuildFence(img)
- local w,d,h0=mapSize.x,mapSize.y,-0.1
- local v11,v21,v22,v12=vec3(-w/2,h0,0),vec3(w/2,h0,0),vec3(w/2,h0,-d),vec3(-w/2,h0,-d)
- local h=vec3(0,M.tileSize,0)
- local m=mesh()
- m.vertices={v11,v21,v21+h,v21+h,v11+h,v11, v11,v12,v12+h,v12+h,v11+h,v11,
- v12,v22,v22+h,v22+h,v12+h,v12, v21,v22,v22+h,v22+h,v21+h,v21}
- local tw,th,td=w/img[3]/img[5],M.tileSize/img[4]/img[5],d/img[4]/img[5]
- local t11, t21, t22, t12 =vec2(0,0),vec2(tw,0),vec2(tw,th),vec2(0,th)
- local t11d,t21d,t22d,t12d=vec2(0,0),vec2(td,0),vec2(td,th),vec2(0,th)
- m.texCoords={t11 ,t21 ,t22 ,t22 ,t12 ,t11 , t11 ,t21 ,t22 ,t22 ,t12 ,t11,
- t11d,t21d,t22d,t22d,t12d,t11d, t11d,t21d,t22d,t22d,t12d,t11d}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- local col={} for i=1,24 do col[i]=c end
- m.colors=col
- m.texture=M.spriteSheet
- m.shader=shader(Surface.v,Surface.f)
- m.shader.light=ambient+diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function BuildObjects()
- B={} --object list
- for a,b in pairs(M.objects) do
- if b.type=="block" then B[a]=CreateBlock(M.images[b.image]) end
- end
- return B
- end
- function CreateBlock(img,bottom)
- local s=M.tileSize
- local s2=s/2
- local v={vec3(-s2,0, s2),vec3(s2,0, s2),vec3(s2,s, s2),vec3(-s2,s, s2),
- vec3(-s2,0,-s2),vec3(s2,0,-s2),vec3(s2,s,-s2),vec3(-s2,s,-s2)}
- local vert={v[1],v[2],v[3],v[3],v[4],v[1],v[6],v[5],v[8],v[8],v[7],v[6],
- v[2],v[6],v[7],v[7],v[3],v[2],v[5],v[1],v[4],v[4],v[8],v[5],
- v[8],v[4],v[3],v[3],v[7],v[8],v[5],v[6],v[2],v[2],v[1],v[5]}
- local tw,th=s/img[3]/img[5],s/img[4]/img[5]
- local t={vec2(0,0),vec2(tw,0),vec2(tw,th),vec2(0,th)}
- local tex={t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1],
- t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1],
- t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1]}
- local n={vec3(0,0,1),vec3(0,0,-1),vec3(1,0,0),vec3(-1,0,0),vec3(0,1,0),vec3(0,-1,0)}
- local norm,col={},{}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- for i=1,#n do
- for j=1,6 do
- norm[#norm+1]=n[i]
- col[#col+1]=c
- end
- end
- return {v=vert,t=tex,n=norm,c=col}
- end
- function AddBlock(p,tbl,obj)
- pos=PosToPixel(p)
- for i=1,#obj.v do
- tbl.v[#bb.v+1]=obj.v[i]+pos
- tbl.t[#bb.t+1]=obj.t[i]
- tbl.n[#bb.n+1]=obj.n[i]
- tbl.c[#bb.c+1]=obj.c[i]
- end
- return tbl
- end
- function PosToPixel(p)
- return vec3(p.x-0.5-M.mapSize.x/2,p.y,-p.z+0.5)*M.tileSize
- end
- function PixelToPos(p)
- return vec3(math.floor((p.x+mapSize.x/2)/M.tileSize)+1,math.floor(p.y/M.tileSize),
- math.floor(-p.z/M.tileSize)+1)
- end
- function PreventCollision(p0,p1)
- local t=PixelToPos(p1)
- local m=memMap[t.x*1000000+t.y*1000+t.z]
- if m=="b" then
- --calculate direction of movement by using tile positions
- local v=PixelToPos(p0)-PixelToPos(p1)
- --move back towards previous tile
- p1=p0+vec3(v.x,0,-v.z)*M.tileSize/3
- end
- return p1
- end
- --# MapData
- --Map Data
- --T2
- T2={}
- T2.tileSize=8
- T2.mapSize=vec2(30,30) --even numbers for x, please
- T2.spawn={{vec3(2,0,2),45},{vec3(2,0,29),-45},{vec3(29,0,2),135},{vec3(29,0,29),-135}}
- T2.spriteSheet="Dropbox:T1"
- T2.images={
- block={611,1701,294,300,0.0166},
- surface={1,1401,599,600,0.02},
- fence={1,880,511,511,0.01},
- jump={610,1390,300,300,0.05}
- }
- T2.objects={
- b={type="block5",image="block"},
- B={type="block6",image="block"},
- j={type="jump",image="jump"}
- }
- T2.tileSettings={
- default={ambient=0.4,diffuse=0.6,mist=100},
- [" "]={ambient=0.7,diffuse=0,mist=99999999}
- }
- T2.mapData={
- {start=vec3(8,0,8),tiles=
- {"bbbbbbbbbbb bbbb",
- "b b b b",
- "b bbbb j b",
- "b b b bbb b",
- "b b b bbb b",
- "b bbb bbbbbbb b",
- "b bb b b",
- "bbbbb b",
- "b bbbbbbbbbbbb",
- "b b b bbb",
- "bbbb b b b",
- " jb bbbbb b",
- "bb b b b b",
- "bb bb bb b b",
- "bb bb b",
- "bbbbbbbbbbbbbbbb"},
- },
- -- {start=vec3(8,1,8),tiles=
- -- {"bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb",
- -- "bbbbbbbbbbbbbbbb"},
- {start=vec3(8,1,8),tiles=
- {"BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB",
- "BBBBBBBBBBBBBBBB"}
- }
- }
- --# Maps2
- --Maps
- local sceneWidth,sceneDepth,block,prevTileCode
- function CreateScene(map)
- M=map
- local s=M.spawn[math.random(1,#M.spawn)]
- playerPos=PosToPixel(s[1])
- lookAngle=math.rad(s[2])
- look=vec3(math.cos(lookAngle),0,-math.sin(lookAngle))
- mapSize=map.mapSize*map.tileSize
- margin=map.tileSize/2
- spriteSheet=readImage(map.spriteSheet)
- spriteWidth,spriteHeight=spriteSheet.width,spriteSheet.height
- --surface mesh
- surface=CreateSurface(M.images.surface)
- --build fence
- fence=BuildFence(M.images.fence)
- --build basic objects
- objects=BuildObjects()
- --read map and create mesh containing objects
- objMesh=ReadMap()
- print(objMesh.size)
- local x,y,z=M.tileSize*M.mapSize.x/2,M.tileSize*8,M.tileSize*M.mapSize.y
- CullDupFaces(objMesh)
- print(objMesh.size)
- end
- function UpdateSettings(p)
- local t=PixelToPos(p)
- local m=memMap[t.x*1000000+t.y*1000+t.z] or "default"
- if m~=prevTileCode then
- prevTileCode=m
- if M.tileSettings[m] then
- ambient=M.tileSettings[m].ambient
- diffuse=M.tileSettings[m].diffuse
- mist=M.tileSettings[m].mist
- end
- end
- end
- function DrawScene(cam,look,mist)
- --local cam4=vec4(cam.x,cam.y,cam.z,1)
- --SetLighting(surface,cam4,mist)
- surface.shader.intensity=lightIntensity
- surface:draw()
- --SetLighting(fence,cam4,mist)
- fence.shader.intensity=lightIntensity
- fence:draw()
- --SetLighting(objMesh,cam4,mist)
- objMesh.shader.ambient=ambient
- objMesh.shader.diffuse=diffuse
- objMesh.shader.intensity=lightIntensity
- objMesh.shader.mModel=modelMatrix()
- objMesh:draw()
- end
- function SetLighting(m,cam4,mist)
- m.shader.intensity=lightIntensity
- m.shader.mModel=modelMatrix()
- --m.shader.cam=cam4
- --m.shader.mist=mist
- end
- function CullDupFaces(m,seq)
- local bv=m:buffer("position")
- local bt=m:buffer("texCoord")
- local bn=m:buffer("normal")
- local bc=m:buffer("color")
- local A,B={},{}
- local r=100000
- for i=1,m.size,6 do
- local c=bv[i]+bv[i+1]+bv[i+2]+bv[i+4]
- local cc=math.floor(r+c.x*100+0.5)..","..math.floor(r+c.y*100+0.5)..","..math.floor(r+c.z*100+0.5)
- A[cc]=(A[cc] or 0)+1
- for j=0,5 do B[i+j]=cc end
- end
- local v,t,n,c={},{},{},{}
- local u=0
- for i=1,m.size do
- if A[B[i]]==1 then
- u=u+1
- v[u]=bv[i]
- t[u]=bt[i]
- n[u]=bn[i]
- if bc then c[u]=bc[i] end
- end
- end
- m.vertices=v
- m.texCoords=t
- m.normals=n
- if bc then m.colors=c end
- end
- function ReadMap()
- memMap={}
- local A={}
- A.v,A.t,A.n,A.c={},{},{},{}
- for _,a in pairs(M.mapData) do
- local p0=PosToPixel(a.start) --bottom left tile location
- local n=string.len(a.tiles[1])
- for i=#a.tiles,1,-1 do
- for j=1,n do
- e=string.sub(a.tiles[i],j,j)
- memMap[(a.start.x+j-1)*1000000+a.start.y*1000+(a.start.z+i-1)]=e
- local f=objects[e]
- if f then
- --memMap[(a.start.x+j-1)*1000000+a.start.y*1000+(a.start.z+i-1)]=e
- for k=1,#f.v do
- A.v[#A.v+1]=f.v[k]+p0+vec3(j-1,0,-i+1)*M.tileSize
- A.t[#A.t+1]=f.t[k]
- A.n[#A.n+1]=f.n[k]
- A.c[#A.c+1]=f.c[k]
- end
- end
- end
- end
- end
- --fill in fence around edge in memMap
- for i=0,M.mapSize.x+1 do
- memMap[i*1000000]="_"
- memMap[i*1000000+M.mapSize.y+1]="_"
- end
- for i=0,M.mapSize.y+1 do
- memMap[i]="_"
- memMap[(M.mapSize.x+1)*1000000+i]="_"
- end
- --create mesh
- local m=mesh()
- m.vertices=A.v
- m.texCoords=A.t
- m.texture=mapImage
- m.normals=A.n
- m.colors=A.c
- m.shader=shader(Diffuse.v,Diffuse.f)
- m.shader.lightDirection=lightDirection
- m.shader.intensity=lightIntensity
- m.shader.ambient=ambient
- m.shader.diffuse=diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function CreateSurface(img)
- local w,d=mapSize.x,mapSize.y
- local x1,x2=-w/2,w/2
- local y=-0.1
- local z1,z2=0,-d
- local v={vec3(x1,y,z1),vec3(x2,y,z1),vec3(x2,y,z2),vec3(x1,y,z2)}
- local tw,td=w/img[3]/img[5],d/img[4]/img[5]
- local t={vec2(0,0),vec2(tw,0),vec2(tw,td),vec2(0,td)}
- local m=mesh()
- m.vertices={v[1],v[2],v[3],v[3],v[4],v[1]}
- m.texCoords={t[1],t[2],t[3],t[3],t[4],t[1]}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- m.colors={c,c,c,c,c,c}
- m.texture=M.spriteSheet
- m.shader=shader(Surface.v,Surface.f)
- m.shader.light=ambient+diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function BuildFence(img)
- local w,d,h0=mapSize.x,mapSize.y,-0.1
- local v11,v21,v22,v12=vec3(-w/2,h0,0),vec3(w/2,h0,0),vec3(w/2,h0,-d),vec3(-w/2,h0,-d)
- local h=vec3(0,M.tileSize,0)
- local m=mesh()
- m.vertices={v11,v21,v21+h,v21+h,v11+h,v11, v11,v12,v12+h,v12+h,v11+h,v11,
- v12,v22,v22+h,v22+h,v12+h,v12, v21,v22,v22+h,v22+h,v21+h,v21}
- local tw,th,td=w/img[3]/img[5],M.tileSize/img[4]/img[5],d/img[4]/img[5]
- local t11, t21, t22, t12 =vec2(0,0),vec2(tw,0),vec2(tw,th),vec2(0,th)
- local t11d,t21d,t22d,t12d=vec2(0,0),vec2(td,0),vec2(td,th),vec2(0,th)
- m.texCoords={t11 ,t21 ,t22 ,t22 ,t12 ,t11 , t11 ,t21 ,t22 ,t22 ,t12 ,t11,
- t11d,t21d,t22d,t22d,t12d,t11d, t11d,t21d,t22d,t22d,t12d,t11d}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- local col={} for i=1,24 do col[i]=c end
- m.colors=col
- m.texture=M.spriteSheet
- m.shader=shader(Surface.v,Surface.f)
- m.shader.light=ambient+diffuse
- m.shader.mistColor=mistColor
- return m
- end
- function BuildObjects()
- B={} --object list
- for a,b in pairs(M.objects) do
- if b.type=="block5" then B[a]=CreateBlock(M.images[b.image],false)
- elseif b.type=="block6" then B[a]=CreateBlock(M.images[b.image],true)
- elseif b.type=="jump" then B[a]=CreateBillboard(M.images[b.image],"bottom")
- end
- end
- return B
- end
- function CreateBlock(img,bottom)
- local s=M.tileSize
- local s2=s/2
- local v={vec3(-s2,0, s2),vec3(s2,0, s2),vec3(s2,s, s2),vec3(-s2,s, s2),
- vec3(-s2,0,-s2),vec3(s2,0,-s2),vec3(s2,s,-s2),vec3(-s2,s,-s2)}
- local vert={v[1],v[2],v[3],v[3],v[4],v[1],v[6],v[5],v[8],v[8],v[7],v[6],
- v[2],v[6],v[7],v[7],v[3],v[2],v[5],v[1],v[4],v[4],v[8],v[5],
- v[8],v[4],v[3],v[3],v[7],v[8],v[5],v[6],v[2],v[2],v[1],v[5]}
- local tw,th=s/img[3]/img[5],s/img[4]/img[5]
- local t={vec2(0,0),vec2(tw,0),vec2(tw,th),vec2(0,th)}
- local tex={t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1],
- t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1],
- t[1],t[2],t[3],t[3],t[4],t[1],t[1],t[2],t[3],t[3],t[4],t[1]}
- local n={vec3(0,0,1),vec3(0,0,-1),vec3(1,0,0),vec3(-1,0,0),vec3(0,1,0),vec3(0,-1,0)}
- local norm,col={},{}
- local c=vec4(img[1]/spriteWidth,img[2]/spriteHeight,img[3]/spriteWidth,img[4]/spriteHeight)
- for i=1,#n do
- for j=1,6 do
- norm[#norm+1]=n[i]
- col[#col+1]=c
- end
- end
- if bottom~=true then
- for i=1,6 do
- table.remove(vert,#vert)
- table.remove(tex,#tex)
- table.remove(norm,#norm)
- table.remove(col,#col)
- end
- end
- return {v=vert,t=tex,n=norm,c=col}
- end
- function AddBlock(p,tbl,obj)
- pos=PosToPixel(p)
- for i=1,#obj.v do
- tbl.v[#bb.v+1]=obj.v[i]+pos
- tbl.t[#bb.t+1]=obj.t[i]
- tbl.n[#bb.n+1]=obj.n[i]
- tbl.c[#bb.c+1]=obj.c[i]
- end
- return tbl
- end
- function CreateBillboard(img,pos,s)
- if s==nil then s=M.tileSize/math.max(img[3],img[4]) end
- local w,h=img[3]*s,img[4]*s print(w,h)
- local v11,v21,v22,v12,n
- if pos=="bottom" then
- local m=0.1
- v11,v21,v22,v12=vec3(-w/2,m,-h/2),vec3(w/2,m,-h/2),vec3(w/2,m,h/2),vec3(-w/2,m,h/2)
- n=vec3(0,1,0)
- end
- local t11,t21,t22,t12=vec2(0,0),vec2(1,0),vec2(1,1),vec2(0,1)
- local vert={v11,v21,v22,v22,v12,v11}
- local tex ={t11,t21,t22,t22,t12,t11}
- local norm={} for i=1,6 do norm[i]=n end
- local c=GetTextureVector(img)
- local col={} for i=1,6 do col[i]=c end
- return {v=vert,t=tex,n=norm,c=col}
- end
- function AddBillboard(p,tbl,obj)
- pos=PosToPixel(p)
- for i=1,#obj.v do
- tbl.v[#bb.v+1]=obj.v[i]+pos
- tbl.t[#bb.t+1]=obj.t[i]
- tbl.n[#bb.n+1]=obj.n[i]
- tbl.c[#bb.c+1]=obj.c[i]
- end
- return tbl
- end
- function GetTextureVector(img)
- return color(img[1]/spriteSheet.width,img[2]/spriteSheet.height,
- img[3]/spriteSheet.width,img[4]/spriteSheet.width)*255
- end
- function PosToPixel(p)
- return vec3(p.x-0.5-M.mapSize.x/2,p.y,-p.z+0.5)*M.tileSize
- end
- function PixelToPos(p)
- return vec3(math.floor((p.x+mapSize.x/2)/M.tileSize)+1,math.floor(p.y/M.tileSize),
- math.floor(-p.z/M.tileSize)+1)
- end
- function PreventCollision(p0,p1)
- local t=PixelToPos(p1)
- local m=memMap[t.x*1000000+t.y*1000+t.z]
- if m=="b" then
- --calculate direction of movement by using tile positions
- local v=PixelToPos(p0)-PixelToPos(p1)
- --move back towards previous tile
- p1=p0+vec3(v.x,0,-v.z)*M.tileSize/3
- end
- return p1
- end
- --# Objects
- --Objects
- Objects={}
- JumpPad=class()
- function JumpPad:init(p,h)
- self.pos=p
- self.height=h
- table.insert(Objects,self)
- end
- function JumpPad:draw()
- end
- --# ShaderMist
- --Shaders
- Diffuse={
- v=[[
- uniform mat4 modelViewProjection;
- uniform mat4 mModel;
- uniform float ambient;
- uniform float diffuse;
- uniform vec3 lightDirection;
- attribute vec4 position;
- attribute vec4 color;
- attribute vec2 texCoord;
- attribute vec3 normal;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp float vLight;
- varying lowp vec4 vPosition;
- void main()
- {
- vTexCoord=texCoord;
- vColor=color;
- vPosition = mModel * position;
- vec4 n = normalize(mModel * vec4(normal,0.0));
- float d = clamp(dot(n.xyz, lightDirection ),0.0,1.0);
- vLight = (ambient + diffuse * d) ;
- gl_Position = modelViewProjection * position;
- }
- ]],
- f=[[
- precision highp float;
- uniform lowp sampler2D texture;
- uniform float mist;
- uniform vec4 mistColor;
- uniform vec4 cam;
- uniform float intensity;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp float vLight;
- varying lowp vec4 vPosition;
- void main()
- {
- float x=vColor.r+vColor.b*mod(vTexCoord.x,1.0);
- float y=vColor.g+vColor.a*mod(vTexCoord.y,1.0);
- lowp vec4 col = texture2D(texture, vec2(x,y));
- float f = min(1.0, distance(vPosition,cam)/mist);
- col = col * (1.0-f) * vLight + mistColor * f;
- col.a=1.0;
- gl_FragColor=col;
- }
- ]]
- }
- Surface={
- v=[[
- uniform mat4 modelViewProjection;
- uniform mat4 mModel;
- attribute vec4 position;
- attribute vec2 texCoord;
- attribute vec4 color;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp vec4 vPosition;
- void main()
- {
- vTexCoord=texCoord;
- vPosition = mModel * position;
- vColor=color;
- gl_Position = modelViewProjection * position;
- }
- ]],
- f=[[
- precision highp float;
- uniform lowp sampler2D texture;
- uniform float light;
- uniform float intensity;
- uniform float mist;
- uniform vec4 mistColor;
- uniform vec4 cam;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp vec4 vPosition;
- void main()
- {
- float x=vColor.r+vColor.b*mod(vTexCoord.x,1.0);
- float y=vColor.g+vColor.a*mod(vTexCoord.y,1.0);
- lowp vec4 col = texture2D(texture, vec2(x,y));
- float f = min(1.0, distance(vPosition,cam)/mist);
- col = col * (1.0-f) *light * intensity + mistColor * f;
- col.a=1.0;
- col.a=1.0;
- gl_FragColor=col;
- }
- ]]
- }
- --# Shaders
- --Shaders
- Diffuse={
- v=[[
- uniform mat4 modelViewProjection;
- uniform mat4 mModel;
- uniform float ambient;
- uniform float diffuse;
- uniform vec3 lightDirection;
- uniform float intensity;
- attribute vec4 position;
- attribute vec4 color;
- attribute vec2 texCoord;
- attribute vec3 normal;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp float vLight;
- void main()
- {
- vTexCoord=texCoord;
- vColor=color;
- vec4 n = normalize(mModel * vec4(normal,0.0));
- vLight = (ambient + diffuse * clamp(dot(n.xyz, lightDirection ),0.0,1.0)) * intensity ;
- gl_Position = modelViewProjection * position;
- }
- ]],
- f=[[
- precision highp float;
- uniform lowp sampler2D texture;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- varying lowp float vLight;
- void main()
- {
- lowp vec4 col = texture2D(texture, vec2(vColor.r+vColor.b*mod(vTexCoord.x,1.0),vColor.g+vColor.a*mod(vTexCoord.y,1.0))) * vLight;
- col.a=1.0;
- gl_FragColor=col;
- }
- ]]
- }
- Surface={
- v=[[
- uniform mat4 modelViewProjection;
- attribute vec4 position;
- attribute vec2 texCoord;
- attribute vec4 color;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- void main()
- {
- vTexCoord=texCoord;
- vColor=color;
- gl_Position = modelViewProjection * position;
- }
- ]],
- f=[[
- precision highp float;
- uniform lowp sampler2D texture;
- uniform float intensity;
- varying highp vec2 vTexCoord;
- varying lowp vec4 vColor;
- void main()
- {
- lowp vec4 col = texture2D(texture, vec2(vColor.r+vColor.b*mod(vTexCoord.x,1.0),vColor.g+vColor.a*mod(vTexCoord.y,1.0)))*intensity;
- col.a=1.0;
- gl_FragColor=col;
- }
- ]]
- }
- --# Utility
- --Utility
- function CullFaces(meshes,views)
- --loop through meshes provided
- local m={}
- for u=1,#meshes do
- m[u],c=mesh(),{}
- --copy vertices to new mesh
- local vv=meshes[u]:buffer("position")
- local v={}
- for i=1,meshes[u].size do v[i]=vv[i] end
- m[u].vertices=v
- --set colours with code (r=mesh id, g*255+b = face id)
- local n=0
- for i=1,meshes[u].size,3 do
- n=n+1 --face count
- local b=math.fmod(n,255)
- local g=(n-b)/255
- c[i]=color(u,g,b)
- c[i+1],c[i+2]=c[i],c[i]
- --print(u,n,g,b)
- end
- m[u].colors=c
- end
- --draw image to memory
- local img=image(WIDTH,HEIGHT)
- f={}
- for _,v in pairs(views) do
- setContext(img,true)
- perspective()
- camera(v[1],v[2],v[3],v[4],v[5],v[6])
- for i=1,#m do m[i]:draw() end
- setContext()
- --read visible faces out of image
- for i=1,WIDTH do
- for j=1,HEIGHT do
- local u,g,b,a=img:get(i,j)
- if b>0 and a==255 then
- local ff=g*255+b
- f[u]=f[u] or {}
- f[u][ff]=(f[u][ff] or 0) + 1
- end
- end
- end
- end
- for u=1,#meshes do
- local mv,mt=meshes[u]:buffer("position"),meshes[u]:buffer("texCoord")
- local mc,mn=meshes[u]:buffer("color"), meshes[u]:buffer("normal")
- local v,t,c,n={},{},{},{}
- local j=0
- for i=1,meshes[u].size,3 do
- j=j+1
- if f[u] and f[u][j] and f[u][j]>20 then
- --print(u,j,f[u][j])
- --print(mv[i]) print(mv[i+1]) print(mv[i+2])
- v[#v+1]=mv[i] v[#v+1]=mv[i+1] v[#v+1]=mv[i+2]
- if mt then t[#t+1]=mt[i] t[#t+1]=mt[i+1] t[#t+1]=mt[i+2] end
- if mc then c[#c+1]=mc[i] c[#c+1]=mc[i+1] c[#c+1]=mc[i+2] end
- if mn then n[#n+1]=mn[i] n[#n+1]=mn[i+1] n[#n+1]=mn[i+2] end
- end
- end
- meshes[u].vertices=v
- if mt then meshes[u].texCoords=t end
- if mc then meshes[u].colors=c end
- if mn then meshes[u].normals=n end
- end
- end
- --# Controls
- --Controls
- --contains Joystick controls and Tilting controls
- --1. Tilting the iPad
- --This is as easy as just returning the Gravity values, which range from -1 to +1 for both x and y
- --You may want to make all three directions incremental [self.mode in Flight tab = (1,1,1)] so you
- --can control how much the plane reacts to tilting, and so you can do 360 degree rolls without
- --dislocating your shoulders
- function Tilt()
- return vec2(Gravity.x,Gravity.y)
- end
- --2. Joystick
- JoyStick = class()
- --Note all the options you can set below. Pass them through in a named table
- function JoyStick:init(t)
- t = t or {}
- self.radius = t.radius or 100 --size of joystick on screen
- self.stick = t.stick or 30 --size of inner circle
- self.centre = t.centre or self.radius * vec2(1,1) + vec2(5,5)
- self.position = vec2(0,0) --initial position of inner circle
- self.target = vec2(0,0) --current position of inner circle (used when we interpolate movement)
- self.value = vec2(0,0)
- self.delta = vec2(0,0)
- self.mspeed = 120
- self.moving = 0
- end
- function JoyStick:draw()
- ortho()
- viewMatrix(matrix())
- pushStyle()
- fill(160, 182, 191, 50)
- stroke(118, 154, 195, 100)
- strokeWidth(1)
- ellipse(self.centre.x,self.centre.y,2*self.radius)
- fill(78, 131, 153, 50)
- ellipse(self.centre.x+self.position.x, self.centre.y+self.position.y, self.stick*2)
- popStyle()
- end
- function JoyStick:touched(t)
- if t.state == BEGAN then
- local v = vec2(t.x,t.y)
- if v:dist(self.centre)<self.radius-self.stick then
- self.touch = t.id
- end
- end
- if t.id == self.touch then
- if t.state~=ENDED then
- local v = vec2(t.x,t.y)
- if v:dist(self.centre)>self.radius-self.stick then
- v = (v - self.centre):normalize()*(self.radius - self.stick) + self.centre
- end --set x,y values for joy based on touch
- self.target=v - self.centre
- else --reset joystick to centre when touch ends
- self.target=vec2(0,0)
- self.touch = false
- end
- end
- end
- function JoyStick:update()
- local p = self.target - self.position
- if p:len() < DeltaTime * self.mspeed then
- self.position = self.target
- if not self.touch then
- if self.moving ~= 0 then
- self.moving = self.moving - 1
- end
- else
- self.moving = 2
- end
- else
- self.position = self.position + p:normalize() * DeltaTime * self.mspeed
- self.moving = 2
- end
- return self.position/(self.radius - self.stick)
- end
- function JoyStick:isMoving()
- return self.moving
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement