Inigo Quilez

It's 12 years old now, but I am still extremely impressed by this 64k intro https://geidav.wordpress.com/2013/04/14/making-of-turtles-all-the-way-… and also by this 4k intro https://www.youtube.com/watch?v=_YWMGuh15nE :) And overall this website is extremely interesting with tutorials and code and great explanations https://iquilezles.org/

Also, the Inigo Quilez website is a great reference: https://iquilezles.org/ He is essentially the god of shaders effects like this. He is the one who made Shadertoy, the non code-golfed version of the cloud effect, and the second video you linked, among many other things.

Have to mention https://www.shadertoy.com/browse here, by the brilliant Inigo Quilez https://iquilezles.org/

It's all done with shaders. A good starting point is https://thebookofshaders.com/. You can learn a lot from people's examples on https://www.shadertoy.com/. Another amazing resource is iq's website at https://iquilezles.org/. Something to note - it's all math. Changing other people's code and implementing things other people have devised is quite straightforward, but making new styles requires a good understanding of some relatively complex math topics. I'm not saying that to put anyone off - the opposite in fact. If your math isn't great or you're a bit scared of it then learning shader coding is a brilliant way to improve.

The simplicity is also why the demoscene has made extensive use of them (see the https://iquilezles.org/ site for some great examples) --- very complex scenes can be described in a tiny amount of space.

I have a few articles on my blog (and will be adding more related to the Procedural GL JS) library: www.pheelicks.com I would also very much recommend: - https://webglfundamentals.org - https://www.iquilezles.org - https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p… - Reading the code on shadertoy.com shaders & THREE.js examples

In this intro and in almost every modern 4kB intro, the graphics are made in a shader. To play with shaders, I'd recommend you to look at https://www.shadertoy.com/. Check also Inigo Quilez's website (https://www.iquilezles.org/), it has a lot of fascinating content.

And this happens regularly! I know of experts in programming languages[0], compression[1], graphics[2, 3], and computational geometry[3] who all have sites that both have excellent content, and look fairly awful. [0]: http://piumarta.com/index.html [1]: http://cbloom.com/ [2]: http://iquilezles.org/ (okay, this one doesn't look that bad in retrospect) [3]: http://paulbourke.net/

For geometry, start with high-school algebra and coordinate geometry, and learn how to put the two together: equations representing geometry. By which I mean, being able to write down equations for geometric objects and manipulate the equations to get them into different useful forms, and to compute useful things. A first example would be studying different ways of writing down equations for the line [1], and then learn how each of the forms relate, how to use algebra to move between them, and what each for is useful for. For example finding the intersection of two lines involves simultaneously solving for (x,y) that satisfy both equations, and there's a particular form that is best suited to that. Another form is better if you want to "move along a line" say, parameterised by time. One form might be best for GPU rendering. Once you're comfortable with algebraic expressions for lines, then you can move on to the more complex curves that you listed -- the equations for these curves can be manipulated in analogous ways. EDIT: importantly you want to learn not how to "plug and chug" numbers, but instead how to use these equations in code: e.g. how would you use the equations to write code to draw a line/curve, and how to derive functions to intersect curves, connect curves at tangents, etc. There's more to it than that of course. For example working out equations for tangents to curves will become important. But start with the above. You mention de casteljau algorithm, I am…

I didn't take your post as criticism, but rather a spark, or conversation starter, to think about self-imposed limits in art via tools or physical handicaps. I had immediately thought of the demoscene, especially Inigo Quilez [1], and his creation Shadertoy [2]. It is amazing to see what people create with these tools. Thanks for the link on 'first-order jails'. I thought I had the gist of it, until I read your link. I especially like the back and forth about higher order vs. first order re: Haskell and graphical user interfaces. I am curious how it applies to Praxis, which has a node editor, but you can hop into the code which is in Java. It is built from the ground up for distributed, non-glitch livecoding. I am an experimenter, and although I fancy myself reading about logic and computing, I am only passingly familiar with it WRT your reference. I learn a lot about it from my studies with Shen [3], and recently Idris. [4] Extempore, and its programmng language xtlang, are driven by livecoding needs, but it is basically a general systems programming language at this point. I believe Andrew started with S7 scheme like CM (Common Music) did. The original creator, Andrew Sorensen, and Ben Swift who works on it too, are courting, or are being courted by the HPC world. The need to have a language that could handle time well, or 'temporal recursion' for music creation, lends itself well to HPC concerns. Xtlang is fast. C fast. It uses LLVM in the back. Blender3D has a nice…

Inigo Quilez's (of demoscene fame, highly talented graphics engineer) blog is one of my favorites: https://iquilezles.org/blog/ It's a time capsule from that era.

https://iquilezles.org/articles/ Also recommend this as a resource, immensely useful and full of examples.

When I want to show people what an intro is and tell them a bit about the demoscene, I usually show them the intro Elevated, which won the PC 4k compo at Breakpoint 2009. For me it really shows the talent of Iq and the other people who created it. It’s truly amazing what can be done in just 4 kilobyte! Elevated by Rgba & TBC: https://www.youtube.com/watch?v=jB0vBmiTr6o Iq's slides on the Elevated intro: https://iquilezles.org/articles/function2009/function2009.pdf Sourcecode: https://files.scene.org/view/resources/code/sources/rgba_tbc_elevated_…

https://iquilezles.org/ is a legend, see the articles and video tutorials. Aside from shadertoy I use https://glslsandbox.com/ (for some reason it has https errors now). It's the same concept and it has a lot of submissions that are more basic than shardertoy where you can easily change lines and see what happens. My intuition for these kind of shaders: They are just pure functions mapping an x,y coordinate to a color (optionally making use of time and cursor position). From this you can derive anything, like drawing a circle by choosing black or white depending on the distance from the center. There is a lot of intuition to gain and it's fun playing around, because as long as it compiles you will see something and you are likely to be surprised about what you accidentally made. Very rewarding.

Inigo Quilez (who is basically the CEO of SDFs in my book) has a page on this: https://iquilezles.org/articles/interiordistance/. The goal isn't boolean operations over distances themselves, because as you point out that makes no sense. What you often want though is boolean operations over the surfaces the functions are returning the distance to. For example, you have one function that gives the distance to the surface of a sphere, and another that gives the distance to the surface of a cube, and you want to AND them, to get a function that gives you the distance to whichever surface is closer. That explanation probably doesn't make any sense, so just check out the page I linked which has some great visualizations.

You can represent arbitrary shapes through the composition of SDFs: https://iquilezles.org/articles/distfunctions/ These can be treated as parameterised nodes in a tree, similar to what's happening here. It follows that there may be a possible adaptation of this to SDF composition, such that you can give it a shape and have it produce the SDF nodes + composition required to produce that shape. Most existing approaches to SDFs with NNs have the NN itself take on the role of the SDF (i.e. given a point, it predicts the distance), so there's a compelling opportunity here to build a system that can produce spatial representations from existing imagery without NN inference at render-time. I imagine adding the third dimension to the problem makes it much harder, though! I'll have to give the paper a read to determine how coupled to 2D their current approach is.

Nice! And very snappy, even on my phone. You probably know https://www.shadertoy.com/ already, but if not, prepare to have your mind blown. Many shaders there use Signed Distance Fields to draw intricate 3D geometry within the fragment shader. If you find that interesting, check out Inigo Quilez's excellent tutorial series: https://iquilezles.org/articles/raymarchingdf/

The same author also has some great references for SDF primitives to learn from: https://iquilezles.org/articles/distfunctions/ An example of how different thinking in SDF is: in classic modeling, you define a 3D sphere mesh using a bunch of 3D coordinates (vertices), grouped into triangles for the surface. Therefore you need more vertices to make the sphere appear smoother. On the other hand with SDF, you have a function that takes an arbitrary 3D coordinate and returns whether the coordinate is inside the sphere or not (easily done by comparing the distance from the center), meaning the smoothness of the sphere is already the maximum it can be.

IQ= Inigo Quilez. His work is a good entry point. https://iquilezles.org/

This is a beautifully written article. Excellent job! I have seen some of Inigo Quilez tutorials on this subject [1] but I feel like this is a much better introduction for those of use without too much interest in learning GLSL :-p. On the other hand, Quilez's tutorials are amazing and show what can be accomplished with this technique! 1: https://iquilezles.org/live/

Great write up. If anyone wants to explore SDFs more, check out Inigo Quilez - he's a master of this stuff and a great explainer. Painting a Character with Maths: https://www.youtube.com/watch?v=8--5LwHRhjk And plenty more on his website in article form: https://iquilezles.org/articles/ Finally, Shadertoy, a graphics shader playground where you can see (and try!) a lot of this kind of stuff: https://www.shadertoy.com/

I don't think so. It is clearly raymarching Signed Distance Fields, and doing so in realtime is quite slow. Even if you use proper acceleration structures, for every pixel you have to compute the distance to the closest primitive in the scene, and shade it. For a bunch of primitives using simple materials it is no problem even on a potato GPU, but as your scene gets more complex, the performance goes down, quickly. It is a beautiful and elegant technique, but it has its downsides. If you are interested in going deeper, Inigo Quilez (https://iquilezles.org/) has a lot of articles and code explaining how it works. I would start from https://iquilezles.org/articles/raymarchingdf/

That was fun. I love how the AI is both very simple but also creates interesting group movements (especially in "zombie modes"). Cosmetic enhancement: the ground plane looks really blurry half-way to the horizon. I can even see it in the README screenshot :D Looks to me like a textbook use case for anisotropic filtering, which should be a simple setting in the library you're using: https://en.wikipedia.org/wiki/Anisotropic_filtering Or if you're feeling hardcore, write a shader for the ground plane: https://iquilezles.org/articles/filterableprocedurals

the URL should have been https://iquilezles.org/articles/texturerepetition but this is indeed a great resource

Book of shaders is a good intro, and a nice complement to Inigo Quilez's https://iquilezles.org/ tutorials. While it has not been updated in a while, Patricio is responsive on GitHub :)

The creator's homepage is a treasure trove https://iquilezles.org/

If with "this beast" you mean Inigo Quilez, he worked at Pixar for a while, made shadertoy, and teaches the world maths via shadertoy, his own website and his yt channel. So he's doing pretty well I'd say [0] https://www.shadertoy.com/ [1] https://iquilezles.org/ [2] https://www.youtube.com/c/InigoQuilez/videos

Thankfully for the graphics the very person who did the graphics in this Elevated demo is very generous with their time. Inigo Quilez has many instructional videos on his channel in how to code procedural graphics from the very beginner to the advanced. I link a couple of examples. You can watch the more advanced video even as a beginner but trying yourself is easier at the beginner level. Beginner. https://youtu.be/0ifChJ0nJfM Advanced. https://youtu.be/BFld4EBO2RE Website. https://iquilezles.org/

Absolutely and without question. I’d argue he surpasses the normal meanings behind 10x, and is one of the super-rare people up in the stratosphere. Not because of the code itself (though his combination of math, code, and art skills are 10x on their own), but more because of his goals and it’s effects on other people. Inigo Quilez is one of the most famous demo scene programmers, one of the authors of ShaderToy, has one of the best sets of graphics programming articles on the net (https://iquilezles.org/articles/) and he has been focused on sharing ideas and getting other people to share ideas. His level of knowledge and code influence on other people, if you tried to measure it, which you can’t, but it would be more than thousands of times more productive than a single programmer.

With two arbitrary faces on the same axis (say z), at locations z1 and z2 and the shape of each face being represented by the functions a(x,y) and b(x,y), you can get a loft SDF L(x,y,z) between a and b by the following math (this is not correct syntax for any tool I know but should make it clear what's happening): if(z<z1) L=a(x,y) elif(z>z2) L=b(x,y) else L=((z-z1)/(z2-z1))*a(x,y)+((z2-z)/(z2-z1))*b(x,y) For way way more info, you might like https://iquilezles.org/www/articles/distfunctions/distfunctions.htm