Last active
December 10, 2018 12:19
-
-
Save KrabCode/17536a26f9cda15ab913a03a8d071538 to your computer and use it in GitHub Desktop.
Astral, Creative Coding Discord Weekly Challenge: Stars and Astral Bodies
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
import ch.bildspur.postfx.builder.PostFX; | |
import processing.core.PApplet; | |
import processing.core.PGraphics; | |
import processing.core.PShape; | |
import processing.core.PVector; | |
import processing.opengl.PShader; | |
import java.util.ArrayList; | |
import java.util.HashMap; | |
import java.util.List; | |
@SuppressWarnings("Duplicates") | |
public class MainApp extends PApplet { | |
private SimplexNoise noiseGenerator; | |
private PostFX fx; | |
private PGraphics canvas; | |
private float bloomIntensity = 0; | |
private STAR_TYPE[] availableStarTypes = {STAR_TYPE.o, STAR_TYPE.b, STAR_TYPE.a, STAR_TYPE.f, STAR_TYPE.g, STAR_TYPE.k, STAR_TYPE.m}; | |
private PShader sunFrag, texLight; | |
private float h, w; | |
private float t; | |
private HashMap<STAR_TYPE, PVector> starColors = new HashMap<STAR_TYPE, PVector>(); | |
private Star sun; | |
private Frame smoothSphere; | |
private Frame bumpySphere; | |
private int totalFramesToAnimate = 300; //5 seconds @ 60 fps OR 10 seconds & 30 fps | |
private int captureStartFrame = 0; | |
private float sinTime = 0; | |
private float linearTime = 0; | |
public static void main(String[] args) { | |
PApplet.main("MainApp"); | |
} | |
public void settings() { | |
size(800,800, P3D); | |
// fullScreen(P3D, 1); | |
smooth(8); | |
} | |
public void setup() { | |
canvas = createGraphics(width, height, P3D); | |
noiseGenerator = new SimplexNoise(); | |
noStroke(); | |
prepareShaders(); | |
prepareShapes(); | |
prepareStarColors(); | |
regen(); | |
} | |
private void prepareShaders() { | |
fx = new PostFX(this); | |
sunFrag = loadShader("sun.frag"); | |
texLight = loadShader("pixlightx.frag", "pixlightx.vert"); | |
} | |
private void prepareShapes() { | |
smoothSphere = createSphere( 200, 0.25f); | |
bumpySphere = createSphere( 50, 5.0f); | |
} | |
private Frame createSphere(float spokes, float zscl) { | |
float r = 100; | |
shader(texLight); | |
textureMode(NORMAL); | |
noStroke(); | |
PGraphics frag = createGraphics(500,500, P2D); | |
PShape sphere = createShape(); | |
sphere.rotateX(HALF_PI); | |
sphere.rotateZ(HALF_PI); | |
for (int x = 0; x <= spokes; x++) { | |
sphere.beginShape(TRIANGLE_STRIP); | |
sphere.texture(frag); | |
for (int y = 0; y <= spokes; y++) { | |
sphere.fill(map(y, 0, spokes, 0, 255)); | |
float elev = (float) (noiseGenerator.noise(x, y) * zscl); | |
float elev1 = (float) (noiseGenerator.noise(x + 1, y) * zscl); | |
PVector v0 = getPointOnSphere(x, y, spokes, spokes, r + elev); | |
PVector v1 = getPointOnSphere(x + 1, y, spokes, spokes, r + elev1); | |
float u = map(x, 0, spokes, 0, 1); | |
float u1 = map(x + 1, 0, spokes, 0, 1); | |
float v = map(y, 0, spokes, 0, 1); | |
sphere.vertex(v0.x, v0.y, v0.z, u, v); | |
sphere.vertex(v1.x, v1.y, v1.z, u1, v); | |
} | |
sphere.endShape(); | |
} | |
return new Frame(sphere, frag, 100); | |
} | |
private PVector getPointOnSphere(float x, float y, float xMax, float yMax, float r) { | |
float s = map(x, 0, xMax, 0, TWO_PI); | |
float t = map(y, 0, yMax, 0, PI); | |
float resultX = r * cos(s) * sin(t); | |
float resultY = r * sin(s) * sin(t); | |
float resultZ = r * cos(t); | |
return new PVector(resultX, resultY, resultZ); | |
} | |
private void xyz(float size) { | |
canvas.strokeWeight(3); | |
canvas.textSize(60); | |
canvas.stroke(255, 0, 0); | |
canvas.fill(255, 0, 0); | |
canvas.line(0, 0, 0, size, 0, 0); | |
canvas.text("x", size, 0, 0); | |
canvas.stroke(0, 255, 0); | |
canvas.fill(0, 255, 0); | |
canvas.line(0, 0, 0, 0, size, 0); | |
canvas.text("y", 0, size, 0); | |
canvas.stroke(0, 0, 255); | |
canvas.fill(0, 0, 255); | |
canvas.line(0, 0, 0, 0, 0, size); | |
canvas.text("z", 0, 0, size); | |
} | |
//https://bestdoubles.files.wordpress.com/2010/06/starcolors.jpg | |
//values are in rgb and taken directly from the image using MS Paint | |
private void prepareStarColors() { | |
starColors.put(STAR_TYPE.o, new PVector(154, 175, 255)); | |
starColors.put(STAR_TYPE.b, new PVector(170, 191, 255)); | |
starColors.put(STAR_TYPE.a, new PVector(202, 216, 255)); | |
starColors.put(STAR_TYPE.f, new PVector(248, 247, 255)); | |
starColors.put(STAR_TYPE.g, new PVector(255, 243, 234)); | |
starColors.put(STAR_TYPE.k, new PVector(254, 210, 163)); | |
starColors.put(STAR_TYPE.m, new PVector(255, 204, 115)); | |
for (STAR_TYPE s : starColors.keySet()) { | |
starColors.get(s).div(255f); | |
} | |
} | |
public void keyReleased() { | |
if(key == 'r'){ | |
captureStartFrame = frameCount; | |
}else{ | |
regen(); | |
} | |
} | |
public void mouseReleased(){ | |
regen(); | |
} | |
private void regen() { | |
STAR_TYPE type = availableStarTypes[floor(random(availableStarTypes.length))]; | |
sun = new Star(type); | |
} | |
public void draw() { | |
background(0); | |
w = width; // shorter == better | |
h = height; | |
t = radians(frameCount / 6f); | |
if (frameCount > 1) { | |
canvas.background(0); | |
canvas.translate(w / 2, h / 2); | |
} | |
float baseIntensity = 6.759259f; | |
bloomIntensity = .2f * 20 * baseIntensity; | |
sun.draw(); | |
println(frameCount); | |
linearTime = frameCount * TWO_PI / totalFramesToAnimate; | |
if(captureStartFrame != 0 && frameCount < captureStartFrame + totalFramesToAnimate){ | |
saveFrame("/capture/#####.png"); | |
} | |
} | |
private List<Body> addOrbitersRecursively(Body parent, int gen) { | |
int n = 0; | |
float orbiterRmodifier = 1; | |
switch (parent.bodyType) { | |
case inner: | |
n = floor(random(0, 2)); | |
break; | |
case asteroid: | |
orbiterRmodifier = .5f; | |
break; | |
case gas: | |
n = floor(random(3, 8)); | |
orbiterRmodifier = .2f; | |
break; | |
} | |
List<Body> result = new ArrayList<>(); | |
for (int i = 0; i < n; i++) { | |
Body orbiter = new Body(); | |
orbiter.r = parent.r * .05f + random(parent.d * .1f) * orbiterRmodifier; | |
orbiter.d = parent.d * .5f + random(parent.d * .1f); | |
switch (parent.bodyType) { | |
case inner: | |
orbiter.bodyType = BODY_TYPE.asteroid; | |
break; | |
case asteroid: | |
orbiter.bodyType = BODY_TYPE.asteroid; | |
break; | |
case gas: | |
orbiter.bodyType = BODY_TYPE.inner; | |
break; | |
} | |
if (++gen < orbiter.maxGens) { | |
result.addAll(addOrbitersRecursively(orbiter, gen)); | |
} | |
result.add(orbiter); | |
} | |
return result; | |
} | |
private List<Body> generateMainPlanets(float sunMaxR) { | |
List<Body> planets = new ArrayList<>(); | |
planets.addAll(generateInnerPlanets(sunMaxR / 2f, 350)); | |
planets.addAll(generateAsteroidBelt(400, 500, 40, 300)); | |
planets.addAll(generateGasGiants(500, 1000)); | |
return planets; | |
} | |
private List<Body> generateInnerPlanets(float minD, float maxD) { | |
List<Body> planets = new ArrayList<>(); | |
int innerPlanetCount = floor(random(3, 7)); | |
float innerPlanetsStartD = minD * 2f; | |
float innerPlanetRunningD = innerPlanetsStartD; | |
float innerPlanetDstep = (maxD - innerPlanetsStartD) / innerPlanetCount; | |
float innerPlanetMinR = 10; | |
float innerPlanetMaxR = 20; | |
for (int i = 0; i < innerPlanetCount; i++) { | |
Body b = new Body(); | |
b.bodyType = BODY_TYPE.inner; | |
b.orbitable = true; | |
b.d = innerPlanetRunningD += innerPlanetDstep; | |
b.r = random(innerPlanetMinR, innerPlanetMaxR); | |
planets.add(b); | |
} | |
return planets; | |
} | |
private List<Body> generateAsteroidBelt(float minD, float maxD, int minCount, int maxCount) { | |
List<Body> asteroids = new ArrayList<>(); | |
int asteroidCount = floor(random(minCount, maxCount)); | |
float asteroidMinR = 2; | |
float asteroidMaxR = 5; | |
for (int i = 0; i < asteroidCount; i++) { | |
Body b = new Body(random(HALF_PI)); | |
b.bodyType = BODY_TYPE.asteroid; | |
b.orbitable = false; | |
b.maxGens = 1; | |
b.d = map(i, 0, asteroidCount, minD, maxD); | |
b.r = random(asteroidMinR, asteroidMaxR); | |
asteroids.add(b); | |
} | |
return asteroids; | |
} | |
private List<Body> generateGasGiants(float minD, float maxD) { | |
List<Body> planets = new ArrayList<>(); | |
int giantCount = floor(random(2f, 7f)); | |
float giantMinR = 30; | |
float giantMaxR = 50; | |
for (int i = 0; i < giantCount; i++) { | |
Body b = new Body(); | |
b.bodyType = BODY_TYPE.gas; | |
b.orbitable = true; | |
b.d = map(i, 0, giantCount, minD, maxD); | |
b.r = random(giantMinR, giantMaxR); | |
b.ring = generateAsteroidBelt(b.r * 2, b.r * random(14f), | |
floor(random(20)), floor(random(150))); | |
planets.add(b); | |
} | |
return planets; | |
} | |
@SuppressWarnings({"SuspiciousNameCombination"}) | |
private void updateShader(PShader s, PVector myColor, PVector nextColor, float flowModifierX, float flowModifierY, float r) { | |
s.set("u_resolution", r, r); | |
s.set("u_mouse", (float) mouseX, (float) mouseY); | |
s.set("u_time", radians(frameCount)); | |
s.set("u_colorA", myColor.x, myColor.y, myColor.z); | |
s.set("u_colorB", nextColor.x, nextColor.y, nextColor.z); | |
s.set("u_x_flowmodifier", flowModifierX); | |
s.set("u_y_flowmodifier", flowModifierY); //variable flowModifierY passed as param x: suspicious but ok | |
} | |
private void updateFrame(Frame frame, boolean shader) { | |
frame.canvas.beginDraw(); | |
frame.canvas.background(0); | |
if (!shader) { | |
frame.canvas.resetShader(); | |
} | |
frame.canvas.rect(0, 0, frame.canvas.width, frame.canvas.height); | |
frame.canvas.endDraw(); | |
texLight.set("texture", frame.canvas); | |
} | |
enum STAR_TYPE { | |
o, b, a, f, g, k, m | |
} | |
enum BODY_TYPE { | |
inner, asteroid, gas | |
} | |
class Frame { | |
float scl; | |
PShape shape; | |
PGraphics canvas; | |
Frame(PShape res, PGraphics canvas, float scl) { | |
this.canvas = canvas; | |
this.shape = res; | |
this.scl = scl; | |
} | |
} | |
class Body { | |
List<Body> ring; | |
PVector myColor; | |
PVector nextColor; | |
float r = 20; | |
float d = 500; | |
PVector flowModifier; | |
float startT, tMod; | |
float orbitalInclination = 0; | |
float orbitalInclinationOffset = 0; | |
float maxOrbInc = 0; | |
float typeSpdMod = 1; | |
int maxGens = 1; | |
boolean orbitable = true; | |
BODY_TYPE bodyType; | |
List<Body> orbiters = new ArrayList<Body>(); | |
@SuppressWarnings("Duplicates") | |
Body() { | |
init(); | |
} | |
Body(float maxOrbInc) { | |
this.maxOrbInc = maxOrbInc; | |
init(); | |
} | |
void init() { | |
tMod = random(.5f, 2.f); | |
startT = random(TWO_PI); | |
maxOrbInc = random(HALF_PI / 32f, HALF_PI / 4f); | |
orbitalInclination = random(-maxOrbInc, maxOrbInc); | |
orbitalInclinationOffset = random(TWO_PI); | |
flowModifier = new PVector(random(-1, 1), random(-1, 1)); | |
myColor = new PVector(random(255), random(255), random(255)); | |
nextColor = new PVector(random(255), random(255), random(255)); | |
} | |
void draw() { | |
draw(smoothSphere); | |
} | |
void draw(Frame f) { | |
canvas.pushMatrix(); | |
canvas.rotateY(orbitalInclinationOffset); | |
canvas.rotateX(orbitalInclination); | |
canvas.rotateY(startT + t * typeSpdMod); | |
canvas.translate(d, 0); | |
canvas.rotateY(t * tMod); | |
canvas.fill(255); | |
canvas.scale(r / 100); | |
canvas.shape(f.shape); | |
canvas.resetShader(); | |
if (ring != null) { | |
for (Body b : ring) { | |
b.draw(); | |
} | |
} | |
canvas.popMatrix(); | |
} | |
} | |
class Star extends Body { | |
private final float minR = 50; | |
private final float maxR = 100; | |
STAR_TYPE starType; | |
HashMap<BODY_TYPE, List<Body>> bodyGroups; | |
float darken; | |
Star(STAR_TYPE starType) { | |
this.starType = starType; | |
darken = random(.5f, 2.f); | |
r = random(minR, maxR); | |
d = 0; | |
List<Body> mainPlanets = generateMainPlanets(maxR); | |
for (Body b : mainPlanets) { | |
if (b.orbitable) { | |
switch (b.bodyType) { | |
case inner: | |
b.ring = addOrbitersRecursively(b, 0); | |
break; | |
case asteroid: | |
break; | |
case gas: | |
break; | |
} | |
} | |
} | |
orbiters.addAll(mainPlanets); | |
bodyGroups = new HashMap<>(); | |
bodyGroups.put(BODY_TYPE.inner, new ArrayList<>()); | |
bodyGroups.put(BODY_TYPE.asteroid, new ArrayList<>()); | |
bodyGroups.put(BODY_TYPE.gas, new ArrayList<>()); | |
for (Body b : orbiters) { | |
switch (b.bodyType) { | |
case inner: | |
bodyGroups.get(BODY_TYPE.inner).add(b); | |
break; | |
case asteroid: | |
bodyGroups.get(BODY_TYPE.asteroid).add(b); | |
break; | |
case gas: | |
bodyGroups.get(BODY_TYPE.gas).add(b); | |
break; | |
} | |
} | |
} | |
void draw() { | |
PVector rgb = starColors.get(starType); | |
updateShader(sunFrag, myColor, nextColor, 0, 0, 600); | |
canvas.beginDraw(); | |
canvas.background(0); | |
Frame frame = smoothSphere; | |
frame.canvas.beginDraw(); | |
frame.canvas.background(0); | |
frame.canvas.shader(sunFrag); | |
frame.canvas.rect(0, 0, frame.canvas.width, frame.canvas.height); | |
frame.canvas.endDraw(); | |
canvas.beginDraw(); | |
//glsl preview | |
// canvas.image(frame.canvas, 0, 0); | |
canvas.translate(w * .5f, h * .5f); | |
canvas.fill(0); | |
canvas.noLights(); | |
canvas.scale(r / 100f); | |
myColor = starColors.get(starType); | |
nextColor = new PVector(myColor.x - darken, myColor.y - darken, myColor.z - darken); | |
canvas.shader(texLight); | |
canvas.shape(frame.shape); | |
canvas.resetShader(); | |
for (BODY_TYPE key : bodyGroups.keySet()) { | |
canvas.pushMatrix(); | |
canvas.pointLight(rgb.x * 255f, rgb.y * 255f, rgb.z * 255f, 0, 0, 0); | |
canvas.rotateX(-HALF_PI/5f); | |
for (Body b : bodyGroups.get(key)) { | |
if (b.bodyType.equals(BODY_TYPE.gas)) { | |
updateFrame(smoothSphere, false); | |
frame = smoothSphere; | |
} else if (key.equals(BODY_TYPE.inner)) { | |
updateFrame(bumpySphere, false); | |
canvas.fill(myColor.x, myColor.y, myColor.z); | |
frame = bumpySphere; | |
} | |
b.draw(frame); | |
} | |
canvas.popMatrix(); | |
} | |
canvas.endDraw(); | |
image(canvas, 0, 0); | |
fx.render(canvas).bloom(0, floor(bloomIntensity), bloomIntensity).compose(); | |
} | |
} | |
} |
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
#ifdef GL_ES | |
precision mediump float; | |
precision mediump int; | |
#endif | |
uniform sampler2D texture; | |
varying vec4 vertColor; | |
varying vec4 vertTexCoord; | |
void main() { | |
gl_FragColor = texture2D(texture, vertTexCoord.st) * vertColor; | |
} |
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
uniform mat4 transform; | |
uniform mat4 texMatrix; | |
attribute vec4 position; | |
attribute vec4 color; | |
attribute vec2 texCoord; | |
varying vec4 vertColor; | |
varying vec4 vertTexCoord; | |
void main() { | |
gl_Position = transform * position; | |
vertColor = color; | |
vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0); | |
} |
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
public class SimplexNoise { // Simplex noise in 2D, 3D and 4D | |
// Skewing and unskewing factors for 2, 3, and 4 dimensions | |
private final double F2 = 0.5 * (Math.sqrt(3.0) - 1.0); | |
private final double G2 = (3.0 - Math.sqrt(3.0)) / 6.0; | |
private final double F3 = 1.0 / 3.0; | |
private final double G3 = 1.0 / 6.0; | |
private final double F4 = (Math.sqrt(5.0) - 1.0) / 4.0; | |
private final double G4 = (5.0 - Math.sqrt(5.0)) / 20.0; | |
private Grad grad3[] = {new Grad(1, 1, 0), new Grad(-1, 1, 0), new Grad(1, -1, 0), new Grad(-1, -1, 0), | |
new Grad(1, 0, 1), new Grad(-1, 0, 1), new Grad(1, 0, -1), new Grad(-1, 0, -1), | |
new Grad(0, 1, 1), new Grad(0, -1, 1), new Grad(0, 1, -1), new Grad(0, -1, -1)}; | |
private Grad grad4[] = {new Grad(0, 1, 1, 1), new Grad(0, 1, 1, -1), new Grad(0, 1, -1, 1), new Grad(0, 1, -1, -1), | |
new Grad(0, -1, 1, 1), new Grad(0, -1, 1, -1), new Grad(0, -1, -1, 1), new Grad(0, -1, -1, -1), | |
new Grad(1, 0, 1, 1), new Grad(1, 0, 1, -1), new Grad(1, 0, -1, 1), new Grad(1, 0, -1, -1), | |
new Grad(-1, 0, 1, 1), new Grad(-1, 0, 1, -1), new Grad(-1, 0, -1, 1), new Grad(-1, 0, -1, -1), | |
new Grad(1, 1, 0, 1), new Grad(1, 1, 0, -1), new Grad(1, -1, 0, 1), new Grad(1, -1, 0, -1), | |
new Grad(-1, 1, 0, 1), new Grad(-1, 1, 0, -1), new Grad(-1, -1, 0, 1), new Grad(-1, -1, 0, -1), | |
new Grad(1, 1, 1, 0), new Grad(1, 1, -1, 0), new Grad(1, -1, 1, 0), new Grad(1, -1, -1, 0), | |
new Grad(-1, 1, 1, 0), new Grad(-1, 1, -1, 0), new Grad(-1, -1, 1, 0), new Grad(-1, -1, -1, 0)}; | |
private short p[] = {151, 160, 137, 91, 90, 15, | |
131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, | |
190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, | |
88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, | |
77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, | |
102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, | |
135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, | |
5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, | |
223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, | |
129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, | |
251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, | |
49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, | |
138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180}; | |
// To remove the need for index wrapping, double the permutation table length | |
private short perm[] = new short[512]; | |
private short permMod12[] = new short[512]; | |
{ | |
for (int i = 0; i < 512; i++) { | |
perm[i] = p[i & 255]; | |
permMod12[i] = (short) (perm[i] % 12); | |
} | |
} | |
// This method is a *lot* faster than using (int)Math.floor(x) | |
private int fastfloor(double x) { | |
int xi = (int) x; | |
return x < xi ? xi - 1 : xi; | |
} | |
private double dot(Grad g, double x, double y) { | |
return g.x * x + g.y * y; | |
} | |
private double dot(Grad g, double x, double y, double z) { | |
return g.x * x + g.y * y + g.z * z; | |
} | |
private double dot(Grad g, double x, double y, double z, double w) { | |
return g.x * x + g.y * y + g.z * z + g.w * w; | |
} | |
// 2D simplex noise | |
public double noise(double xin, double yin) { | |
double n0, n1, n2; // Noise contributions from the three corners | |
// Skew the input space to determine which simplex cell we're in | |
double s = (xin + yin) * F2; // Hairy factor for 2D | |
int i = fastfloor(xin + s); | |
int j = fastfloor(yin + s); | |
double t = (i + j) * G2; | |
double X0 = i - t; // Unskew the cell origin back to (x,y) space | |
double Y0 = j - t; | |
double x0 = xin - X0; // The x,y distances from the cell origin | |
double y0 = yin - Y0; | |
// For the 2D case, the simplex shape is an equilateral triangle. | |
// Determine which simplex we are in. | |
int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords | |
if (x0 > y0) { | |
i1 = 1; | |
j1 = 0; | |
} // lower triangle, XY order: (0,0)->(1,0)->(1,1) | |
else { | |
i1 = 0; | |
j1 = 1; | |
} // upper triangle, YX order: (0,0)->(0,1)->(1,1) | |
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and | |
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where | |
// c = (3-sqrt(3))/6 | |
double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords | |
double y1 = y0 - j1 + G2; | |
double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords | |
double y2 = y0 - 1.0 + 2.0 * G2; | |
// Work out the hashed gradient indices of the three simplex corners | |
int ii = i & 255; | |
int jj = j & 255; | |
int gi0 = permMod12[ii + perm[jj]]; | |
int gi1 = permMod12[ii + i1 + perm[jj + j1]]; | |
int gi2 = permMod12[ii + 1 + perm[jj + 1]]; | |
// Calculate the contribution from the three corners | |
double t0 = 0.5 - x0 * x0 - y0 * y0; | |
if (t0 < 0) n0 = 0.0; | |
else { | |
t0 *= t0; | |
n0 = t0 * t0 * dot(grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient | |
} | |
double t1 = 0.5 - x1 * x1 - y1 * y1; | |
if (t1 < 0) n1 = 0.0; | |
else { | |
t1 *= t1; | |
n1 = t1 * t1 * dot(grad3[gi1], x1, y1); | |
} | |
double t2 = 0.5 - x2 * x2 - y2 * y2; | |
if (t2 < 0) n2 = 0.0; | |
else { | |
t2 *= t2; | |
n2 = t2 * t2 * dot(grad3[gi2], x2, y2); | |
} | |
// Add contributions from each corner to get the final noise value. | |
// The result is scaled to return values in the interval [-1,1]. | |
return 70.0 * (n0 + n1 + n2); | |
} | |
// 3D simplex noise | |
public double noise(double xin, double yin, double zin) { | |
double n0, n1, n2, n3; // Noise contributions from the four corners | |
// Skew the input space to determine which simplex cell we're in | |
double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D | |
int i = fastfloor(xin + s); | |
int j = fastfloor(yin + s); | |
int k = fastfloor(zin + s); | |
double t = (i + j + k) * G3; | |
double X0 = i - t; // Unskew the cell origin back to (x,y,z) space | |
double Y0 = j - t; | |
double Z0 = k - t; | |
double x0 = xin - X0; // The x,y,z distances from the cell origin | |
double y0 = yin - Y0; | |
double z0 = zin - Z0; | |
// For the 3D case, the simplex shape is a slightly irregular tetrahedron. | |
// Determine which simplex we are in. | |
int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords | |
int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords | |
if (x0 >= y0) { | |
if (y0 >= z0) { | |
i1 = 1; | |
j1 = 0; | |
k1 = 0; | |
i2 = 1; | |
j2 = 1; | |
k2 = 0; | |
} // X Y Z order | |
else if (x0 >= z0) { | |
i1 = 1; | |
j1 = 0; | |
k1 = 0; | |
i2 = 1; | |
j2 = 0; | |
k2 = 1; | |
} // X Z Y order | |
else { | |
i1 = 0; | |
j1 = 0; | |
k1 = 1; | |
i2 = 1; | |
j2 = 0; | |
k2 = 1; | |
} // Z X Y order | |
} else { // x0<y0 | |
if (y0 < z0) { | |
i1 = 0; | |
j1 = 0; | |
k1 = 1; | |
i2 = 0; | |
j2 = 1; | |
k2 = 1; | |
} // Z Y X order | |
else if (x0 < z0) { | |
i1 = 0; | |
j1 = 1; | |
k1 = 0; | |
i2 = 0; | |
j2 = 1; | |
k2 = 1; | |
} // Y Z X order | |
else { | |
i1 = 0; | |
j1 = 1; | |
k1 = 0; | |
i2 = 1; | |
j2 = 1; | |
k2 = 0; | |
} // Y X Z order | |
} | |
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), | |
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and | |
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where | |
// c = 1/6. | |
double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords | |
double y1 = y0 - j1 + G3; | |
double z1 = z0 - k1 + G3; | |
double x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords | |
double y2 = y0 - j2 + 2.0 * G3; | |
double z2 = z0 - k2 + 2.0 * G3; | |
double x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords | |
double y3 = y0 - 1.0 + 3.0 * G3; | |
double z3 = z0 - 1.0 + 3.0 * G3; | |
// Work out the hashed gradient indices of the four simplex corners | |
int ii = i & 255; | |
int jj = j & 255; | |
int kk = k & 255; | |
int gi0 = permMod12[ii + perm[jj + perm[kk]]]; | |
int gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]]; | |
int gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]]; | |
int gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]]; | |
// Calculate the contribution from the four corners | |
double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0; | |
if (t0 < 0) n0 = 0.0; | |
else { | |
t0 *= t0; | |
n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0); | |
} | |
double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1; | |
if (t1 < 0) n1 = 0.0; | |
else { | |
t1 *= t1; | |
n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1); | |
} | |
double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2; | |
if (t2 < 0) n2 = 0.0; | |
else { | |
t2 *= t2; | |
n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2); | |
} | |
double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3; | |
if (t3 < 0) n3 = 0.0; | |
else { | |
t3 *= t3; | |
n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3); | |
} | |
// Add contributions from each corner to get the final noise value. | |
// The result is scaled to stay just inside [-1,1] | |
return 32.0 * (n0 + n1 + n2 + n3); | |
} | |
// 4D simplex noise, better simplex rank ordering method 2012-03-09 | |
public double noise(double x, double y, double z, double w) { | |
double n0, n1, n2, n3, n4; // Noise contributions from the five corners | |
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in | |
double s = (x + y + z + w) * F4; // Factor for 4D skewing | |
int i = fastfloor(x + s); | |
int j = fastfloor(y + s); | |
int k = fastfloor(z + s); | |
int l = fastfloor(w + s); | |
double t = (i + j + k + l) * G4; // Factor for 4D unskewing | |
double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space | |
double Y0 = j - t; | |
double Z0 = k - t; | |
double W0 = l - t; | |
double x0 = x - X0; // The x,y,z,w distances from the cell origin | |
double y0 = y - Y0; | |
double z0 = z - Z0; | |
double w0 = w - W0; | |
// For the 4D case, the simplex is a 4D shape I won't even try to describe. | |
// To find out which of the 24 possible simplices we're in, we need to | |
// determine the magnitude ordering of x0, y0, z0 and w0. | |
// Six pair-wise comparisons are performed between each possible pair | |
// of the four coordinates, and the results are used to rank the numbers. | |
int rankx = 0; | |
int ranky = 0; | |
int rankz = 0; | |
int rankw = 0; | |
if (x0 > y0) rankx++; | |
else ranky++; | |
if (x0 > z0) rankx++; | |
else rankz++; | |
if (x0 > w0) rankx++; | |
else rankw++; | |
if (y0 > z0) ranky++; | |
else rankz++; | |
if (y0 > w0) ranky++; | |
else rankw++; | |
if (z0 > w0) rankz++; | |
else rankw++; | |
int i1, j1, k1, l1; // The integer offsets for the second simplex corner | |
int i2, j2, k2, l2; // The integer offsets for the third simplex corner | |
int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner | |
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order. | |
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w | |
// impossible. Only the 24 indices which have non-zero entries make any sense. | |
// We use a thresholding to set the coordinates in turn from the largest magnitude. | |
// Rank 3 denotes the largest coordinate. | |
i1 = rankx >= 3 ? 1 : 0; | |
j1 = ranky >= 3 ? 1 : 0; | |
k1 = rankz >= 3 ? 1 : 0; | |
l1 = rankw >= 3 ? 1 : 0; | |
// Rank 2 denotes the second largest coordinate. | |
i2 = rankx >= 2 ? 1 : 0; | |
j2 = ranky >= 2 ? 1 : 0; | |
k2 = rankz >= 2 ? 1 : 0; | |
l2 = rankw >= 2 ? 1 : 0; | |
// Rank 1 denotes the second smallest coordinate. | |
i3 = rankx >= 1 ? 1 : 0; | |
j3 = ranky >= 1 ? 1 : 0; | |
k3 = rankz >= 1 ? 1 : 0; | |
l3 = rankw >= 1 ? 1 : 0; | |
// The fifth corner has all coordinate offsets = 1, so no need to compute that. | |
double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords | |
double y1 = y0 - j1 + G4; | |
double z1 = z0 - k1 + G4; | |
double w1 = w0 - l1 + G4; | |
double x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords | |
double y2 = y0 - j2 + 2.0 * G4; | |
double z2 = z0 - k2 + 2.0 * G4; | |
double w2 = w0 - l2 + 2.0 * G4; | |
double x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords | |
double y3 = y0 - j3 + 3.0 * G4; | |
double z3 = z0 - k3 + 3.0 * G4; | |
double w3 = w0 - l3 + 3.0 * G4; | |
double x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords | |
double y4 = y0 - 1.0 + 4.0 * G4; | |
double z4 = z0 - 1.0 + 4.0 * G4; | |
double w4 = w0 - 1.0 + 4.0 * G4; | |
// Work out the hashed gradient indices of the five simplex corners | |
int ii = i & 255; | |
int jj = j & 255; | |
int kk = k & 255; | |
int ll = l & 255; | |
int gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32; | |
int gi1 = perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32; | |
int gi2 = perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32; | |
int gi3 = perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32; | |
int gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; | |
// Calculate the contribution from the five corners | |
double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0; | |
if (t0 < 0) n0 = 0.0; | |
else { | |
t0 *= t0; | |
n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0); | |
} | |
double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1; | |
if (t1 < 0) n1 = 0.0; | |
else { | |
t1 *= t1; | |
n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1); | |
} | |
double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2; | |
if (t2 < 0) n2 = 0.0; | |
else { | |
t2 *= t2; | |
n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2); | |
} | |
double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3; | |
if (t3 < 0) n3 = 0.0; | |
else { | |
t3 *= t3; | |
n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3); | |
} | |
double t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4; | |
if (t4 < 0) n4 = 0.0; | |
else { | |
t4 *= t4; | |
n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4); | |
} | |
// Sum up and scale the result to cover the range [-1,1] | |
return 27.0 * (n0 + n1 + n2 + n3 + n4); | |
} | |
// Inner class to speed upp gradient computations | |
// (array access is a lot slower than member access) | |
private class Grad { | |
double x, y, z, w; | |
Grad(double x, double y, double z) { | |
this.x = x; | |
this.y = y; | |
this.z = z; | |
} | |
Grad(double x, double y, double z, double w) { | |
this.x = x; | |
this.y = y; | |
this.z = z; | |
this.w = w; | |
} | |
} | |
} |
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
#ifdef GL_ES | |
precision mediump float; | |
precision mediump int; | |
#endif | |
uniform vec2 u_resolution; | |
uniform vec2 u_mouse; | |
uniform float u_time; | |
uniform int u_type; | |
uniform vec3 u_colorA; | |
uniform vec3 u_colorB; | |
float map(float x, float a1, float a2, float b1, float b2){ | |
return b1 + (b2-b1) * (x-a1) / (a2-a1); | |
} | |
vec3 rgb( in vec3 c ){ | |
vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0), 6.0)-3.0)-1.0, 0.0, 1.0 ); | |
rgb = rgb*rgb*(3.0-2.0*rgb); return c.z * mix(vec3(1.0), rgb, c.y); | |
} | |
vec3 random3(vec3 c) { | |
float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0))); | |
vec3 r; | |
r.z = fract(512.0*j); | |
j *= .125; | |
r.x = fract(512.0*j); | |
j *= .125; | |
r.y = fract(512.0*j); | |
return r-0.5; | |
} | |
const float F3 = 0.3333333; | |
const float G3 = 0.1666667; | |
float snoise(vec3 p) { | |
vec3 s = floor(p + dot(p, vec3(F3))); | |
vec3 x = p - s + dot(s, vec3(G3)); | |
vec3 e = step(vec3(0.0), x - x.yzx); | |
vec3 i1 = e*(1.0 - e.zxy); | |
vec3 i2 = 1.0 - e.zxy*(1.0 - e); | |
vec3 x1 = x - i1 + G3; | |
vec3 x2 = x - i2 + 2.0*G3; | |
vec3 x3 = x - 1.0 + 3.0*G3; | |
vec4 w, d; | |
w.x = dot(x, x); | |
w.y = dot(x1, x1); | |
w.z = dot(x2, x2); | |
w.w = dot(x3, x3); | |
w = max(0.6 - w, 0.0); | |
d.x = dot(random3(s), x); | |
d.y = dot(random3(s + i1), x1); | |
d.z = dot(random3(s + i2), x2); | |
d.w = dot(random3(s + 1.0), x3); | |
w *= w; | |
w *= w; | |
d *= w; | |
return dot(d, vec4(52.0)); | |
} | |
void main() { | |
//krab code from now on | |
float t = u_time; | |
vec2 uv = gl_FragCoord.xy / u_resolution.xy; | |
vec2 c = vec2(.5,.5); | |
float scl =100.5; | |
float xn = scl*uv.x; | |
float yn = scl*uv.y; | |
float n = snoise(vec3(xn, yn, t*.8)); | |
float pct = n; | |
gl_FragColor = vec4(mix(u_colorA, u_colorB, pct), 1.); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
https://i.imgur.com/Q3CyIfs.mp4