Rust Programming Language Rust Linz, 25 Oct 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Workshop: Rust for Artists - Lisa Passing - Rust Linz x Coder Dojo x Ars Electronica

Description

Rust is a great programming language for creative coding, building games, implementing interactive sculptures, etc. It has been the most loved programming language in the famous Stack Overflow Survey for many years in a row. This workshop offers an introduction to Rust for artists who want to use it in their digital art. You will learn language fundamentals and discover Nannou (https://nannou.cc/), a framework for creative-coding in Rust.

Lisa is a Berlin-based creative technologist, artist, and researcher. Her main obsessions are playful interactions with computers and creative uses of civic tech and data.

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

A

A

Okay, that's perfectly fine, so that everybody can hear me and I will give it back to you. Stefan. Are we live very well, so I think we should get started. We are here in Lintz at the US Electronica festival and we have a very special guest here. uh Lisa is here and she will do a workshop with the title rust for artists and without further Ado I would like to hand the microphone to you, so you can get started.

A

You are thank you. The workshop will be, of course, not just life, it will be recorded and you can find it on the rust YouTube channel after the conference tip. So.

B

Thank you. Thank you very much, um okay, so for the camera and everybody there's also people in the room, hello, welcome it's so cool that you're here and that you're interested in the topic um so recipe for artists. um We will do a little like quick round of introduction like what is your background? What are you especially interested in um because our time is kind of limited and trust is a big big topic and art is a big big topic, um so we can kind of like see which bits and pieces we can like.

B

Maybe try out or if you say, I have no idea. I have also something prepared that we can like work on and discuss things along the way cool, um even I. Why am I standing here? Why? Why should I talk about this um I'm Lisa? First of all, hi um I'm, a creative technologist um doing this, like in a self-employed manner, for like two years now, and what does that mean? It means that I really just want to play with technology and kind of make a living off of that um with varying success.

B

I would say, but, like apple things like, like I, opened up like like electronic kids toys and like try to like play with them lots of Arduino stuff, um but also like fun, interactive web applications.

B

um I've not yet been paid to make a game. But if you want to pay me to make a game, I would love to um just putting that out. There um I've been around the rest Community since 2016-17, um which, like I, was jumping like like head in first, just like oh there's, a bus conference I submit a proposal about making games and it got accepted and I was like.

B

Oh, my God I have no idea what I'm doing um and today I think I know a little bit more than I did back then, but um let's see at least enough to like talk to people about it um and I'm. Also like super proud that last year, in November, um we put in an online conference called Western Arts, which combines these like two um two areas of my life like rust and like also art.

B

um This is a screenshot from um where I was doing a little intro talk with Kyle, who did something with pen plotters, which was like really cool, very um wrote, an entire like operating like like software, for a pen plotter and like also how to design the plots and everything it's all rust. It was really cool and these kinds of ideas, um so it looks, really cool so, like another rest, in a little bit about art, I would say- um and this is the moment where I ask you- who are you. Why are you here?

B

Maybe just like maybe say your name and kind of like where what your background is like one sentence and then what you would like to learn today? One sentence: let me start in the front.

C

A

Random image generation: okay, so like.

B

Ar AI style already or like just very simple: some credit advice: okay, yeah, okay, cool cool, so yeah, but, like you, use the word pearl and I. So you kind of know a little bit about tools: industry, okay, perfect, perfect, okay, cool! Thank you! Paul.

A

A

Boom- and you just said: what's your experiencing and I would like to.

C

Pick up credit to the Cross, because okay.

B

Cool all right, um that's perfect, that's a good mix of, and so I can kind of like try to, because I've never worked with Java, but a little bit with closure. So maybe I can like find some some similarities to draw um uh or like to to compare it to, but like a little bit of rust experience or like a lot.

B

Maybe let's see um so I will come to you for maybe like what do you think about this, um and hopefully like pick up everyone's um like where people are and like we, um we learn a bunch. Okay, um let's talk about rust since you're here, I assume you kind of know what it is um so I will keep it short, um but I do want to quickly.

B

Let's see wrestling um I want to make a point about. Why I think it's um actually a cool choice for artists um as well, so this is the Ross website and you've probably seen it, and when the website tries to make a case for rust itself. It has these things like performance, reliability and productivity, which are obviously important in a corporate environment, but I also think they are very important in an artistic environment because, like if you build an installation or if you like, have something running somewhere.

B

You want exactly these things as well um and uh when I hear stories of like people who, um who built like a um a larger thing for, uh was it a museum and they think like?

B

Oh, it had like sound components and like just like it was supposed to run for a year and they're like, uh and they were like imagining writing this in C, plus plus, it was just like it gave them nightmares so, and this is like it's an actual story of like people say like that, but then they chose rust so that they know once it compiles. It will just run as long as nobody touches anything.

B

So um this is the kind of like idea that I think is like rust is very suitable for these kinds of um yeah artistic playful things that that we can use. um Also and I think this is another very cool factor. Is that restaurants everywhere and can do a lot of cool things so from embedded? So we can like program our so arguably, the ecosystem is not quite there, but like thinking of programming, our arduinos or like Raspberry Pi's in Rust, like like reading from like physical Computing reading from from the environment.

B

um But we can also do everything we need to do, but networking we can build our apps and have them cross-compiled to resin, so they run in the browser. We can share them and we can do all of this in rust. Without like having to switch languages, we can often put them all in the same project and I think it's just eliminates a lot of overhead uh in like trying to figure out.

B

Okay here, I need this and then maybe write a note server and then like choose this front-end framework that has its own build, set up and all these things- and we can just have one thing in Rust and that's I, think- is also really cool.

B

um uh That is that a little plug, because I think rest is cool um right. So this was the the short intro part. um But since this is a workshop, this is supposed to be like Hands-On, um and this is a little checklist that you would need to like follow along.

B

um So ideally you you have rust installed uh nodding, nodding, yes, cool check. um If not, you can click here. There's the it's! It's a one-line copy paste thing from the rest language website.

B

um You would ideally have your favorite editor I would use vs code um in this Workshop, which is not what I usually use, but this is also not the laptop that I usually use so yay um and optionally um I recommend installing Rusk analyzer for a lot of like nice. Things that it gives you I can I will show you what rust analyzer gives you in a moment when we switch to the editor, but this is optional, but it's really cool um and another like plugin for cargo.

B

If you don't know what cargo is I will say so like explain it in a second as well, um but especially when you work on the sketch or like a um something where you need to do a lot of changes, something like cargo watch which, like watches your changes, can also be useful.

B

Then um I prepared a workshop Repository.

D

Let's see if I can uh here we go.

B

B

I prepared AMD. um This is really all like where you can write post questions or we can share links. um The link is packmd Dot, okay,.

B

For artists, Dash a e or is electronica 22., um and then you should see something like this uh and there's this cool thing where you can do split split view. So you also have the same same access to this uh and on the left side you can write a markdown and on the right side, then you can see the um the the rendered macron and now it also just like so ideally, I should have given you this link beforehand, but I forgot, um but I'll put the um the repository link just in here.

B

So it's there for you as well and from the repository you can just um clone repository or if you want to also just download the zip and unzip it that works too, and the important part for this is actually everything that is in code and then in Walkers.

B

um Maybe in the future. There will be more in other examples, but we go with this one. For now,.

D

B

Yeah cool, ah thank you for sharing the things um hello you're here for the workshop cool.

B

We already started.

B

Yeah, so we were going through the the setup like checking that everything's ready cool cool great, um so the maybe I write like the link later as well. If you have the workshop repository, the first thing that I want you to do is actually like: go into uh code, slash, Walkers and run cargo, build um dash, dash bin and then final, which will then download all the dependencies which takes a lot because of the framework that we use has a lot of dependencies, and so this will take a moment.

B

So I just want you to start with this, so we can like work with. um uh So we can work with that in a moment. So I keep this open for now um and then, while everybody like maybe goes through the list, uh we can maybe have a first round of questions if there's anything unclear or.

D

A

A

C

C

A

B

B

How's, the download going is the internet okay for ghosts.

D

Okay, let's see.

A

B

A

B

Takes a couple of minutes and like until everything is ready cool, but if that works like if things are like running and downloading for people, I can like go a little bit further without jumping into the code straight away.

B

um Do you have not like okay, okay, uh let's see um how did I do this before uh I just give you so I have. um Maybe this one is easier.

D

Because then I can.

D

Oh no I have trouble with internet, it seems.

B

Yeah, so this is the workshop repo, but you can also save the link to this patch. If you can see it, I was trying to like maybe copy it and.

B

That is perfect, I'm also trying to yeah. Maybe.

D

It's still links.

D

B

Oh, my computer is lagging right now. It is annoying okay,.

B

Attack MD dot, okfn.de, slash, RFA rest for Arts artists, Dash, a e RS, electronica 22. and then there's the workshop link is in the top and, like other useful links, and you can also share links there.

D

B

I'll switch back to this, maybe okay, um next uh so the first project or like the project that I want to walk. You through is like a simple um like a simple exercise and like a simple uh or useful and simple tool in the creative coding world, I would say, um and they're so-called Walkers or like random Walkers, um which is just like.

B

Basically, we kind of like draw random lines so, like there's, imagine a little Walker like a person or a robot like walking in random directions, and wherever this little like like agent, let's say, goes, um we will draw a shape or something um they come in. Various uh yeah disguises, I, would say. I put in two links into the slides. I will also um put the slides online. There's like a proper, proper link.

B

I will also put this in the notes, um but if you like, this kind of so I link these two resources, which are like very cool, creative coding resources, um one is nature of code and they also introduce Walkers like in the introduction. Chapter.

B

um Nature, of course, is a great resource for, like all kinds of creative coding um uh techniques and algorithms, uh random mug.

B

um All the examples are written or like are used processing. So, like the Java based thing, it's um it's a couple of years old, but it's like the it covers all the bases and it's really really cool. So this is the example that people that is built in um nature of code was just like a very small, like kind of like draws little like dot sales where like wherever along it goes well.

B

This is like the basis um for a lot of cool things that you can do or generative design that does not have HTTP s um and they basically updated this.

B

They use P5 so like the JavaScript version of processing- um and they do this like a little bit more advanced stuff like oh it wraps around the edges, and it has like, um creates this cool like randomized patterns um in the same way, but like the logic, is basically the same um and I thought we'd do something like this, because it's like uh small enough and we'll quickly run the um so the thing that you're building right now, if you run it, um it looks like this.

B

So the the logic is the same, but I decided to write. I. Could probably barely see it on the on the screen, maybe in on here is that we also like walk randomly, but we draw semi-transparent circles, um but we can, even so you can like uh change more I, also made it so that you can choose if it's like a square um or also just like small dots, which you can probably not see at all here now.

B

Okay, um so you can like switch between like what what we're, drawing and also create multiple Walkers um in in one in one window.

B

That's what what we're gonna do um uh and the tool that we'll be using for this is yeah I. Think right as of right now, my favorite, like rust, Library um it's called menu, and let's look at the website here um so nanu is, is an open source, creative coding framework for us?

B

um Usually people ask so what's the difference between a creative coding framework and the game, engine um and I think the the best answer to this question. I've ever heard was like our creative coding framework, accepts more inputs and offers more outputs to like various other protocols.

B

So um the people behind me are very fond of their lasers and LEDs so that you can talk to lasers. Do a little laser show. um I also know the lasers are really really expensive. This is why I don't have one, um but you can like um yeah. You can just use it as as processing or P5.

B

um You can talk like as of right now, I think it speaks needy and um open Sound control over C, and you can talk to like peripherals and they get data and like send out data um to these things.

B

um This also is very funny and like cool and fancy, uh but we will just draw today, um but I hope that you will have enough knowledge or like enough knowledge of both the new and rust, that you can, like then uh dive into the documentation and the guide and see like how you can use this for yourself and your little projects um right so I think I can actually close my things here right.

B

So this is all of the introduction and all of the slides playtime um and for this I will jump into the code.

D

No not safe. Okay, now close the store.

B

um Quick question how's the download or like the build, is finished, finished cool how's it going for you, no oh, okay. Okay. We will also do like a short break, so then be like if you're still need help you can like or like I can take a look. Then cool.

D

uh Let's loot, smaller hello, oh.

B

Hello um right um so in um within the workshop folder that I shared with you um in the code Walkers, the the Walkers folder, is basically um what came out of scaffolding. A new rust project, so I will like quickly explain a couple of things.

B

um So, if you've never started a rust project by yourself, when you install rust, it comes with its own little package manager and like not just packet manual, build tool. Everything called cargo and cargo is your best friend, because um we can do everything with it. um For example, you are already seen in the example that I shared, we said cargo run to like um run up like run our software.

B

We can also take Hardware build um various other things uh and when we say cargo, let me just do a little demo, Maybe cargo new and we call it ours- um and this is all I need to do for me to like um to have cargo scaffold, a new project. For me that comes with just the cargo tunnel and the source directory where there's a main like this- is the default binary um project setup. There's also the possibility to create a library project, but like we, we stick to the binary for now.

B

um So this is what we have or let's say in the in the workers directory, there's a little bit more um as compared to like the the really like the bass, um which is the cargo lock which will be written um once you install other dependencies.

B

You know it properly from other various package, Management systems that, once you like, install everything it will be written down in a specific file, um I added a readme and once you compile stuff and we will get the target folder where all our compiled stuff lives um cool, then one more thing before we get into the code code is I. Don't have this open actually.

D

uh I have another window.

D

Yes, I. Do this one.

B

um Because I wanted to take a look at the cargo tunnel, um so this was generated for me, um nope, don't um it's just a couple of things to notice that Tamil is maybe an unusual choice for these kinds of things. You might be more used to Json or XML or yaml or whatever. It was definitely when I started rust. The first time I had to like deal with with tomorrow as a format for these kinds of things um uh we have so we Define our packages as like our project. It has a name.

B

It is the name that I gave it in the beginning. um Version is automatically edited and then there's this key. That's called bless you um Edition, which is the 2021 Edition.

B

um Just a quick note on this is that every three years, rust kind of like makes like decides on a milestone like this, is all the features that are currently now in the language. And this is, um if you use this Edition, you kind of like assume that this is the um it's kind of like a version of rust, except that Russ decided to to never ever have uh I like to always give back what's compatible and never to like deprecate things.

B

But you kind of like need something to talk about this, a certain set of features in the language that we want to work with. So the first edition was um 2018, and now we have 2021 and then like.

B

We will get the next one later um not to talk too much about this, because I actually think it's quite boring when you just want to start with a project, but like I, think also the idea that, um once your rust project compiles it will always compile in the future, is a great promise um and something that I think a lot of like people in other language communities would be like kind of jealous of so I.

B

Think it's very cool, um and then so really just like a small edit is that I defined several of these bin um Keys here. So like several binaries that live in this project. If you don't do this, cargo will search for just the main RS, um which I then renamed to Main, which for us is just um basically the blank scaffold for a little nanu setup.

B

um There's also final, which is kind of the the thing that you that I told you to compile that just like pulls in everything um and also will be my little cheat sheet if I get lost. So we can look at final.

B

um I gave this Workshop once before, which is why you have a version that is slightly different, um which is like what we played around with in the first iteration of this Workshop and I will actually be working um in the Arts 2022 file, which is just a copy of main right now, but just like record what we end up doing here so like.

B

If we uh diverge a lot from like my original path, it will be recorded for history and will live in the repository um in the end and then last but not least, we have dependencies here. So what do we want to pull like what we want cargo triple in, and we say nanu in this version and that's it cool uh okay,.

B

I think it's time to ask you if you have questions as of right now,.

D

No, no, no okay, cool.

B

So then, um let's look at the main RS file or, as I said, I will be working in the RS 2022 file that you don't have yet, but we'll be in the repository by the end of the day. uh Let's just see what is um what is in there uh right, okay, so at the very top. So this is the the idea is mainly just like look a little bit of rust syntax. What do the things mean?

B

um Why are they there? Why are they cool? um How do we work with this and what is rust? What is nanu and what is what is Me Maybe um at this point?

B

Okay, so at the very top we have a use statement which pulls in the dependency nanu that we want to work with, so we say nanu and then we have colon colon for um namespacing uh and then the new Prelude, and then we have the Asterix or like glob everything that we have in Prelude, and we want it here, um and this is a really like a pretty good example of things in the rust world.

B

If you do with dependencies, because actually what is not or like what we can't see right now is that um rust automatically includes its own Prelude into our file. So, like there's a couple of things, we can already use um like certain types like vector types, for example, they're already included without having us having to explicitly import them, um and these are also. This is called the standard Prelude um and following these, this Prelude idea of like saying I, give you like I bundle up everything that you would probably need right away.

B

A lot of packages um also Define a Prelude and say: okay, here's the Prelude you can. You can include everything in there because we probably need it, and this is what nanu did as well. So we can a new offers us a Prelude um like with everything that we need to get going. So we include everything from here.

B

Cool uh next thing. That's interesting, maybe, is that we I Define a constant um you're, probably familiar with the with the concept. So it's a constant value, and here we see a little bit of fret syntax, which is defined uh like defining Types on things. If you come from, maybe like a dynamic language, um this, like maybe unfamiliar to you um so let's say we have I- want to define a width that will ever later use to define the um the dimensions of the window that I want to create and I gave it.

B

The the type of F32, which is a as it says here in the tooltip 32-bit floating Point type, and this actual tooltip is also something that comes from rust, analyzer, the plugin.

B

um What did I choose this number type um it because later on, the new requires me to use this so like I use it in the beginning, um but there's quite a lot of number types and rust.

B

Actually, we will see a couple later, um but there's two floating part types like the 32-bit and the 64-bit and then signed an unsigned integers in various bit sizes um and they're, usually like you, for example, 16 or u32 for the unsigned ones, and then I um uh I am the same for the for the signed ones um and because I always forget to mention that there's also um platform, specific number types um use size and eye size which we will see or will be used as indexes into areas and vectors, for example, um but we'll get to this in a second, so we have comms to Name colon type, and then we assign um a float cool, um and then we have some interesting things happening here already.

B

um I'll start with line six where it says struct model and then just empty curlies.

B

um The struct is um rest way of defining a new type, so we say like hey, you have a struct, we call it model and right now this is this model. Has no properties, there's nothing in there. It doesn't do anything. It's just like we Define this new type.

B

um Russ doesn't have the concept of like classes. So it's not. It's not object oriented um but like we, we kind of like build types, and this is everything everything evolves around this um later on. Some things might feel object, oriented to you and then there's definitely similarities, but um there is no no real object orientation, as you like know it from other languages, for example cool.

B

um So we have a struct model. uh Structs are usually written or, like start with an uppercase um uppercase letter.

B

um That is that the more interesting or even like super weird looking part, is um what comes at the top. uh It starts with with the hash and then like square brackets, and it says, derive debug.

B

um Can anyone? Does anyone know what this could mean or like people who might know it? Like can say it, but like wild guesses from people who don't know what this might be.

B

Okay, it's completely fine! um So every time we have this, like this hash, uh sometimes like hash square brackets um and now I have to think because I always mix up the names. It's called an attribute.

B

Yes, because I sometimes say it's annotation, but it's attribute then- um and this is kind of like uh our little message to the Rusk compiler saying like hey um something with whatever follows this every year and in this case we want to tell the compiler hey um I, want you to derive So like um basically generate something um for our type here, and we want to derive an implementation of something that is called debug for this model.

B

um Here's the question: what is debug and I will actually and I hope the internet works stable enough for this, introduce you to actually, let's go through the um through the pet.

D

B

Never Reliant internet is a bad idea. um Okay, uh because one of the useful links that I put in here is called rust playground, which I highly recommend you check out. If you just want to like try other things, so we will try out the thing and instead um you get a minimal like rust.

B

Playground, like literal rest playground, where you can like write a little bit of rust, evaluate it and see um if things work or like what what happens so and we have a main function and I'll just quickly, also um uh typed a little bit that we had in the um in the in our main RS, um and the idea is that we we have a model or like we have a type that we created called model and then, let's say I just want to, for example, um print um print this.

B

This is something that would look like this so like, uh like this I, think I'm always confused. um We also have to create a new. Let's say um this is very small: actually isn't it, let's make it bigger.

B

So I create a new variable, that's just like where I assigned this like empty, like an empty model thing um and then I want to print um this model, and then hopefully it didn't make any other mistakes. Okay, perfect! ah Actually, not so perfect. Let's do it like this.

B

um Yes, okay! This is the error message that I wanted to appear. um So what is happening so um this program doesn't doesn't compile um in this case it complains, um or we can see two things. First of all, the nice error messages that rust gives us. Women want to work with it and Singapore.

B

What exactly is is happening here, um so it tells us that model doesn't Implement debug, and this is a very good, um um and this leads us into the path of like how rust deals with with types and like how how we construct uh programs, basically so I, said that rust is not it's not an object-oriented language. It's more that like we, um we create types and then we kind of um Implement what is called traits so like certain functionality.

B

That is bundled under a name uh on our types so that we can kind of like pick and choose so like the I guess. The standard example in object-oriented world is, um you have an animal, and then you have like a bird and the bird has like wings and then um and and the in the beak, um and then you have like animal and then animal or like um a dog inherits from um animal and the dog is like um fur or whatever.

B

And then you have like a platypus which is uh uh traveled here in German, which is kind of like it has some traits of a bird and some traits of like a mammal uh I didn't confuse it, but like basically like something that is hard to illustrate an object-oriented like programming. If you like only have inheritance, um but in rest with the trade system, we can say. Okay, we have this animal and has like traits from certain other um from certain other types that we can like. Implement implement this.

B

So This trade system is really like, inherently uh resting, like breasts main architectural feature, I would say and where everything is a trait and like also, everything is implemented as a trade, and we can also Implement trades on our own types, and one of these traits is debug, which is something that we need to implement our type so that we can print it.

B

For example, um the first error message was a little bit different one because it says oh model doesn't Implement um another another trade called display and again so you see this one, uh send it from a display which is similar but like more like a pretty printing kind of way, which we or like I don't need right now, I'm satisfied with a different kind of formatter, which we can put in with colon question mark in this I haven't said anything about this um So within the string.

B

We can oh like within the curly, the placeholder and the curlies, and where we want to replace our value, um we can. We can say we want a different kind of formatted to be used when we print this thing and the the debug one is this one, that's the most useful one for debugging and if I want my type to um uh to be to be debuggable, I need to implement this debug trade.

B

Okay, let's sit on this for a moment. um How do we Implement a trade like what? How do we? How do we solve this? This error message um and there's a shortcut so there's a long, long version where we actually Implement manually a trade on a type.

B

We will do this later, but there's also a shortcut for all these types that have, um let's say very standard like a debug or if you have things that are you want to compare to one another or um what the other ones with this yeah several ones that I don't want to like get too deep into, but um there's like a simple and easy implementations for them so easy that we can automatically tell the compiler to please and do this for us to save us. Some manual work- and this is what the rife debug does.

B

So we say a little message to the compiler hey um for my struct or my type model here. Can you please just like auto-generate or implement this debug for me, and then it will do so, and you say hello model. Our model uh is not very, it doesn't really do anything, so we just get like the name of it. But this is the idea of what is happening here and what is derived okay, cool um I hope, you're.

B

Still following me because, like rust, is a big big language and there's a lot to cover and I hope just we we get through uh the main parts um so that you know what's happening here, finally, really cool, um we make it down to our main function. This is the main entry point into a program, as you might expect. Rust analyzer actually gives me here uh little buttons that I can click, so I can just like click here and it will open.

B

um uh It will run the thing open, a little terminal, and you can do that too, but you can also I, usually don't use this one but like just switch to a terminal to run stuff.

B

um I have okay, so this is and then we see what what our current program is doing right now. It just opens the window that is black and doesn't do anything yet, um but it's cool it works.

B

um So what is happening in Maine? What is actually going? uh What is actually going on? We have nanu and we create a new app. um This app gets a model function.

B

um This is interesting because this is more of a in a new convention and that I will talk about in a second, and then we say this app um should also update and the function it should use to update is also called update. So these are like function names um and then we say run this app, and this is all we do in Main and then the rest of the file is basically um the definitions of of uh model and update.

B

um So we have a FN model, so FBC FN is the function keyword. So this is a function that is called model. We, as we would, as we would expect, have parentheses that take parameters um a first like arguments and my first argument is called app. We see the colon, so what follows is the type definition, so what kind of type should app be? Surprisingly?

B

um It should be of type app, which is what we get um when we call the new DOT app um and interesting. Also here is the Ampersand, so we get a reference so like we don't um give over anything like the ownership um uh to this model function, but just a reference to it and what we want to get back is of type model and model is the model that we defined as our struct here at the top. So it doesn't do anything. Yet.

B

um This is an interesting. So at first, when I saw how nanu tries to um or like the the base, API, let's say of nanu.

B

um It took me a while to understand that in the end it does the same thing as processing does or P5 does or um like smaller, like 2D game engines. Do is that they have or like maybe you're familiar with it. They have a setup or a load function and then an update or a draw Loop. Sometimes you know you have update and draw, um but just like the idea that you have like something that runs once in the beginning.

B

uh Really that just like starts everything up and then some sort of loop that just like runs continuously and that does either the drawing or the computation or both and in the end um the new does the same thing. They just call it diff different things, so the naming is a little bit weird, because the naming is kind of like a model view controller adjacent naming. So they have. This, like idea of model, is supposed to be your state, um but you like to find state. It's like rest structs um and, like your your draw.

B

Loop is called View for whatever reason, um funnily enough, there's nothing that is actually called controller um but like in in their reasoning. It was like. Okay, we want to we kind of like um want to like architect our API, similarly to to like model view controller, which is like okay, um it's a choice. I was kind of like confused at first, but um you get used to it, and that's fine. So in this idea is that um mod, like the function model is what is usually like your setup or load function.

B

So it's the thing that builds everything in the beginning prepares everything and runs once so, since we can actually like choose the naming um for this one.

D

B

D

Call this well.

B

ah Set up here and the setup here like in the nanu guide in the getting started guide. um Usually this is um uh this is called Model who also like already like yeah, okay, a complaint here.

B

um But let's do this um back, so that's kind of like um where we were at before. Okay um right, I, quickly, walk through the rest of the model function, just to like know where the rest is happening um as I said, uh model is kind of like setup where we construct everything.

B

um So here we like basically say we use this app again that we get as the new app creates this hands it into the model function. So we get this from like our arguments here and then we like build it in a way that you may be used from other things. So we say you want a new window and the size of the window should be, and here comes our constant width.

B

So um actually I have to type cast here so now, I'm not sure where I need the width again and why I chose float in the top. um But here I say basically that I need um not the float value, but I need it as a u32. So I need to like convert it to now to a different number um type um and for height um I, also use width and, like analyzer, rust, analyzer testing.

B

Here, actually, this parameter is called like height, um just in case you were confused, um uh but I also use with here.

B

So we get like a rectangular like a square, a square window because I like those um also Typecast here and then we say similar to like how we call it in Maine um for the drawing function or like what they call View, and we also want to use a view function that are also called View and then I also already defined some um interactive parts that are not in the standard in the standard setup.

B

But I thought we're going to use them because they're like the most common ones- and we say like hey in our new window- I- want to listen to Mouse release events. So when we click and then release I want to like call the function, that I pulled Mouse release and if you have key pressed I want to like call a function that is called key, pressed and then similarly, there's like all kinds of other event.

B

Handlers, if you want that, you can listen to this- is very similar to um to processing and P5 how like they handle events, and the last two are just like then build this entire thing call on rep, because that's what we do here and then this is kind of like starts our um starts, our window starts or or a sketch, if you will um and then, because the the function actually needs us to return our model.

B

So like the the state, if we have one, um we we give it our empty our empty model struct, um even though it doesn't do anything because, like all the magic is already happening here, setting up the window um and like registering stuff for us cool, do we have questions until here? Yes,.

A

B

um Usually you would like so like we, we will expand our model like every kind of state that we have, and this is usually something we're like.

B

Okay, I want to have my various assets that I need to preload, um because so, basically um the model is everything that that you need that uh you later want to have access to in your update, or also in your in your event, handling things um so like usually in model you pack, everything that you need to reload into your state and then like later, you can like access it and like read from it from everywhere else, so yeah image loading fund loading. Everything would go in here.

B

um If you need it late like. If you need it later and say: oh I want to like I, don't know switch between fonts and then you have like an active fund or something. This is then something that you can override in the event handlers or in update or whatever does it answer your question cool.

A

A

E

B

um That's a very good question: I, don't actually know because I haven't used it with menu with okay, um but we can open up in the in the documentation if they actually do.

B

um But that's it's a good question. Yeah.

B

Other questions so far: okay, um I just quickly want to like go through the rest of the predefined functions that I put in there, and then we can take a small break um and then maybe, like more stuff, comes up later cool.

B

um Let's maybe go with um yeah the update function first, like actually all um all of like our interaction or active functions here, um because they're kind of like similar in in a way that there's nothing really happening right now, um but what we can do so if we look at the function signatures so like what arguments do we get and like? What do we need to return if we do need to return anything um they're quite similar, so uh every function um gets a reference to our app, so we can always access everything.

B

That's in our app, and so this is the part that nanu built and we get access to the model that we Define so like our entire State um and then, depending on what the what the function is. We also get maybe like another um like another kind of argument that we can use. So, for example, um key press gets app model and the key that is being pressed um and mouse release gets app model and the mouse button which I clicked so we can access these.

B

um An interesting thing is that you may be wondering about what is this? What is this underscore here doing in front of all the um in front of all the the parameter or like argument names, and this is also very resting, um saying that, oh, if you, um if you don't, if you want to like Define or name this argument, but you don't actually use it in the function body, you can prefix it with um the underscore to tell the compiler. Hey I will not actually use this.

B

Otherwise, the compiler will tell you hey you define something that you don't use. Why don't you remove it like? This is kind of like Rusty, like compiler gives you these hints of, like hey. You have all this stuff defined that you never use. Why don't you just remove it, but maybe like in this example like I, want to know all like my entire function. Signature um uh but I want to know the names, but I don't want the warnings, uh so in these cases I just like put underscores in front of them.

B

um An alternative way would be to use another attribute like a hash thing that you can put at the top. Where you can say: hey, um I, don't know exactly what the what the syntax is, but you can say um a compiler won't like basically deactivate compiler warnings for this kind of um for unused code or for unreachable codes like, but the compiler also knows that or the way you wrote this function, certain branches will never be reached.

B

um So like look at this look at this code. Basically, so the compiler has very very useful things for us to um to consider.

B

um Another thing that I um want to highlight here is that um app gets passed down as a as a regular reference as an immutable reference, um but model gets passed in as a mutable reference, so with Ampersand mute- and this is an interesting part where um basically, once we construct an a new app, it stays immutable throughout our program. So we can like read from it.

B

We can read the settings of the window, but we cannot um like change it again as opposed to the model, which is the the state that we defined and that we probably want to change, because we want some interactivity. We want something that's going on and we want to maybe also um yeah, probably change the the state change your model, um which brings us to The View function, which interestingly, gets um reference to app and a immutable reference like a regular reference to model.

B

So like the view function, which is just drawing, cannot actually modify our state and I think this is really cool because I've definitely had it in the past, with P5, for something when, like you're, quickly scripting down something, and it's like ah this would work, and then you realize, while you're, drawing that you kind of need a different, a different value here and then you start kind of like rewriting your your state in your in the loop that is kind of like unclean, um and then manure says like okay.

B

This is view this is just for drawing and make sure you hear through the type system that you can't actually modify. The model only modify it in places where you're actually allowed to do this, um and this is really like cool, because it forces me to actually pay attention to like where I do what um so that, like later I, still know what is going on.

B

um We also get a frame, which is the the actual image information that is then being printed or like being being displayed, um uh which has to like I, also thought it was kind of a little bit of- um let's say not ergonomic to me, but it actually has to do with the way that the the graphics pipeline, like the the dependencies and like the this, is handled in Rust. So this um might actually change, maybe a little bit.

B

Maybe they also keep it um because they're currently rewriting or like updating part of the the rendering process of in a new app. Where, um like the idea or the goal, is that you can take it you're in a new sketch and compile it to a bosom Target so that it runs in the browser, so you can like either have it as a desktop app or just like in the browser, but this is not yet. This is ongoing. This is not yet done.

B

um This has to do with, like the um the switch from I. Don't know what they used before, but they know switching to wgp GPU like is it called that I think so um so, like basically, um the underlying uh Foundation that is used for graphics, um Graphics, processing and drawing um which is a huge deal because, like I, don't I, don't really know where this starts and ends.

B

um I just read the GitHub tickets, um but this this might change. um The important part is, though, that in view we get this little bit of a little scaffold for like actually drawing so this is. We saw the black rectangle in the in the window, and this is actually something I that is already defined.

B

um We get from from the apps gives us a straw um a function and then, from this draw yeah it's actually. It returns um uh the the draw type where we have uh various functions that are that we are probably familiar with something like background or color or um uh yeah.

B

We will see like ellipses or like rectangles, that come from this like drum draw type, um we also have various colors defined as constants, so this can also be red, there's also like different ways to Define colors, which we see later, but in the end, so this is the most important line is that we say draw, we put it into a frame and then this Frame um basically gets handled to like the the actual rendering, um so that this is what makes the the image appear um and call and rep on that.

B

um This is the walkthrough of basically the base sketch. That is here. um If you look at, if you go to the new website and find the guide.

B

D

B

All right, just a second: this is the new guide. This is kind of like um the uh welcome Hello World.

B

um How do I get started uh guide um and they have uh under tutorials one three like point three tutorials and 3.1 is um anatomy of a of a new app and there we have the, which is basically going through like what I explained in the base um base template that I used for our sketches.

B

Basically also this one plus um uh already some functions for key, pressed and and mouse pressed, but this is kind of like um we can also see that they used event for uh okay, um that's what I get for going of script.

B

um So what I used is the the direct eventenders of key pressed and mouse pressed, um but what you can also do is just call the more General event which fires when any kind of event occurs.

B

um So this is like more general, which might be interesting to just see um well I, guess in a more exploratory way of like oh, what happens when I press this or like scroll here or like what kinds of events happen and but if you already know, oh I just want to listen for a certain event. I think it's much more readable if you just go for that event handler, um but just know that, like event also exists and there's lots of events um that we can look at or use.

B

um Okay with that being said, um uh I think I will just leave this here and like run. No, let's run.

B

The RS binary because I just changed the color to Red. Let's see if that worked, um and then we take a short like a 10 minute break I would say or 15 minutes. How do you feel then?

B

Okay, yeah, that's the 10 minutes, um and then we can get into actually coding, The Walker.

B

B

Okay, this takes a long time. um This is called a break, maybe by the end of the break. My computer decided to actually compile this. um So let's meet at 10 like at 10, past two um and then go on by then.

D

B

We are back again welcome. um You can already see that. Finally, at some point, uh the sketch compiled with the background uh being a red now so that worked that's cool, and now we can finally get to uh create a walker like work with our Walker here. I would quickly close this again um and then, let's jump into the code, so I will also change this. Maybe back.

B

um Maybe that's not too black, because it's not really that um doesn't really work that well on the screen here, um but let's go with white, so my big question is: um where should we start uh with the idea being that we want to have something that kind of randomly walks around our our like sketch our frame or window um and then like Draw Something, wherever it wherever it lands? Next, um how would you proceed or like what would be your first, your first step.

B

Get a random source: okay,.

C

B

That's a good idea. um That also brings up a very, very good point that rust doesn't come with a um random number generator per default, uh so this is kind of annoying. um Let's do that. um This is also like very educational, because we can check out um a really really important website uh called uh crates. Oh.

B

So we know cargo is our package manager and it pulls independencies for us and compiles things for us, um but these packages are called crates in the rust ecosystem. So it's just like kind of like a package. It's a crate um and we can search for things if you want to do something like uh just let's just search for random and let's see what happens here.

B

um So it's random and I really hope that there's also.

B

Just Rand no hmm yeah, so I I thought this was a little confusing actually because, like the usually the go-to default, create for random numbers is brand, um but if a person, that's just searching for random, would not actually see this first. So now now you know uh search for Rand and not random, um and we can quickly click click here in the little clipboard and then we can go uh uh into our cargo Tamil and this is a dependency nice.

B

Okay. This can also like actually teach us a lot of other cool things. um Let's go maybe to the home page and hope that there is a little, because Brent can actually do like a lot of cool things. um We will only use the teeny tiny, teeny tiny fraction of it. uh Let's see, um you can also see that a lot of um uh rust, Pro, like rust libraries, are very fond of this kind of book format.

B

So you will find these um type of uh bookish um documentation, Parts, like basically everywhere um in the rust ecosystem and they, if they're, nice and well documented. Just as like rent is um you get something like um like? That's a very nice getting started guide and we once again see that we have a Prelude that we can use so ran. Prelude sounds good.

B

uh Let's go back and use this, maybe um and then how do we make a random thing? ah We just call random cool, um so this seems fair enough. There's also knowledge you can do with random um like generate like within certain ranges and stuff, but like just calling random for us is um probably enough.

B

Okay, so we have the rent Prelude.

B

Maybe my next suggestion is that we go into view and just like try to draw something on a random position right just to see if that works um draw, um and then what can we do?.

D

D

B

B

um Nanu has so there's an interesting part where um there's kind of like different functions, especially when we're dealing with positioning or width and height um that you I, don't think it's like super well documented. Yet, but it's kind of um good to know is that there's usually two versions of something one is for example.

B

If you want to give it a position: X and Y, there is X Y and X underscore y, um and one takes a vector like a vector two so like something that you would use in like a yeah classic coordinate system. But if you just want to give it like two numbers and not coupled in a vector type, you can do X underscore Y and then just give it two numbers like comma separated and the same works for things like um uh width and height to, um for example.

B

So um let's go with this, so there's a back two I think it's called, or is it Vector two I don't actually know? Let's see.

D

Back two yeah: okay.

D

B

D

B

We're here um and then I would just try and call random comma.

D

B

And give it a within: let's go for the same width and height um every time. For now, uh let's say maybe 10 and all of these usually take um loads.

E

D

B

um And we can give it a color and now we're drawing on white. So, let's maybe say blue.

D

D

B

Go hoping that this is a little faster right now, uh but the idea is then, like that we we just pulled in something that we can use to create Randomness um for once and then just like try to draw something at a random position on every like Call of our draw function.

B

D

B

Now that we pulled in Rand, we also need um also compile these things. um Let's maybe take a.

D

D

D

Here we get like.

B

No, that's okay,.

B

Yeah, that's right. This should actually be lowercase.

B

So that we do get the.

B

Actually like functions, and not um the type.

E

B

10 things would take so long. Okay, yes, question.

B

Yes, so what you would do is, um for example, say or like you can basically create new instances of draw. So let's say this is like draw two and this and then this creates something from draw where you translate um by I, don't know something and then like move it, and then you yeah, okay, thank you.

B

Okay, let's see what's going on in our compilation here.

B

B

B

Let's just assume this works and if it didn't, we will have to check in a second. So what I would assume to happen? Is that once the window starts, we get random splotches of blue circles somewhere on our screen, um which is good in a way that we now know how to draw a circle um on a random position.

B

But what we kind of want is that we want to start at a random position and then, from there kind of somewhat random, but still in an organized way, keep walking so like we can kind of get a trail um of these things. Let's see, uh maybe maybe now.

B

Okay, this is also not what I imagined.

B

ah Okay uh I, don't know if you can see it on the projection, but I can see it. It's kind of a blue um blue circle that is kind of jittery um in a way and I forgot to tell you a lot of things. um So what the Assumption I was just talking about was that there would be several, but this would.

B

um That is not true, because we also keep drawing the background every frame, so we only draw one Circle at a time, so one option could be to just not draw the background or like draw the background once and then keep the um the circles happening. The more interesting part here is, though, is the usage of random and the coordinate system that we're dealing with that I completely forgot to talk about at this point.

B

um So what is happening so we're drawing the circle basically right in the center of of our screen, and this um may seem counter-intuitive, especially like coming from like processing or P5, is that when you're used to dealing with the coordinate system is that usually you start at the top uh left um and then, like you, go to the right and to the bottom.

B

um Nanu doesn't do this and then I think this is one of the the biggest. What is happening? um What is happening here?

B

Coordinate system is kind of think of it as um almost like a polar coordinate system, if you will but like basically, um the center of the screen is zero zero um and then you go up. That is -1 and you go down. That is one, um and if you go to the left, it's minus one and if you go to the right, it is one.

B

Well, it should still be zero. Zero right. Let me let me see this yeah um well, my computer's laggy, um why? What is what's the reasoning behind this and why this like zero zero because, like we did Define like a size but like internally? How do we like? How does this work um and the reason for this is, if you um or like, maybe, if you're, somewhat familiar with like Shader programming?

B

um uh This is very common in the world of like like Shader programming, um because then you can normalize a lot of things um and it's very easy to do. Math on this, like very uh constrained things you can like map. Basically any value, Within These ranges, um and it's just um uh it's. What like yeah.

B

um It's also usually the default in um yeah in the kind of let's say the creative coding sphere, when you do with that creative coding and fragment Traders, for example, when you then say Okay I want to like map sine waves to something and then sine waves also usually go from like um negative one to positive one, and then you can like map these values easily to certain other ranges.

B

So this is the idea that also the new has um that we start in the center Center, and this is zero zero and then we can basically map all kinds of other values um and basically build the coordinate system that we um that we want.

B

um So this is interesting. The other point is that so we started zero zero. This is here. The other point that um happened is why this little circle is really just only minimally walking like barely barely visible, um is that random I would assume uh I didn't actually check this.

B

um The random function from the random crepe will probably just generate a random value between zero and one. So like also a like, we get a float, but it's like very, very tiny, and so we kind of need to um make this a little bit uh bigger. So just for the sake of trying this out, um let's multiply by 100 just to see. If my assumption here is right,.

B

It's hopefully it's a little bit faster.

D

B

um uh Does it not work now because.

D

Specifying the generic argument, what is happening.

B

Okay, now it complains about our type things that we might need to do this differently anyway,.

D

Okay- um and let's put it here- uh let's say um no- let's say X.

D

D

And this should be.

E

B

And this is where my emac shortcuts don't work. Okay,.

B

B

Now I have a typo in here and.

D

D

Foreign driver.

B

B

um That is a good.

B

Is it I thought.

C

B

Okay, good did you know that, because I would not have known that um so get underscore around.

C

For this, Instagram is called come along around with, unless you have geographies, but there's also red RNG, okay, um right.

B

From there okay, but did random work for you in this kind of scenario. No, because that's what I had before.

B

So I'm wondering why it works so dead. You just have to specify the time in the foreign.

B

Because I was one like wondering if I just put it here, it should also figure that out but I guess I guess not.

D

B

And try it like this and then we learn about turbo fish, which is also nice.

B

So there's a an operator, um colon colon and then anchor brackets and then be usually ready type.

B

This is correct.

E

B

Yeah, okay, um that is lovingly called turbo fish. um Do you remember the website? Is it turbo.fish.

D

B

And now you never forget foreign.

B

And yeah um later on, when we get to more, um when we get into like iterators, we will also probably see turbo fish again, um which is just a yeah shortened of like telling, for example, a function that is, the typed like the output type that we want, and it's just like a different way of like defining um or like uh yeah, indicating the the type that we expect or that we want.

B

um And let's see, if that works.

B

B

Just realized I also removed the the multiplication again right, geez.

E

B

B

Actually why we stare at this oh well, I started. This I can also like use the um the kind of like annotations that or attributes that you can put into um height compiler warnings, So like um where we previously had derived here. It says Warren and then the type of warning that you maybe want to like mute for your project, so in this case unused Imports, even though we technically use something from here, um but there's also like uh um unused variables, I guess and other other kinds.

B

That's it for a second, more.

D

B

D

This is the one without 100.

B

Should have probably configured this to be faster, um sorry about that?

B

uh Okay, maybe we will like wait for a second until the window, hopefully pops up again um once again talking about like what my assumption would be what's happening is that we still get the same window, but like now, we get like a bigger step of like randomly drawing a circle around the center.

B

um We can actually work with this for our Walker, um but, like we already had the question really quickly and I want to um explain a little bit about this. um The same way we get um like the draw that we use is in just an instance of draft that we get from app.

B

We can Define um new instances of draw either like freshly from app or basically from another draw instance. So let's say if we wanted like um uh classical um uh top left, let's call it that.

B

Top left coordinate system, um we can say we want to get um draw and then we can say translate so then basically shifts um shifts our coordinate system and what we can do is then say: um basically we want to take everything and then like shift it to the left and then like shift it to the um to the top.

B

uh So we can say take a back of two um and now I'm, actually not sure if we should ah here's the window. Finally, um so this is more like what I, what I was um assuming would happen is that we uh somewhere around the um around the center but like notice, how we do stay within like the um this quadrant of our coordinate system. Basically- and we draw this random Circle and it's like jumping all over the place, um but yeah so like the random Works multiplication with random Works.

B

um But we see that we need a little bit of work on our um on our coordinate system.

B

um So what we can do is either start like what I was about to do is start Shifting, the the center point from like the center of the center to the top left, and then we can say: okay, we always know that it's going to, we need to like do something in this direction, um for whatever reason like it's also interesting to think about that you um really have this freedom to to play with the with the coordinate system.

B

um Let's say if you want to have something that starts at the bottom and then like shifts to the top. Maybe you like want to start something and then kind of like flip it um with like a negative scale or something so there's like multiple ways that you can um that you can work with this.

B

um But let's start with like the uh translated to like a more conventional um coordinate system and then go from there, and what we can do is that we shift basically the width that we have divided.

D

B

Negative two, because we need it to the left right um and now we do the same to the top, where we say width.

D

Divided by negative.

B

Two and I really hope this works okay and then so this is kind of it's actually.

D

B

Where is it here? um So I can use these simultaneously, so I can still use the original draw to draw the background, um but I can also say um from there on I want to use top left. So here, instead of draw I can say top left um and then use this um to draw the stuff. I also don't need to change the last line because, like the since um top left kind of like comes from draw, we can just like use, draw to then draw the frame, um and that should work as well.

B

For now, I will also comment out the draw background so that we can actually see or like better see, um what's happening with um the circle that we draw.

D

uh Let's see, let's run this again.

E

B

Does this network like this, um it's.

D

Function from draw.

D

I'm confused, let me look into my cheat.

E

B

I, don't actually use this in the final version.

B

Maybe it's not the function call but.

D

Just like this.

B

Then it should work like this. Maybe I don't know, I thought it worked the other way around. But no that's, let's see.

D

B

ah uh Expected like three: oh okay,.

D

Well, that we can do.

B

um That's not what I expected so instead of like. um It also expects us something for the uh Z Dimension, um but let's just not shift that at all I hope that gets like just a zero, then yeah.

D

Let's try nope.

E

B

Fascinating: um okay,.

B

But this also doesn't shift the rest. No okay,.

D

B

Well, let's look into the documentation, maybe um I'm just kind of avoiding this, because my internet seems to be kind of slow.

D

B

See the chapter for window coordinates.

B

B

So it did shift for me, but not in the way I expected it. um So I got like the wrong direction, so I stopped painting the the background, but apparently I did negative and negative. ah Okay, so apparently I said the wrong thing about the y-axis, because um now we almost start with like a little square.

B

um So we see the the bounce also like a nice way to see the bounce of our like Randomness um multiplied by 100, uh okay, so on the y-axis I actually need to um uh going the other direction. Oh yeah, so negative is bottom wow, so I got really confused as well.

B

um So here it's two, so we want it at the top um and then we kind of like should get the same thing. I will not recompile this right now, because this takes too long, um but it should kind of you should get some missions.

C

B

Cool um cool. uh That being said, um so we see that we get lots of random points, but we still don't have a walker, um and the idea is now that we start tracking our states instead of just randomly drawing, we finally make use of our model um and uh try to keep track of. Like all the points, the ideas that we create, some sort of um Vector, which is usually the the type that you want to go for in Rust. There is an array type, but Aries can't grow or Shrink in size.

B

um So you use a vector which is exactly or does the same things that we wanted to do so on our model. We say um maybe positions and that should be of type back. So let me get a vector, don't confuse this with the vect two and three that come from the new that we've used before, um which we see right now because, like this will be a vector of vac 2's like what we use for positions, um two.

B

um So that, basically the idea is that every time we um we update, uh we calculate like we, we put a new um position in there and then like draw all the positions at once or work of our background.

B

um So that's the idea.

B

um What we also need to change is that in our model function so where we set everything up, we now have to create like a proper, empty, um proper empty model. So let's say positions um is uh you can use the vacuum macro here to create an empty vector and then we can actually yeah. Let's just start with this. um It's around here, um let's just start with one random position in the beginning, so we have something.

D

uh Where did I do that here.

D

Okay, just put it into here, okay, and then we say this is our.

B

First, Vector of.

D

D

D

uh No such fields did I write this wrong positions, positions.

D

But that should be okay, I, don't know, let's see.

B

um Now here comes the cool part. I will now delete this, so we get now that we put our first initial random position um in our model when we created it we'll quickly. Go back. I also hope that, like.

B

The red underline disappears in a second, um so we have modeled with um with the with a vector of actual coordinate positions, but we only put light one in there for now just to see if that works, um then what we had before in the view, because that's actually kind of more logic than should be in the view I will delete this, um and then we can actually read our coordinates from um from the model, so I actually need to.

B

Basically I will remove the underscore from from the model here in the function signature. If he has code without me yep, so we get model we can read from it. So here in X, Y I can now say um model.

B

And then positions and then zero or something- um and this is interesting because like right now, we only have we're only drawing one so like this. This could work for now.

B

um I will quickly actually check if that works like this, because I don't know.

C

C

B

This is why he was like thank you. Yes, beautiful.

B

Yeah, let's wait for it, um so this is just like a next small step in like changing the code again to see if, like okay can I actually access the model and the positions in there um I know that in the next step would be.

B

We will not have just one position because right now we only put in one position in the beginning, um but we want to actually uh keep pushing in and positions and then draw a circle for each of these positions, um which leads us to one of my favorite topics in Rust, which are iterators yay.

B

um uh So, like iterators are everything that has to do with um traversing a list or a collection of things.

B

um An iterator is a trade also in Rust, like uh even like a vector that we that we saw is implements the iterator thing um or like iterator trade, and the best part about iterators is that they open up the entire world of cool functional things that we can do in Rust and that I don't know. It's like this.

B

This cool thing that um I said in the beginning that I did a little bit of closure where I was like everything is just like map and reduce and and like all this kind of stuff, and then you can do all these things um with your collections of data and rust as well, but not where not having to worry about any kind of like overhead for performance because, like once it compiles, it will run super fast.

B

So you don't you don't pay um for a nice higher level Concepts um just like these functional features, but you basically get them for free, and this is really exciting.

B

um So there's different ways: we can um now we have this little window and we see nothing. Actually, this is unexpected. um Where is our Circle.

D

Where is the circle.

E

B

uh Yeah um but I think I know what it is because um I know there should be a chance that it just we got unlucky with a random nope.

D

D

C

D

B

Because, like before, I was so shh.

D

B

The thing is, random should only give us a positive value anyway right, so it should do. We need to just coordinate stuff, um so we started from here and then we shifted negative and positive, so we should be here so if we have so, if we have a positive, we should end up in this.

B

I know um because, okay, so it now fooled me twice um because negative is down so when we, so we kind of need the the second value or the second random way to produce a negative value or we flip. um We flip the coordinate system again. Maybe this is better because otherwise I will probably make the same mistake again.

B

um Nope not here so after um translating I would say scale.

B

um And then keep one for the x-axis and negative one for the y-axis, and that should flip it right.

B

That is yeah. um Actually it's.

D

The scale y o yeah yeah, okay,.

B

I will try it this way and if it doesn't work, I will try your way.

D

D

C

But I think last time I did Graphics yeah. The zero point was on top left and X was coming right now.

D

C

Why did they flip it.

B

um That the Y is flip right now, I'm also absolutely confused by it um like I, did remember the reasoning for the center position like yeah, um but why they flip the Y I don't know I would um maybe reread the because there's a blog post, where they explain some of like the design choices that they made.

B

um Maybe it's in there and I just forgot. uh Maybe it's also not in there I don't know, but there's um it is. It seems kind of yeah, not what you expect. So this is yeah. So I've now ran into this twice in in one session because it still seems so.

B

What I'm thinking of right now, if I flip it do I, also need to adjust the other translation again, but.

D

B

Maybe it's just easier to multiply by minus one and then in the random. So it's because if we ah no, it worked okay. So we get a point within our now correct, uh coordinate system, hooray uh fascinating, um so we're only generating one um one point right now, so this is fine. This is expected um and I guess. You can also see how I usually go about these things.

B

I try to do something think kind of like imagine what should be the outcome of what I just did and then either it is that outcome and then I, move on to the next step, um or it's not working at all and I.

B

Try to figure out, okay did I, think wrong or did I write wrong um to go like like kind of this is my my Approach, but maybe like once you're um more used to both the tool and the um like this kind of where you're probably like right right these um way faster and more like more confidently.

B

um Okay, so we have finally settled our top left coordinate system. We generate um one thing: oh yeah, we were with iterators, so what we actually want to do is um draw a circle for each of our positions in the vector, um so for the sake of just showing it so there's um uh simple for Loops that we can use.

B

um So let's call it four.

D

D

D

Positions, I'm really bad at typing. This positions.

B

um So we want this as an iterator um and then we already see like Rosanna says: okay, now we get this back too cool.

D

D

Well, no, that's.

E

B

uh Let's take everything here and move it into here and then we can just work with um position here and not have to worry.

D

About the rest,.

D

Cool ah just position here.

D

B

um Before I start trying to re-render this again, it's also just at the um the code to the update function to tell like basically adding a new Point. Otherwise we will also just get the same Point again.

B

um So in this case here, um let's go into our update.

B

um I already removed the underscore from model here. um So what I kind of want to do is basically do the same thing here again um and that's not multiplied by 100, but let's actually multiply by width. So we get a random value that goes over the entire canvas of the Oleg upper window.

D

Whoops with like this.

B

And then um so we do the same thing here and then I would just say: model position.

D

B

And then we can push because it's a vector, oh my God, push.

B

um And create a new random um X Factor here, whoop.

D

B

uh And then, let's try this one and this time we should oh and I also want to bring back the drawing the white background. So we can see so now. Every time we draw, we should really draw every Circle in the position, because we also redraw the background, um so we we I, hope you get with them, ah no what's happening.

B

um ah um So this is an interesting, um interesting era that we haven't talked about. I used words like um references before, um but here we see kind of like the the counter sides, so um in the in the iterator that I created um I get position so like each um each element in the vector, I get it as a reference uh to a vector, but what the X Y position or like the X Y function really wants is just a vector.

B

um What how do we get around this and the compiler actually already has like an idea? What we might want to do. um It says: oh help, consider dereferencing the borrow so borrow, and it's basically saying that so we borrowed something we get a reference to it. So we kind of like powered this value, let's say temporarily or like without an um without the intention of modifying or mutating it um and with dereferencing.

B

We basically say: oh I have this reference that I borrowed, but I can walk along it and see what is actually what is actually there at the end like what is the reference pointing towards, um and then we can like look at this value, and this is done and rest with the Asterix operator. So basically saying. Okay, if this is a reference, I can use the Asterix and say: okay walk down this reference, which is um points to an actual value, and then we want to use this value um in our code.

D

Let's go to here and save and try again.

D

B

Yeah and you will see that oftentimes, like I, don't really think about references and borrows in advance I. Most of the time rely on the compiler to tell me um I'll, try this or try that, especially with dealing with um nanu, because menu sometimes has very opinionated ideas of like what it wants right now, um so that, like oh, maybe it's like an a different d-reference D reference d-reference to something um is, is not uncommon in a bigger um in a bigger sketch or in a bigger project.

B

Okay, uh well, this yeah it's! um Sadly, my computer died two weeks ago, and this is a it's a borrowed laptop. So I can't really talk bad about it, because I'm happy that I have it at all.

B

But um let's see um maybe let's go on um after all, uh I'll once again tell you what my assumption is that will happen once we have the video once we have the window, um which is that we still get like random points all over our screen, but still no Walker, um yes kind of like random dots, and it's like okay, but where is the? Where is the kind of idea of like well we're following some sort of Trail?

B

um So this is the point where we need to like think about like how do we get from like one one? Okay, we can start randomly, but how do we go from one position to the next? That is somewhat random, but still like connected in a way any ideas.

B

It's um that's actually an interesting idea, but I thought of something. That's more simple and just math.

B

Basically, we we take the last value and like go from there um cool. Let's do this, so we already have update, so we can kind of um how do we do this? So we say we get. Maybe the um s point or not. The.

D

Pine pint but point: oh, my God.

D

B

D

Model positions.

B

Thought last does not exist, I don't even know. Does it.

C

C

A

B

I would I would probably be lazy with coding and insert um like this, but now that you mentioned the the option, um because that's already a good point to talk about um last.

B

um So this gives us an option. I hope that must analyze it will quickly run um yeah. So it's an option of a reference of vac 2., um so probably really cool. uh So like the way, the program runs right now that we know that there will be um at least one position in the vector because, like I put one in right when we create it, um but there's a cool thing.

B

So there's this entire topic of pattern, matching investors, which is also really cool and where we can match on things and um especially enums um one doesn't enum. Enum is a type that has a um strictly defined um like strictly find list of variants. That means it's strictly defined list of things it can be a classic example would be if we have an email of traffic lights and then the variants of traffic light would be green, yellow and red, at least like where traffic lights. Look like this, not in other countries that have blue lights.

B

um But the idea is that we can say: okay if we know that we're dealing with a type traffic light, we know that it can only be one of these three variants um and in the same kind of way of thinking, option is an enum and option is either some thing, so the one variant is actually called sum s-o-m-e um or it is none. When there's like nothing um and then the sum will will contain something um that we can work with. uh So what we could do um so like the way pattern.

B

Matching words is that we have um the match statement and then we can say last so we mentioned last point.

B

um And then we know that it's either some uh of something X.

D

Well, that is actually: where are we nope nope.

B

Why am I here um then we can do something here uh or yep. um It is none, and then we can do something here.

B

uh uh So then, so let's say we match on the option that we get um and then do something with the next value, but there's also a shorthand for this entire expression. If we, if we're only dealing with the um with this concept of option- um and that will be um I put this at the top to like then compare it to uh which would be if whoop.

B

um It flat- um um and that is some of let's just call.

D

D

And then last oh, come on.

B

um Last point and I hope this is correct, syntax, because it also always make a mistake here. um So basically, these these two are equivalent.

B

um It's just that in in the in the, if lead case and saying okay I'm interested in whatever is in this object like I, want to access it in like a safe way, but I'm really only interested in the sum I.

B

Don't care about the the nun case um so like in here I can then use uh last and do something with it um and in the other case, in the match, I'm more explicit I can be more explicit about doing something for each of the variants um that I might be um that I can match on so to say.

B

So the first part for match. We will also see um matching later um because, like there's like we'll, also Define an enum and like look at how how that works.

B

um Okay, let's go with the um if flat for now or like maybe for completeness sake, there's also like other ways to to just access um uh the option uh like the sum part of the option which is with um unwrapped, which is something that we've seen before in this as well.

B

This is just um taking the sum if there is some um but like crashing, if there is a nun, so this could potentially back crash our program um because it's like not really a good error handling, um let's say um so like a nicer way. Whoop um would be this uh so like. Finally, let's get to our last point um and let's also say actually that I want um like last and then we do reference this here, I guess um so. I can get this.

B

D

B

Will also remove these two.

D

So that I can a little bit of an overview.

B

um So if that last and then we said uh we want to say, hey, um let X be last.

B

um Dot X um Plus, random server.

D

Fish just to be safe here.

B

And then that's multiplied by.

D

B

Let's go for 10.

B

so just like, we have a little bit of of a distance that we can walk um in between these two, like from the last position to the next position, um and then we do the same for why.

B

D

Then we also just pull this one in.

B

In here, um so this is one problem right now, but I think we will see this once we I'm already gonna kick off the I'm running this, but the idea is that we update we get the last Point only if we actually have a last point.

B

We construct a new point that is like goes a little random step um on the X and on the y-axis, and then we take this new point and then push it in um what I've, already kind of assume is going to happen is that um we will only ever walk in a positive direction because, like now that we actually our coordinate system is made in a way that positive only means like um going uh right, write and down, and this is kind of like where we're walking here oops.

B

So we kind of like have to um also think about okay like now. How do we generate a random point? It might also be randomly negative. um Are we done yet? No uh so there's various ways. We could do this. Maybe we this time we can actually work with range.

C

Double to 10 and.

D

Then subtract the 10 again.

B

That's a good idea too.

D

uh But then we have to should be fine.

B

Nah I, like it like this, so I, know like what's what steps I want to belong together in a way.

E

D

And let's maybe try this one directly.

B

um And this should technically already um give us a walker in a way. The rest is then, like um visually, improving the outcome.

B

um I want to say one um one part about because we heard purlin noise before so. This kind of motion would be Brownian motion so like just like randomly really uncoordinatedly walking into a direction.

B

um uh The biggest difference to purlin noise is that pearly noise is pseudo um pseudo-random.

B

So um in this case, if we have a walker like this, and we like generate an image based on this, there is no way we could ever like get the same or like uh replicate an image that we had once because, like this, this is truly random or like as random as a computer can make it I guess.

B

um But if we say we want to have an algorithm that can be reproduced because there's um let's say it takes a very long time to compute, and then you just you, don't want to like send some. You only want to like send or like. Let me I'm going to pick. um Pearly noise is pseudor random. What that means is that, based on the seed, the algorithm will generate the same sequence of random numbers based on the seed.

B

So if you use the same seed again, you will get the exact same um sequence of random numbers. So let's say you could share an image. Let's say by sharing the algorithm and the seed and then the person can compute their own image and then they would get the same image, um and this can be really cool ah here we go uh it compiled it's a walker amazing.

B

Yay, um yes,.

B

um So this is one idea that can be really cool. um There is nanu comes with purlin noise. It is I, think you have to explicitly import the um I, don't know if it's really just like the new colon colon noise or, if there's, if it's like in another package, but it is already in there, so you can get perlin noise from the new, give it a seed and then like generate Randomness based on on that. If you want um uh right, um cool.

D

No last forever: okay.

B

um Questions so far.

B

Okay, no um yeah.

B

Brownian motion because I guess there's a person called Brown who defined.

B

It was like, like brown like German brown.

B

um Also Berlin noise is named after purlin. um I know it's actually not I'm.

B

It's brown, like English Brown, no I, was so sure um yeah, but there's like different kinds of these. Like.

D

B

Yeah so like this is basically like any kind of like super random um yeah. It is um cool, um let's place a little bit with the with the color things and then because I think that is um also something that or to me was not like super intuitive when I first started, and so um right now we're just like drawing um a color like just the color blue, and then it was like predefined. So there's I think they're based on the CSS color names.

B

um So you can also use your cornflower blue or whatever you have, um but it would obviously be cooler if we could just like um either use RGB or hsl so like um yeah RGB is like red, green and blue, which you use from equip development or hsl hue saturation uh lightness, um which is a different kind of way to like describe um colors and in the final example. So like there's various ways um that you can bring color to your to your Walker.

B

This is also like the part where we can open it up a little bit more because, like this is now the um the very basis like whatever you want to do, because, like for example, you can play with the the width and height values like we just defined them here, but you can say: oh I actually want a um a random width and height for every every position as well.

B

So you have to um adjust your model a little bit, um not only to keep track of positions but also like um maybe like wrap everything and like call it each step, and each step has a position and the color, um for example, um you can also yeah um change, color and click yeah. This is like the last step that I want to do with.

B

You is like looking at one of the event handlers that we have and how to work with those, but maybe we do this when we look in through the final.rs um but like yeah. Now it's the the part where you can like um uh think of like oh, wouldn't it be cool. It could do this or that um and for this I want to quickly do the um the color thing I want to make, uh because we did it here, because I thought there was also kind of interesting.

B

um So what I did in the in the original sketch?

B

um um Is this thing?

B

um I defined a variable and used map range, um so this is the if you come from P5 and processing, it's just called map, but since rust already has a a map and then who decided to call it map arrange- because this is what it is, um is that it takes a bunch of arguments.

B

So the first one is the value that we have um in. So this would be here.

D

um Actually, we need to put it in.

B

Inside here, because we need this for every for every position.

B

um So the idea is that we have um well the reference position um position X and then we know that um the position X will be within the range of 0.0 and the total width of the screen.

B

This is like from the pool where we generate its Randomness from so it's like from this is the input minimum zero zero or maybe, let's do it like um to the output um or the input Max, which is the width of the window, and then we kind of like want to interpolate based on these values, um when I said, like position, X2 a different kind of range of values um and in this case all the ideas that we then go and the color wheel in the Hue space.

B

um We want to pick a value here and then the new this is defined on the scale like on the range from 0.0 to 1.0. This is why these these values are here so map range will like then map these values from one range into another for us.

B

um So this is kind of cool, so then I will also like so instead of just using blue here. I will also copy this because I'm getting lazy.

B

um We can do this.

D

D

B

Wrong wrong thing um right so, instead of calling color and giving this predefined color um we're calling hsla once again, that's Hue saturation um lightness um or sometimes it's also called brightness um and then a for Alpha, um where Hugh is kind of like within the color wheel of um maybe I can.

D

B

Maybe it's easier to quickly search for an image.

B

um So if you imagine this like color wheel, um that goes like yeah um because, like usually it's in degrees from because it's a circle um from zero to 360 Degrees. Sometimes this is already mapped from zero to 255 in the new. This is mapped from zero to one, but basically every value describes um an angle within this circle, and then we move the radius from like darkness and lightness um and then also in saturation.

B

um So any of these kind of ideas and the cool thing is, if you want to be artsy, um you usually like you can easily um set like only use Randomness on one of these channels and set the others um to a static value. So that like, if, because usually, if like saturation and weakness, stay the same, um the colors kind of like seem to work really well together, um and then you can say it's totally on purpose.

B

um If you want uh so, let's maybe go up with the um um with the randomness here so I'm so like you is going to be the map range and based on the X position uh on this color wheel. So like we don't have a circle, but just like basically going from left to right over the um so like from red to basically red again and they're, wondering like Meandering through um through the color wheel, but only on the x-axis um and then saturation lightness stay the same and a little bit of um uh transparency.

B

Basically, um let's see this again and.

B

Once again made a typo in position, because this is my word that I cannot.

D

D

And it's still not red.

B

And I thought I was being smart. It already tells me, oh, this is by accessing the x value I already dereferenced. It um also for reasons uh that I don't want to go into right now, but I really hope it's it's working. You know.

B

B

C

C

Or is it just like, how often is.

B

um That's a very good question: what do you think.

C

Oh the worst case, it's basically about the CPU. So it's as soft as possible.

C

Because of the driver uh best case, it is on a scheduled intro.

C

B

It with this kind of Frameworks usually try to be. They aim for a constant 60 frames per second in everything in in the in the update function. So this is what I, when I say- um and there is um you- can configure this like how often you want the this update function to run so the default is 60 seconds and there is, um let me think um so.

B

There's multiple ways you can even say: oh just don't update at all and then through code uh say update so like, for example, um every time you click calculate, update and play basically step through a sketch. ah Oh no where's everything is it too light? Maybe, sorry I'm, just like quickly.

D

D

Try this again here.

C

B

um um There should be somewhere in the um in the documentation, but I think I also have a um because I did this before and um in one.

D

B

uh Let's see I think it's, it might just be called frame rate, and then you put it in when you when you create the window like in the in the model thing, but I'm gonna check, um Loop mode. Ah That's also, um let's say because I had this actually at the rustling's Meetup.

E

D

There is novel here.

D

B

um At least the window is here now um so we start here and we see like um basically the um the left uh Edge is now red and it if the Walker were to walk a little bit to the to the right um it will lay across from like, yellow and then green into blue into purple into red. Again, um unfortunately, it decided to leave the and leave this now. So maybe, let's try.

D

B

ah And then we start at the other Edge.

B

Eventually we get a good example. Hopefully, ah so here we are like in the blue and purple-ish space.

B

um Another idea could then be to like map, so I only map the the x value M to U, but for example, you could also map, then the Y value to like brightness or to saturation to get like even more um dynamic in within the sketch.

B

So this works um right um because it's only half an hour and I kind of want you to like really like play with this and I. Just like can be here for questions um a quickly run through what like the final result is or was um uh like what, like. My original idea, was um just to show you how like what else you can do and how you can go about things um so in you can also look at this in final RS.

B

So what I was thinking is that you could, instead of circles, draw rectangles or dots or something else, um and then I thought like. Oh, we could create like an enum, so like this, this kind of type that can only have certain um yeah certain certain variants can be certain States and you use it with the enum keyword and then I called it this for visualization and then I just said. Oh um I want it's, either dots or circles or rectangles, um and then, like basically, there's all right. We can.

B

We can look at this I derived some um like basic traits for them and then I have a struct that I call Walker, um where I keep track of state of the steps um which is a vector of a tuples. We haven't talked about tuples, so you can just with um parentheses, basically like uh yeah group groups and values or types together, so this Tuple has a vector on the first field and then a 32-bit float and second field. So I can like say like for each step. I want to like collect these.

B

This information and I think um the F, like the the float, is then used for the distance that we um use like in the the calculation of Random um and then I also want to keep track of um the style that is currently being used, and then that I want to draw in- um and this was an interesting decision because, like you, can go either way right, you can um say, like oh I, if I keep track of all the positions with the um with the Press of a key I can change the um the way it's like drawn for everything.

B

um Even it was like. Previously there were all circles, but then I pressed the key and then they're all rectangles, um but then I thought, wouldn't it be cooler if I um say like each Walker has one style, sudden I can have multiple Walkers and each Walker has like a different style of visualization um and then use that, but like this is then like your artistic and creative freedom um to go with this.

B

um What we also haven't talked about is the input keyword um which is I talked about when we, when we derived something the compiler generates, generates the implementation of a trade for us.

B

um If we cannot or do not want this or just want to do something different, like Implement other functions on our on our on our types, um you have to open an input block, and then we can say so for a structwalker. This is basically just struck. Just defines the fields um of our type and an input.

B

We can then bring functionality uh to our type, so we can say, for example, we can create an explicit new function um so that we don't have to use the um the manual like full syntax to create um an instance of our type um I. Also decided here to actually maybe go a little bit more into the um maybe like object-oriented way. If you want um that I said: okay, each Walker should be able to basically update itself so I Implement an update function on the Walker.

B

That then knows how to do all the maths, um with all the all the steps that are in there. um This seems very yeah. There's a random Vector I'm, also like clamping some values here. So I'm not like this.

B

We, we chose a different approach in our sketch, which also closer to this like multiple ways to do the same thing, um but then, actually, my actual model um is then a vector of Walkers, so that I can have multiple Walkers um and then I also keeps like style overall, it's kind of like the currently active one. If I create a new Walker, it will in kind of inherit, but just like copy the style that is currently the global one.

B

um So I like arranged um arranged the sketch like this um yeah.

B

So, for example, when we kick off um uh like this, sketch um I generate one Walker uh always actually it appears that here we didn't change the coordinate system at all, so I'm, starting at zero zero, which starts in the middle, give it the circle to this, and also like the the overall this circles um and then what I did in key press is that um so when, when I get, the key I can match on Keys like it's the same kind of pattern, matching that we had um with the option and but I say: okay key one, which is just like the number keys in the top I want to change the model style to either dot circles or rectangles.

B

um Interestingly enough, this is also something that um uh it's kind of interesting and cool, so we have a a default case or like a a catch-all. If you want- and that's just the the underscore that says, like all the other keys, because there's a lot more keys on the keyboard than we want to check for um for all the other Keys just do nothing. We want to ignore them.

B

um But in this case we have to put this default case here, because otherwise the compiler says. But what? If any of the other keys are like press I, don't know what to do, and so we have to be explicit about like saying for everything else.

B

um Just don't um just don't do anything, and this is also cool because for um we saw an option earlier option only has two variants, so there's only some at none, so we covered all the all the possibilities in that case, um and the compiler also makes sure that you you provide. You provide one once like one way to go for each and every scenario that the um that an enum has.

B

So you can, um if you kind of like forget to account for a case, the compiler will tell you and force you to actually make sure you cover every case and also like and through this also eliminates like a source of Love of Errors. If like, if you run into something um unexpected or in case you run into something unexpected, um that was it about match.

B

uh Right um in the final sketch, a thing that I did is that when you click a mouse button, um I have the same match statement here. Basically, uh we match on button.

B

If we say if we click with the left Mouse button, we um basically uh copy the position from the mouse click and generate a new Walker, and if we click with the right Mouse button, I, basically remove all the Walkers by just saying: okay, Walker says now an empty vector, and then we can start again um and I also need the fallback case here, because some mice have a lot of keys, but there's at least also the mouse wheel that we need to account for that we can click um and the rest should be kind of kind of self-explanatory if you walk through it um cool um that is it um one thing that I might want to show that the first time I gave this Workshop.

B

The um one of the participants said the idea that we do want a random Walker, but we kind of wanted to sort of walk into the direction of where the mouse is, but still in a random way.

B

um So that was kind of interesting to um to do so. What we did, um it's kind of like multiply the vectors of the mouse position here we go that took us a long time to figure out in the workshop, how we get there um from the mouse position to like normalizing the step size um and to still kind of like sort of like have the Walker wobble its way uh towards the Mouse.

B

um But this is also like an idea that you can um in that direction. If you want to go there, okay, um questions.

B

Okay, what would you like to try, or would you rather like try your stuff by yourself and like I, can like walk around and ask like answer questions or we can try something together or it's just like roughly 15 more minutes, or we can also talk about other things. That may be interesting to you within the yeah.

B

um It should be, but don't quote me on that.

C

B

Maybe other so um I did say that um a creative, quoting framework is basically just a game engine with extra stuff.

B

um If you want something, that's maybe smaller, um just for like drawing a little bit, there is a small game. Engine um called GG easy good games easily, um and this is so I think they're not active, so they're kind of like still maintaining it, but there's no further development on it, but it works um and you can get like most things done with it.

B

um It has this, like update, draw um API that you kind of should be familiar with by now. um They also have to say: Hey, you define your own State through structs literally make this bigger, um and you can like draw simple graphics and like make simple games with it.

B

um So if this is, let's say, let's, if this is all you want to do, GGC might be like a smaller, um smaller crate that is worth looking into.

B

um But but, as I said, there there's no more like active development, just like maintenance going on, um but if you're actually interested in um a game gaming game game engine um I would recommend, ah let's, let's search for it, um recommend bevy.

B

But remember the actual URL Bevy engine.org, okay, um so I think from from my perspective, baby, it's kind of like the hot right now um in the rough Game Dev ecosystem.

B

um But Bevy uses or like is based on like an entity component like architecture, so um this is just like a new like way to think about how to structure your program.

B

um It might be like if you're not familiar with it. It seems a little like weird I think at first, um but it's cool and like actually the um the community does a lot of like uh tutorials for it and it's like actually kind of like cool once you get used to it. um But this is. This is like for it's a game engine like game game engine. That's the focus so like.

B

If you then want to try to like bring something because, like most other um Frameworks or engines, don't don't really work with like this entity component thing. So like then, trying to combine this with other stuff, I actually haven't tried, but I'd. Imagine that it would be more difficult to like bring different kinds of like architectures and ideas into the same um into the same space with bevy.

B

E

B

I think these are the one like the two things that I want to to show you um questions input so far, I just keep on talking like feel free to um to interrupt me and also want to quickly go through the list of um useful links from the pet.

B

B

B

um Yeah um yeah I mean like I and I, know that it's there and I know that I've made mistakes in the past and still I make all these mistakes today again because it's like so it's like, if it's really the only framework that I know that, does it like this, if you're not just like I, don't know writing raw GLS ill shaders, um which is like and even then I think even there you usually set the the center point at the beginning. If I remember correctly,.

D

D

um What else what else.

D

And again, and the rest is just.

B

ah Maybe um that is actually also um kind of cool, so I talked about nature of code and the the generative or generative design um books in the beginning, a little bit because they're kind of like too too standard um resources in the in the generative art or like creative coding space.

B

um But in the new repository there is actually the generative design and the um nature of code. um Examples from both books, ported to nanu um I, think almost like 90, completely, probably maybe even more by now. um So, if you like, read through these and think like oh like how would this work in a new, how can I like solve this, um there's actually examples of everything um everything in the repository. So that's like why there's? No!

B

It's like my biggest pain point with my news, usually so like I like a nicely written out tutorial with, like step-by-step things of like oh, this is how you do this. This is how you do that, um and this doesn't, while nanu has the guide there's only like the very very Basics described in it, and there's like two or three Community tutorials, but the rest is still only only existed like examples in code.

B

So it's really just like you trying to like work your way through the code and like trying to understand what's happening and um with the way that I work with like seeing okay, making one thing work and then like expanding upon it and like iterating over it. This is very hard to um to have this experience with the new material right now, which is I, think a shame um but I I hope or would assume that it like um gets better in the future, because, like then, it was still like under active development.

B

A lot of things change, there's still like more API things that they want to work on um before they want to like attempt a like 0.1 release, um so yeah I think that's it. um Okay, more questions, ideas, uh attractive, implement the thing it was kind of mature, yeah sure which thingy ah okay.

C

C

Different matched arms have different types right, so big thoughts and small dogs are both ellipses, but the.

B

Record Times, okay,.

C

B

C

Do they have to like waste it or.

B

um It is possible that.

B

I just duplicated the code, um but I think I, don't know how this worked out, but I did have some super weird things with um line and polyline, where I just had to like, like really just like clone some like like it had like the weirdest kind of stuff, because, like um some of these functions, expect really strange things um so I would just my assumption. Is that it's something related to this, where it's like?

B

Oh you, um but in in my case, so when I did I just like copied, the um I just copied the stuff yeah.

B

Yeah like um because the quad also takes an um a vector of points, I, guess or something because like I, think wrecked is always like rectangle and quad can be like any kind of four corner thing so like if you just want, like the actual like 90, 90 degrees, rectangles, use wrecked, and then quad is more like. Here are four points that describe a any kind of yeah um foreign.

B

Nice um small steps right in the next time you can like improve on that. Okay, um no I talked for so long ah question. Yes,.

D

A

um I I put small little path um while listening to you and I don't release anything. But my app feels a lot with the scaling images.

A

It scales the recycling so now I'm not really sure what the audience. If you want buttons.

A

B

So the idea of you is that you just draw, and the idea of update is that you modify your model. That is like the base base distinguishing I. Don't know: where do you have any kind of like window, resize, Handler or something that does stuff.

A

B

Okay but you're not setting it again because.