Placeholder Image

Subtitles section Play video

  • - Hello! Now, this video has been a long time coming,

  • because let me tell you something:

  • I've been living in the past.

  • I've been living in 1983 my whole life,

  • I mean, I didn't live in 1983 for ten years of my life,

  • then I actually lived in 1983, and then the years

  • went on, but since then, or at least

  • for the recent times in those--

  • making those coding training videos about Perlin Noise,

  • I was living in 1983, '83 all on,

  • and I sort of knew that but I never really bothered

  • to look into it, I didn't want to know,

  • I didn't want to know about what's happening since 1983.

  • (laughs)

  • I, am going to update my life, right now,

  • and your life too, 'til the year 2001,

  • and actually more like the year 2014

  • and all they way to the present, because today,

  • I'm going to unpack what it means,

  • to the best of my ability, what is--

  • what is the difference between

  • the original Perlin Noise implementation of 1983,

  • something that came out in 2001, which is an updated version

  • of Perlin Noise called Simplex Noise by Ken Perlin himself,

  • and some open-source implementations

  • that have been made more recently,

  • notably by Kurt Spencer called Open Simplex Noise.

  • So, (chuckles) a lot of stuff to cover here, this video

  • will be approximately 71 hours and 32 minutes long,

  • I hope you enjoy it.

  • 1983, the original Perlin noise,

  • a type of what's known as gradient noise,

  • was developed by Ken Perlin in 1983,

  • um, Ken Perlin won an Academy award for this work.

  • It is the-- the algorithm that Ken Perlin invented in 1983

  • forms the basis for the source code,

  • the implementation that's in processing itself

  • and all these videos I've made about Perlin noise.

  • Where I first learned about, uh,

  • how the Perlin noise algorithm actually worked was from

  • an article written by Hugo Alias.

  • This page is no longer on the internet,

  • but you can find it through web.archive.org.

  • This is a wonderful introduction, noise functions,

  • talks about, uh, random sampling, interpolation,

  • amplitude and frequency, octaves,

  • and looks at this kind of gradient-smoothing process

  • that happens to create Perlin noise and explains

  • why you get these sort-of patterns.

  • How all this stuff works--

  • there's actually even imputation.

  • So. But I am not going to go through this today.

  • Um, I will point you to the idea of gradient noise.

  • This is a key idea, because the idea of Perlin noise

  • is to smooth gradients, in perhaps what-

  • well let's say we'll consider here two-dimensional space,

  • to smooth gradients within a two-dimensional space.

  • Squares on a grid,

  • this is how we usually think of a 2D space.

  • The reason why I'm highlighting this is because

  • this idea of how this space is oriented,

  • the geometry of this space is the key distinction

  • between classic, (chuckles) what I like to call,

  • classic Perlin noise and Simplex noise.

  • Alright, so we'll come back to that.

  • Next stop on my, uh, Wikipedia Tour, (laughs)

  • is the page for Simplex noise.

  • So Simplex noise is an algorithm for constructing

  • n-dimensional noise. It's comparable to Perlin noise

  • created by Ken Perlin himself.

  • But the key element here is fewer directional artifacts.

  • So what do I mean by directional artifacts?

  • Maybe you've noticed this in some of the videos that

  • I've done before. Let me pull up this processing sketch.

  • Look at this. Does it feel like it has this--

  • this is--

  • um, two--

  • I'm visualizing two-dimensional noise using a

  • third-dimension of noise as slices of animation.

  • Do you feel this, like, kind of bouncing,

  • like it's kind of like, herky-jerky?

  • Classic Perlin noise is kind of herky-jerky,

  • it kind of gets to a point where it stops, it bounces.

  • That, the sort of visual quality of a

  • directional artifact. It doesn't feel

  • smoothly continuous over long periods of time.

  • And so this is really the innovation of Simplex noise.

  • Now the innovation has to do with, um,

  • Symplectic geometry, which is really,

  • and this is actually in an article that I'll refer to, but

  • a Simplex grid looks like this.

  • So the core innovation is the idea that

  • instead of smoothing the noise,

  • calculating these gradients over a

  • square grid, a rectangular grid,

  • a tiled system of equilateral triangles,

  • and there's lots of variations of this.

  • And this also generalizes to multiple dimensions,

  • and Symplectic-- Symb-- (laughs)

  • I can't say that word, but Symplectic geometry,

  • which maybe even will be at topic for another day.

  • I do want to highlight the work of Stefan Gustavson,

  • um, who is, uh, a computer graphics researcher.

  • In particular, uh, the page of documents on Simplex noise,

  • and this PDF, which I'll scroll all the way back to the top

  • called Simplex Noise Demystified.

  • So, I've read this (stifled laugh) on the subway home

  • last night, and on the subway to work this morning,

  • (chuckles) um, and, so I have some picture in my mind

  • of how this works, I probably need to read it about

  • 73 times more, but um, this will give you

  • much more background into the difference between

  • classic noise, which there's a nice, uh,

  • and you can see here, this idea of these gradients,

  • and Simp-- Simplex noise, and how the tiling system works in

  • multiple dimensions. So I encourage you to check that out.

  • Now one of the oddities about Simplex noise

  • is that there's a patent for it.

  • This, if I'm correct, is the patent. Patent US6867776B2.

  • Inventor: Kenneth Perlin. You can download the PDF.

  • Uh, this was filed in 2001,

  • at the time of the invention of Simplex noise.

  • Um, and there's, uh--

  • (stutters)

  • This is an apparatus for generation an image.

  • The apparatus includes a computer.

  • The apparatus includes a display connected to the computer,

  • upon which images from the computer appear--

  • I will stop doing a dramatic reading of this patent.

  • And so, to me, I'm not a lawyer, I'm not an expert in this,

  • but it's unclear to me what it would mean to use

  • these sort of like, literal version of

  • the Simplex noise algorithm, which is described

  • in great detail here, in the patent,

  • in, say, a processing library or processing sketch

  • in an open-source environment.

  • So there is, fortunately, a post that was on Reddit that

  • I found from four years ago, from 'KdotJPG',

  • which is a post about this new version

  • of what's called Open Simplex noise.

  • So this algorithm is very similar, it's highly correlated

  • and relates to the Ken Perlin Simplex noise,

  • but there are some key differences. And this--

  • the code for this algorithm is published here,

  • on 'KdotJPG's GitHubGist "OpenSimplexNoise.java"

  • (bell rings) Java! And which means I can use this

  • in process 'cause it's Java, and if you scroll down--

  • (laughs) first you can look and be like, "Whoa!"

  • You got to love anything that has a variable named

  • 'SQUISH_CONSTANT_3D'-- muah!

  • That is a beautiful variable name.

  • Um, but what I want to do is highlight down here.

  • I looked, I looked, I looked, uh,

  • (chuckles) keep going, there's a lot of code,

  • Whoa! There's a lot of code! Oh my God!

  • Scroll, scroll, scroll!

  • Ah! Test, and then here.

  • "This is free, unencumbered software

  • released into the public domain."

  • So, I believe this is something that I can use, and

  • I'm going to use it in the context of this video.

  • Boy, that was a lot of explanation.

  • So, what does this mean?

  • I want to do another video after this one,

  • which is I just find every single piece of code I ever wrote

  • using the classic Perlin noise function,

  • and try-- do it again with Open Simplex noise.

  • But I'll just do that for one thing right now.

  • Alright, let me go here: 'Raw'.

  • Let me do a nice, big 'copy/paste'.

  • I'm going to go to processing because processing--

  • this is the sketch, I want to-- whoops!

  • I want to change this particular sketch from Perlin--

  • classic Perlin 1983 noise, the noise function

  • in the processing library; uh, AKA, gradient noise.

  • There is also something called value noise.

  • There's all these fine distinctions between them.

  • But anyway, it's easy to get confused.

  • And somebody will write a nice,

  • succinct comment that I will pin to this page that

  • has this all explained perfectly, I'm sure.

  • Um... Uh, I want to change this to use Open Simplex noise and

  • I want to examine and look at the difference in quality.

  • And by the way, what does it mean?

  • What do I mean when I say 'quality'?

  • So first of all, I'm going to re--

  • I'm not going to redo this whole description,

  • but I'm going to go down here and I'm going to say--

  • I'm going to read this part:

  • "There have been debates over the accuracy

  • "of the implementation of noise in Processing.

  • For clairification, it's an implementation

  • "of 'classic Perlin noise' from 1983,

  • "and not the newer 'simplex noise' method from 2001."

  • So why not-- I mean, processing, by the way,

  • was invented-- it started by Casey Reas and Ben Fry

  • as a project in 2001 at the same time--

  • why not update the version of Perlin noise

  • that's in the library? So I think you could

  • make a good case for-- you could make an argument for

  • both cases. But there is a different quality to the values.

  • And there is now, historically, years and years of

  • people making artworks, visual artworks and projects

  • based on the quality of the Perlin noise,

  • the noise function in processing.

  • Just say noise, I'm just going to say noise from now on.

  • (laughs)

  • And if it were to be updated, those projects

  • would suddenly maybe not look the way they were intended,

  • not look as beautiful, not look as compelling,

  • not-- not be as visually distinctive,

  • because it's not that one is better than the other.

  • I mean, there are reasons why you can say

  • Simplex noise is an improvement,

  • those artifacts, and the smoothness,

  • and the computational complexity, those types--

  • those are things that had changed and are updated that are

  • better, in-- in-- according to different kinds of metrics,

  • but it would make much more sense to have

  • a separate library that you could use with processing to get

  • Open Simplex noise. I mean, you could make the case--

  • and there is GitHub issue/discussion about this.

  • You could make the case that it might make sense to add

  • to processing something called noiseMode,

  • in which case, you could put in here--

  • I don't know what the terminology would be--

  • (laughs) I would put in '1983'. Put the year--

  • No, but you could put in maybe 'gradient', 'Perlin',

  • 'Simplex', 'value'. You could have Worley Noise!

  • In my research, there's--

  • look up something called "Worley", W-O-R-L-E-Y.

  • I want to really implement that noise. It looks really cool!

  • So that could be something that you could do.

  • I would say, uh, a good test case to see if

  • this makes sense to add the processing API would just be to

  • make it as a library first, where you could pick your

  • different noiseMode; and then if everybody in the world

  • is suddenly using it and it creates so much opportunity

  • and possibilities, maybe then it would make sense to

  • fold to decor. That would, at least, be my point of view.

  • I'm not speaking as an official representative

  • of processing. I'm just telling you my take on this.

  • (chuckles)

  • Alright, now--

  • (clears throat)

  • So... Let's see the difference, let's see the difference.

  • This-- this-- this-- this moment,

  • being-- living in the year 2001,

  • in 2019 has really changed my life.

  • So-- ah! One other thing: because processing is built

  • on top of Java, I can actually-- I'm going to create a tab,

  • I'm going to call it 'OpenSimplexNoise'.

  • I am going to paste in all that code,

  • and this code, because it is written as a

  • stand-alone Java class, will work just out of the box,

  • right like this, with no changes in processing.

  • It's really amazing. I could even, if I wanted to,

  • have named the tab, um,

  • 'OpenSimplexNoise.java',

  • and sometimes this is necessary

  • if there's certain features of Java that

  • the processing IED won't understand,

  • but in this case it's not necessary.

  • And I should say again 'thank you' to Etienne Jacob,

  • for showing me this and giving me lots of advice and help.

  • I mention Etienne's work in several videos so far,

  • but, um, okay. So.

  • Now, we're going to change this over.

  • The first thing that I'm going to do is

  • I am going to create an object called

  • 'OpenSimplexNoise', just call it noise.

  • I'm going to say 'noise = new OpenSimplexNoise object',

  • and I'm just going to run this to make sure

  • I'm not getting any errors. I am getting errors.

  • Oh! Weird!

  • (scoffs) Amazingly..

  • (laughs)

  • I did this yesterday! I swear I did this yesterday

  • just to test, and I didn't have to make any changes;

  • but this is one of those things:

  • you can't have static functions in a class

  • inside processing. It has to do with things

  • being internal classes, yada yada yada.

  • So, what I'm going to do-- let's try renaming this to

  • 'OpenSimplexNoise.java'.

  • I think that will, uh, fix that issue.

  • Great! So, no errors, and

  • maybe that's what I did before and I just didn't notice.

  • It's running now, it's running the current noise algorithm--

  • the noise function in processing.

  • Now, we're getting-- we're getting close.

  • What I'm going to do now is just change this,

  • comment this out; I'm going to put this in and instead,

  • what I'm going to do is I'm now going to say 'noise.eval',

  • so that noise object has an 'eval' function.

  • The 'eval' function takes one val--

  • I don't know if that-- if it's supporting

  • one dimensional noise but we can talk about

  • how you can get that. You just fix the second dimension.

  • But then I give it the arguments for 3D noise:

  • x-offset, y-offset, and z-offset;

  • and now using the library's noise function instead of

  • the built-in noise function.

  • Let's run this. I'm going to get errors.

  • Cannot convert from a double to a float,

  • so this is a little bit of funny business that

  • we're stuck with here and this is what I--

  • if turning into a processing library, I would clean this up.

  • Processing in its, uh, simplification of Java

  • has basically ignored the existence of the data-type double.

  • Double is a floating point--

  • (it's not a floating point I would say)

  • - -decimal number that has more memory,

  • more accuracy, more digits, than just floating point;

  • and so here what I need to do is do something like,

  • well I need to convert--which is called casting--

  • what comes out of the eval function as a float.

  • And then look at this!

  • Now interestingly, this looks so different!

  • Now there's a couple reasons why this looks different.

  • One, is-- look at those, look at those!

  • I don't see a single directional artifact in there.

  • Do you see any directional artifacts?

  • There are no discernible directional--

  • look at this just, like, flowing, smooth, noisey transition.

  • Okay. Now-- but it looks kind of weird,

  • and one of the reasons that it looks weird is that

  • the noise functions are generally designed to

  • give you a number between -1 and 1, the mean being 0.

  • Processing simplementations gives you a value

  • between 0 and 1 as a sort of convenience,

  • so this multiplying by 255--

  • this is why we see these vast areas

  • of the color black, because any noise value that's

  • less than 0 gets reduced to black,

  • which is kind of interesting to know.

  • Now, what I can do here--

  • and I should really take out the third dimension to

  • demonstrate this--

  • but-- so if I change this to float 'n',

  • and then I say, uh, float bright = map 'n',

  • which goes between -1, 1, to 0, 255, now--

  • Whoa! That's not what I meant to happen, but that is cool!

  • Okay, uh, this is actually a really nice but

  • accidental effect. I kind of love that I got this, but

  • I forgot that I had previously multiplied it

  • by 255 here, so that I need to take out.

  • I'm sure the chat is yelling at me about that.

  • There we go. This looks more like what you--

  • what we originally started with.

  • It's a different noise algorithm.

  • I'm visualizing it in very literal fashion,

  • in a two-dimensional space, um, and there you go.

  • Now, there's lots of ways we could

  • alter the quality of what we're getting.

  • I mean, one thing would be this increment value,

  • is really playing a big role in, um--

  • and the z-increment value is playing a big role in the

  • quality of what we're seeing.

  • Like, for example, let me make increment .1--

  • like, suddenly-- look: that's what the noise looks like.

  • Look at that! Ooh, this is really nice! Oh I love this!

  • And then, uh, I could-- the z-increment, you know,

  • if I made that really fast, then you're just seeing it

  • sort of like, changing really fast, and that--

  • that now has a lot more sort of chaotic randomness to it,

  • but ultimately this is a nice addendum.

  • Now, the quality of this has such a sort of like,

  • smoothing, graceful visual quality,

  • even that moving beyond, uh,

  • uh, just this very plain visual representation--

  • they're enormous possibilites.

  • And I would refer you to the work--

  • let me just refer you to the work of Etienne Jacob,

  • who, uh, makes all these amazing, um,

  • gifloops, uh, using Open Simplex Noise

  • and a variety of techniques--

  • all described in his blog post.

  • So now, this-- thus this ends this video,

  • which I don't think was a coding challenge at all,

  • just explaining a little bit about the background and

  • difference between the different noise algorithms;

  • and I will now do a video where I attempt to loop--

  • I will do a coding challenge where I--

  • I'm going to do two more things:

  • I'm going to do one coding challenge

  • where I attempt to do a two-dimensional noise loop

  • using four dimensions (I'll explain what that means

  • in a second), and then I think I also want to do

  • like, a speed video where I just take

  • every single thing I ever made with noise--

  • it's not going to be everything, coding-challenges wise,

  • and like change it over to Open Simplex Noise.

  • Alright? See you in those videos! Muah!

  • (bell rings)

  • (upbeat pop music)

- Hello! Now, this video has been a long time coming,

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it