Created
January 11, 2014 17:29
-
-
Save tnlogy/8373920 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
--# Main | |
-- Terrain | |
function setup() | |
displayMode(FULLSCREEN) | |
forward, right, up = vec3(0,0,1), vec3(-1,0,0), vec3(0,1,0) | |
t = Terrain() | |
A = 0 | |
end | |
function draw() | |
background(40, 40, 50) | |
perspective(45, WIDTH/HEIGHT, .1, 500000) | |
local m = matrix() | |
:rotate(RotationRate.z, forward.x,forward.y,forward.z) | |
:rotate(-RotationRate.x, right.x,right.y,right.z) | |
:rotate(-RotationRate.y, up.x,up.y,up.z) | |
forward, right, up = mult(m,forward),mult(m,right),mult(m,up) | |
camera(0,0,0, forward.x,forward.y,forward.z, up.x, up.y, up.z) | |
rotate(A,0,1,0) | |
translate(0,-1000,0) | |
rotate(-90,1,0,0) | |
t:draw() | |
end | |
function mult(m, v) -- matrix multiplication | |
return vec3( | |
m[1]*v.x+m[2]*v.y+m[3]*v.z, | |
m[5]*v.x+m[6]*v.y+m[7]*v.z, | |
m[9]*v.x+m[10]*v.y+m[11]*v.z | |
) | |
end | |
function touched(touch) | |
if touch.state == MOVING then | |
A = A + touch.deltaX*.2 | |
end | |
end | |
--# Terrain | |
Terrain = class() | |
function Terrain:init(x) | |
local d,s = 1000,100 | |
self.m = mesh() | |
for y=-s,s do | |
for x=-s,s do | |
self.m:addRect(x*d,y*d,d,d) | |
end | |
end | |
self.m.texture = readImage("Cargo Bot:Crate Yellow 1") | |
self.m.shader = S | |
end | |
function Terrain:draw() | |
self.m:draw() | |
end | |
--# Perlin | |
Perlin = [[ | |
// | |
// Description : Array and textureless GLSL 2D simplex noise function. | |
// Author : Ian McEwan, Ashima Arts. | |
// Maintainer : ijm | |
// Lastmod : 20110822 (ijm) | |
// License : Copyright (C) 2011 Ashima Arts. All rights reserved. | |
// Distributed under the MIT License. See LICENSE file. | |
// https://github.com/ashima/webgl-noise | |
// | |
vec3 mod289(vec3 x) { | |
return x - floor(x * (1.0 / 289.0)) * 289.0; | |
} | |
vec2 mod289(vec2 x) { | |
return x - floor(x * (1.0 / 289.0)) * 289.0; | |
} | |
vec3 permute(vec3 x) { | |
return mod289(((x*34.0)+1.0)*x); | |
} | |
float snoise(vec2 v) | |
{ | |
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0 | |
0.366025403784439, // 0.5*(sqrt(3.0)-1.0) | |
-0.577350269189626, // -1.0 + 2.0 * C.x | |
0.024390243902439); // 1.0 / 41.0 | |
// First corner | |
vec2 i = floor(v + dot(v, C.yy) ); | |
vec2 x0 = v - i + dot(i, C.xx); | |
// Other corners | |
vec2 i1; | |
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0 | |
//i1.y = 1.0 - i1.x; | |
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); | |
// x0 = x0 - 0.0 + 0.0 * C.xx ; | |
// x1 = x0 - i1 + 1.0 * C.xx ; | |
// x2 = x0 - 1.0 + 2.0 * C.xx ; | |
vec4 x12 = x0.xyxy + C.xxzz; | |
x12.xy -= i1; | |
// Permutations | |
i = mod289(i); // Avoid truncation effects in permutation | |
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) | |
+ i.x + vec3(0.0, i1.x, 1.0 )); | |
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); | |
m = m*m ; | |
m = m*m ; | |
// Gradients: 41 points uniformly over a line, mapped onto a diamond. | |
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287) | |
vec3 x = 2.0 * fract(p * C.www) - 1.0; | |
vec3 h = abs(x) - 0.5; | |
vec3 ox = floor(x + 0.5); | |
vec3 a0 = x - ox; | |
// Normalise gradients implicitly by scaling m | |
// Approximation of: m *= inversesqrt( a0*a0 + h*h ); | |
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); | |
// Compute final noise value at P | |
vec3 g; | |
g.x = a0.x * x0.x + h.x * x0.y; | |
g.yz = a0.yz * x12.xz + h.yz * x12.yw; | |
return 130.0 * dot(m, g); | |
} | |
]] | |
--# Shader | |
S = shader(Perlin .. [[ | |
uniform mat4 modelViewProjection; | |
attribute vec4 position; | |
attribute vec4 color; | |
attribute vec2 texCoord; | |
uniform vec3 pos; | |
varying lowp vec4 vColor; | |
varying highp vec2 vTexCoord; | |
void main() { | |
vColor = color; | |
vTexCoord = texCoord; | |
vec4 p = position; | |
p.z = p.z + snoise(p.xy*.001)*20. + | |
snoise((p.xy-vec2(1.,1.))*.0001)*1000. + | |
snoise((p.xy-vec2(1.,1.))*.00002)*5000.; | |
gl_Position = modelViewProjection * p; | |
} | |
]], [[ | |
uniform lowp sampler2D texture; | |
varying lowp vec4 vColor; | |
varying highp vec2 vTexCoord; | |
void main() { | |
lowp vec4 res = texture2D(texture, vTexCoord); | |
gl_FragColor = res * vColor; | |
} | |
]]) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment