3D Basics in C

本站添加: 2026-06-05

[00:00:00]Hello everybody. In today's episode, we're going to try to learn about how to code three-dimensional stuff in C.

[00:00:09]In my last 100 or so episodes, I have exclusively coded stuff in two dimensions just because it's simple, it's straightforward, it's visual, and it's fun. Okay? I never really attempted to do anything in 3D. I remember like 1 year ago or maybe even almost 2 years ago by now, uh I started learning about C and the first thing I tried to do in raylib was to to code something in 3D and I completely failed and I freaked out and I canceled the recording and I never uploaded that episode. So, today with >> [laughter and gasps] >> with a history of projects in my backpack, with some experience, I'm going to re-attempt to try to create something ultra simple in three dimensions. Maybe it's just going to be a simple cube that the camera can move around or something like that. So, don't be too harsh on me.

[00:01:10]I'm just going to try to get something in raylib running.

[00:01:14]I know on the raylib examples page, there is an example of a raylib 3D cube.

[00:01:23]Let's just have a look at that. I will try to not do the exact same thing, but maybe something slightly different. For example, this one here is a rotating cube. Okay, that's nice. It has a fixed camera. I don't think I can move around here.

[00:01:40]And then I remember, right, there's a basic example here for a cube that we can walk around, I think.

[00:01:51]Yeah, this one or this one here.

[00:01:56]Can I move?

[00:01:58]Yeah, so here I can move the camera with the mouse and I can also slightly tilt something with the arrow keys. Now, okay.

[00:02:06]Yeah, so there are examples on the raylib GitHub page or on the raylib page itself. I'm not sure if I will use them. Let's try to do it without first.

[00:02:17]So, I'm going to create a new directory 3D cube. I already have one by the way because ah, let's go into that and show you that one. It's or it's also a video that I've recorded sometime ago. That's a video where I That's a project where I coded a 3D cube from scratch using STL. So, this has nothing to do with raylib.

[00:02:39]So, I'm going to No, I I won't compile and show you that one >> [laughter] >> because I don't have STL set up right now on my machine.

[00:02:50]What I want to do is create a new directory and call it raylib cube. Okay, so make directory raylib cube.

[00:03:03]Raylib cube exists.

[00:03:08]Raylib cube, how's that possible? What?

[00:03:14]Ah, is that maybe sample code? Did I explore something about the raylib cube in the past? I completely forgot.

[00:03:26]I think that's just Yeah, okay. Okay, the window is being closed and someone commented de-initialization. That's definitely not my own code.

[00:03:35]>> [laughter] [gasps] >> Whenever you see proper cleanup, it's not from me.

[00:03:39]So, this project is also occu- Is this Yeah.

[00:03:46]Let's figure out a new project name.

[00:03:47]>> [gasps] >> Um >> [sighs] >> So, 3D cube and raylib cube are both taken.

[00:03:55]Let's just create a directory of 3D world and go into this one, 3D world. Okay.

[00:04:04]And I'm going to create a source file called world.c, include raylib.h, and include standard io.h, and then we need a main method here. And that's that's about it. Let's print something here. Oops, that's not what I wanted to paste here. Printf Hello world. That's a good start for a three-dimensional project.

[00:04:32]And let's CD into that over here and try to compile it, world, and source file is world.c.

[00:04:42]Okay.

[00:04:44]And now we have an executable here.

[00:04:47]Right there that we can execute. And if I execute it, I get a hello world. Mhm.

[00:04:53]Mhm. Mhm. Has nothing to do with 3D yet.

[00:04:56]I just wanted to see and if if I I just wanted to see if I can get a quick starting point set up.

[00:05:04]Now, because I want to use raylib, I will open the raylib headers right here.

[00:05:12]And from here, I'm going to take the init window function and paste it here.

[00:05:20]No, paste it up here.

[00:05:23]And we're going to initialize a window with a width and a height and a title.

[00:05:27]So, width and height height and title. What's the title going to be? 3D cube.

[00:05:36]Okay. And then I'm going to need to define width as 900 as always and define height as 600. And now we are set. If I now compile this, this won't work because now we're making Now it's the first time that we make use of a raylib library function, so we need to link raylib here. So, if we compile, we need to append {dash} L raylib. Link raylib.

[00:06:08]That's what it means.

[00:06:11]And now it's compiled and now we can execute it. And as you can see, there was a quick glimpse of a window opening and closing instantly.

[00:06:21]Perfect. So, to keep the window open, we want to create a while loop here. While the window should not close, we keep it open. Wow.

[00:06:37]And what do we do here? We begin drawing. That's how raylib um measure this frame per frames per seconds and handles them because we have to begin drawing and end drawing inside this loop and then we can set a frame rate outside of that loop.

[00:06:54]Set target FPS is 60 frames per second.

[00:06:58]And now we should have a working executable, right? That opens a window.

[00:07:03]It has a title 3D cube and it stays open until we close it. Perfect.

[00:07:09]>> [gasps] >> But now comes the first detail. Here I'm calling begin drawing and end drawing, but I don't even know if this is the right thing to do right now because I just saw when I typed here begin and auto completed, there was begin mode 2D and begin mode 3D.

[00:07:31]So, probably I need to call begin mode 3D.

[00:07:37]Do I need to call it only once out here?

[00:07:41]Let's have a look. Begin mode.

[00:07:44]Here.

[00:07:46]So, begin mode 2D does the following. It begins 2D mode with custom camera.

[00:07:53]Parenthesis 2D.

[00:07:55]And then end mode 2D ends 2D mode with custom camera.

[00:08:01]Same for 3D.

[00:08:03]Begin 3D mode with custom camera 3D. And then we end the mode 3D. So, is there any reason we need to do this inside the loop or can we just do it outside? End mode 3D.

[00:08:16]I'm not so sure, but it definitely has to do with the camera. And when I dealt with 2D projects, I never used the camera because I just created everything in the pixel coordinate space. Never used the camera, which is responsible for panning across the image and zooming in and stuff like that. I never made use of it. Maybe that should have Maybe I should have created a project on that before I started recording this 3D project.

[00:08:47]But okay, we will figure it out.

[00:08:51]Uh what am I doing here?

[00:08:55]Uh visual Okay.

[00:09:00]So, now I think we need to look at sample code because in raylib there's no documentation at all.

[00:09:16]There's only sample code, and it teaches by example, and it's intended to be used as as a tutorial.

[00:09:25]Um before we do it, maybe let's check if um if we're even calling the these functions correctly. So, here we begin mode 3D.

[00:09:39]I don't know when to call it. Should we call it outside of the loop or inside of it?

[00:09:44]Can we call it outside of begin drawing or should or does it have to be called within?

[00:09:50]I don't know.

[00:09:53]And begin mode 3D, where is that function defined? Begin mode 3D.

[00:10:01]Wait, doesn't it exist? Begin mode 3D, does it not exist? Wait.

[00:10:11]Begin mode 2D, begin mode 3D. There it is.

[00:10:17]Why doesn't it exist if I search for it here?

[00:10:26]What the hell?

[00:10:27]I mean, there's begin mode 2D.

[00:10:30]Did I just delete it accidentally? Wait.

[00:10:34]I'm going to reopen the file.

[00:10:37]User include raylib 3D. Let's search for 3D.

[00:10:43]>> [gasps] >> There it is.

[00:10:47]Did I Maybe I deleted it somehow.

[00:10:50]Begin mode 3D. I search for it, now I get the result.

[00:10:53]Or I Or there was a typo in my search. I don't know.

[00:10:57]Okay, anyways, in begin mode 3D, we have to pass a camera 3D. What's that?

[00:11:06]A camera is basically a It's a model that contains information about the Or it's a data structure that contains information about the angle from which you are looking at a at an object and also the distance. As far as I know, it's effectively like a real camera that you point at whatever object. The camera, depending on how you hold it, generates a different image.

[00:11:42]And especially in the 3D world, you need to use a camera because if you define objects in three-dimensional space, you can't just render them without a camera camera because it's not defined from where you look at the object. In 2D space, it's not as critical because you can simply draw objects at specific pixel positions.

[00:12:05]In 3D, it's not that straightforward because you always look at objects from a specific angle.

[00:12:13]And that's what a camera defines.

[00:12:15]So, we need to initialize a camera 3D, which this function here takes as input.

[00:12:24]Camera 3D, let's have a look at that one.

[00:12:27]There it is. So, this is a structure camera 3D. It takes as input the position of the camera, the target, so where does it look which direction does it look at?

[00:12:39]Maybe does it help if I draw this? I don't know.

[00:12:43]Let's see.

[00:12:48]Let's try to visualize it here.

[00:12:51]So, this is the camera here.

[00:12:57]This one is the camera.

[00:12:59]And let's say that this one is the target.

[00:13:06]So, these are already two three-dimensional coordinates here that you define. These are three-dimensional coordinates. Yeah, right. Vector 3.

[00:13:15]And then there's an another vector that is called up, and it's the it's the camera up vector. And I recall from looking this up some sometime in the past that the camera up vector is a vector that you have to define because you can look at a specific object. For example, let me look at this cup here.

[00:13:39]But it's still undefined.

[00:13:42]Well, okay, what's what's currently defined?

[00:13:46]What we are currently defining is the is the position of the camera position and the target that it's looking at.

[00:13:57]Okay.

[00:13:57]But it's but the the up vector of the camera, so the angle at which the camera is being held is not defined. So, the camera could actually look at the object like this or like this or like this.

[00:14:14]Do you get the point?

[00:14:16]So, that's also undefined. You have also have to define the rotation of this camera view angle thingy.

[00:14:26]I'm the master of at explaining stuff.

[00:14:29]>> [snorts] >> Oh, I hope it is all correct. So, this is the up vector. It's a vector pointing in some direction and then there's some math being done, some matrix multiplication or whatever, cross products.

[00:14:44]Completely have no idea.

[00:14:46]Um that figures out what's up and what is down.

[00:14:52]And then there's a floating point number f o v y. That's the field of view aperture in y degrees in perspective used as a near plane width in orthographic.

[00:15:10]What?

[00:15:11]Okay, basically it's a field of view. 90 [clears throat] degrees. Let's It's some angle that defines the field of view. Let's not over complicate it.

[00:15:20]>> [snorts] >> Then there's another integer projection, camera projection, camera perspective, or orthographic. Oh, let's have a look at those two.

[00:15:30]Camera projection, orthographic, and perspective. Right, I recall them. By the way, I when I attended university, I had a course that was called um image processing for engineers.

[00:15:47]For those who do not know, I did not study computer science. I studied electrical engineerings and electrical engineering, and it was super important to understand how cameras themselves work.

[00:16:01]Of course, I forgot it almost all. But there are different projections that you can use to look at objects.

[00:16:09]Essentially, they are different matrices that the camera um that will represent the camera. This might be an okay-ish um visualization here. So, the orthographic projection >> [sighs] >> works in a way as if your eyes were uniformly distributed on a plane, and you look Oh my god, how do I even explain this? This is incredible. Well, imagine rays of light extending from your eyes, or reaching into your eyes, and you have thousands of eyes scattered across a plane here, and they and your eyes can catch all the parallel rays coming uh flying into them, as opposed to having a single eye here for the perspective projection, which >> [sighs] >> I have to draw this, guys.

[00:17:12]My my explanation is super So, let's let's say there's uh some object here. Let's Let's just say this is a cube, but I'm just going to represent it using a line.

[00:17:26]And then let's say you have one eye.

[00:17:32]How do I make this red? So, this is your eye.

[00:17:37]Okay. And then light from this object reaches your eye. Let's say your eye is effectively just a single point in in space.

[00:17:49]Mhm. So, this eye is of course grossly over represented here. It's just a single point. And your eye knows where the upper corner of this object is by ray casting it like this, okay?

[00:18:07]>> [gasps] >> And that's what creates these That's what's the perspective projection is being is doing. It's effectively warping because the rays extend in at angles from your eyes, or rather into your eyes.

[00:18:24]What the orthographic pro- Or also it's it's also called a parallel projection, by the way.

[00:18:31]What that is doing is you have an object, let's say this is the object here.

[00:18:36]And that's what I meant by 1,000 eyes.

[00:18:39]You have this eye here, and this eye here, and this eye here, and this eye here. And the light reaches your eyes in parallel rays like this.

[00:18:52]And that's why there's no warping, but of course there's That's not how reality looks like.

[00:19:00]Because in reality you absorb light from all different directions. But the orthographic projection is used in I think in engineering, especially in civil engineering where you and actually no, in in all kinds of engineering, in mechanical engineering, um where you design machines, buildings, bridges, etc., parts, whatever physical product, and you want to precisely model it such that every part of the object that you're modeling is equally represented, and that's how you can do it.

[00:19:47]Let's have a look, for example, at a apartment plan.

[00:19:55]Apartment floor plan, for example, is effectively if we look at it in 3D, this should be I don't know about this one. Is this orthographic or perspective? This is perspective.

[00:20:10]But, you can have these floor plans in orthographic projection. This one is perspective because you see the inner walls from both sides.

[00:20:22]Maybe let's look for orthographic specifically.

[00:20:26]Here. Yeah, that's that's a good ex- good example.

[00:20:30]Here, for example, that's an orthographic projection. You see that the individual shapes composing the structure that you're interested in, they are not distorted by perspective.

[00:20:44]And when I'm looking at that one, I remember The Sims game.

[00:20:48]Sims, you probably know it, which also uses a perspective projection. At least Oh, no, the new games don't, but the classic ones I'm too old, guys. The classic ones definitely use a orthographic projection here.

[00:21:09]Okay, so that's a that was a small outlook on the different projections. And actually yeah, that's all we need to know about the projections. So, it can be camera perspective or camera orthographic if we deal with classical 3D game engine-ish um 3D worlds, then it's of course going to be the perspective projection.

[00:21:36]So, let's define a camera 3D struct camera 3D cam and it's equal to let's have a look. So, position we position the camera Oh, no. Okay. So, I need a couple more variables here. I'm I'm not even sure how it's going to end up in the end.

[00:21:59]>> [snorts] >> By the way, I just removed the struct here because it's part of the type definition. So, here the the camera 3D is defined as the the struct camera 3D is defined via type def as camera 3D. That's and that effectively maps this keyword to this.

[00:22:21]So, we can omit that.

[00:22:24]Same for the vector three as well. So, vector three is a position.

[00:22:32]Let's say it's I don't know 10 0 0.

[00:22:38]So, we look at an object. Let's assume that we're using meters. If you're from the US, sorry guys. Um sorry, not sorry.

[00:22:48]Let's have a look, wait.

[00:22:50]Meters versus feet? I don't even know what you guys in the US are using. Feet? Are you using feet to measure distances?

[00:23:04]map here.

[00:23:07]I'm not going to say anymore anymore than that. Where in the world do people use metric and imperial?

[00:23:18]Why are all these maps so pixelated?

[00:23:24]metric imperial map Good. Let me have a zip of water.

[00:23:38]>> [sighs] >> So, for the rest of this video, I will say 10 m just for >> [clears throat] >> just so we have a common denominator denominator here. And we can think of units [snorts] of distance. I could also say 10 units.

[00:23:54]But then we couldn't differentiate between measures of distance and measures of volume and measures of area. But I think in this episode we we are only going to deal with distances, right?

[00:24:08]Anyways, let's say the target target is located at the origin point, right at the center of our coordinate system.

[00:24:20]>> [sighs] >> Then the up vector is, let's say, oh, I don't know what the coordinate system is in in Real Axis. Is X and Y then the floor plane as in classical mathematics, or is it some some other plane? I will assume that X and Y are this. Let me just draw it just so we are all aligned. Why can't I just choose a color here?

[00:24:49]So, I assume that the coordinate system looks somehow like this.

[00:24:55]Probably X is this, y is this.

[00:24:58]z is that.

[00:25:02]And because that because that vector that we have to define now is called up, I assume that the first one is x, y, and we want it to point up. I am not sure if it actually should point up because I recall when I looked this up in the past, the up vector actually defined a vector that when it's when the cross product with some other vector was calculated, then the result should point up.

[00:25:35]So, it could also be another vector, but we will just play around with it and see.

[00:25:42]You see, I have some fragments of knowledge here in this area, but really it's um not much at all. Not much at all.

[00:25:51]>> [gasps] >> Field of view. How What What's my field of view, guys? I'm going to try to figure out my field of view.

[00:25:59]I'm going to stop when I can't see either of my hands anymore.

[00:26:08]Mhm, I think now I'm approaching the border.

[00:26:12]Yeah, okay. That's my field of view.

[00:26:16]It's quite large. It's almost It's almost That's definitely a scientific method to determine field of view, guys. That's almost 180°.

[00:26:35]But why? Are fields of views really that large in computer games? I don't think so.

[00:26:43]Maybe I'm an exception.

[00:26:47]Maybe I should create a YouTube channel and speak about my insane field of view.

[00:26:59]So, float field of view FOV, uh but it was the field of view in Y degrees in perspective.

[00:27:09]>> [gasps] >> Oh, ah, I see. Because in in the orthographic camera projection, there is no field of view because or maybe that's just how I am that's just me trying to figure out this right now.

[00:27:23]Um here in the perspective projection, we have a field of view which is yeah, to be precise, this angle here.

[00:27:33]In the of orthographic projection, there is no field of view.

[00:27:37]This is unlimited. If this object was bigger, well, or is there a field of view?

[00:27:46]Well, there's definitely not an opening angle because all the rays are parallel.

[00:27:50]Somehow the scene is of course still limited, but there's no angle involved.

[00:28:00]>> [sighs] >> So, how is it even determined what the field of view in orthographic projections is?

[00:28:07]The field of view as in what fits into the screen image?

[00:28:14]Some of you are probably watching this and freaking out because I know nothing here, but >> [sighs and gasps] >> it's really interesting. If you look at these these things without just copying them from some online example, and you really have a look at every individual field here, and you speak about it and think for it, you think about it for a second, it's it's always opening up interesting new questions that I didn't really think about in the past.

[00:28:42]So, let's just say that the field of view, Y, whatever that is as compared to some regular field of view. Mm.

[00:28:48]Um let's say this field of view is I I think I saw in games before that it's 90.

[00:28:56]>> [sighs] >> But I don't know. Let's just set it to 90. I'm I'm sure with 90 degrees I can't go too wrong. Because let's say this is a player in a game. This is some object and then the player has a field of view of 90 degrees. Let's say it's looking like this approximately. It's not too bad. That one looks okay.

[00:29:21]But of course, if you are a field of view monster like me, then you can see objects in this entire range.

[00:29:29]Yeah.

[00:29:31]I should get an award for these scientific drawings here.

[00:29:35]Then we define a projection.

[00:29:41]But we can define it as part of the camera itself. So, we define we uh we set define a camera that consists of the position, the target, the up vector, the field of view, and the perspective. And the perspective is at the projection, sorry.

[00:30:04]The projection is camera perspective.

[00:30:07]Oh, there seems to be also the opportunity to uh the possibility to create a custom projection.

[00:30:15]Or whatever those are.

[00:30:18]Well, first person, third person, orbital.

[00:30:25]Interesting.

[00:30:27]Let's see if we are going to encounter those later on.

[00:30:32]Then let's close this and begin mode 3D with the cam.

[00:30:39]And if we compile this, it's compiling.

[00:30:42]If I execute it, there's nothing in here.

[00:30:48]Okay, there's nothing in there because we probably need to do something else.

[00:30:56]For example, we begin the mode 3D. Do we ever end it?

[00:31:01]No, we currently don't end it, but I don't even think we need to end it.

[00:31:06]We begin the mode 3D.

[00:31:08]We set the camera.

[00:31:11]But if we want to move, then maybe we need to move this inside the loop.

[00:31:20]Maybe we need to do this.

[00:31:23]Because if the camera is changing position and the angle it's looking at or the the target coordinate it's looking at, then maybe we're going to have to update it in here.

[00:31:37]Inside the loop. Otherwise, we won't be able to move.

[00:31:41]Now we begin drawing something. Begin drawing. Let's figure out and see if there's a begin drawing method for 3D.

[00:31:48]No, there does not seem to be a method for that.

[00:31:52]And how do I now draw anything?

[00:31:56]There is probably something for 3D here.

[00:31:59]Yeah, basic 3D shapes drawing functions.

[00:32:03]Draw a line in 3D.

[00:32:06]Draw a point in 3D. Draw a circle in 3D.

[00:32:11]Um Okay. It's a circle in 3D.

[00:32:17]Draw a triangle strip 3D. Draw cube.

[00:32:20]There it is.

[00:32:21]Draw cube at a position with a width and a height, a length.

[00:32:29]Wait. Which cube has a width, a height, and a length? I thought that cubes are the three-dimensional version of squares.

[00:32:42]But it's probably Apparently, it's the three-dimensional version of a rectangle.

[00:32:51]Wait, that somehow does not make sense to me. Wait. Cube German is Würfel. Würfel is definitely the word for a three-dimensional square.

[00:33:03]Is cube equal cool sided? I know I'm I mean I know what this library function means. I'm just wondering if it's precise or if if my understanding is flawed or if this is a conscious design choice.

[00:33:21]Yeah, okay. So, this AI overview here states that yes, a cube is perfectly equal sided.

[00:33:29]>> [sighs] >> All edges of a cube are equal in length.

[00:33:38]Okay, but then what is a 3D rectangle name called in English?

[00:33:46]It's a cuboid or rectangular prism.

[00:33:53]Okay.

[00:33:54]Never really heard of them.

[00:33:57]So, I assume that this is just a conscious design choice because never nobody would ever be able to properly use a function if it's called draw rectangular prism. Because people just don't know what that is is if you're not a native speaker.

[00:34:16]So, let's draw a cube in this >> [snorts] >> inside begin drawing and end drawing.

[00:34:24]Inside the space delimited by those two functions, draw cube at a position.

[00:34:35]And the position is a vector three.

[00:34:40]Let's create a vector three that's called origin, and that's a position that is just 000.

[00:34:47]And that's the position of the cube.

[00:34:51]And then the length is one, the width is one, and the height is one.

[00:34:58]And the color is red, as always, guys.

[00:35:05]Whenever I try something new with raylib, it's always red.

[00:35:10]And this compiles, and now we don't see anything, and the program is crashing.

[00:35:16]Great.

[00:35:17]What's the error here?

[00:35:19]Matrix stack overflow. Oh, no, I can't even figure out regular stack overflows.

[00:35:24]Why do you give me a matrix stack overflow now?

[00:35:30]Please, don't.

[00:35:32]>> [snorts] >> At least it's recognizing my graphics card. That's nice. I really never spent any attention here. Never really paid any attention here.

[00:35:48]>> [sighs] >> So, hm, target time per frame is this.

[00:35:59]Matrix stack overflow segmentation fault. Okay, now's the point in time where probably figuring things out would take too long. So, let's have a look at the raylib cube example and see what we need to do.

[00:36:17]How to properly use those functions here. There it is.

[00:36:24]Okay, where's the sample code? There it is.

[00:36:28]So, we define a camera.

[00:36:30]It's just zero. This is a placeholder for 000 as far as I know. Then, a Ah, no, it's just >> [snorts] >> No, it's it's of course just a placeholder for the entire structure and then the fields of the structure are populated here.

[00:36:49]>> [snorts] >> Then, the field of view here is set to 45° only. Then, camera perspective is set. Cube position is zero. Just like in my case and a target frame rate is set.

[00:37:01]We update the camera.

[00:37:06]Okay, I don't know if the updating of the camera is needed or if it's just needed if it is changed. Probably, it's only needed if it's changed. But, here we already see that we can define the camera outside.

[00:37:20]And update its position inside. That's useful. Then, we begin drawing. We clear the background. We begin the 3D mode inside the drawing.

[00:37:34]Ah, okay. So, maybe I just need to switch those two functions up. So, we begin drawing first. Then, we begin the 3D mode. Then, probably before we end drawing, we also have to end mode 3D.

[00:37:48]And that's probably just the pattern that raylib requires. So, if I compile this, now it works. And if I execute it, oh, yes, there is a small cube and it looks 2D.

[00:38:01]Probably, because we are not looking at it from an angle. So, we are essentially looking at it exactly at its side.

[00:38:10]>> [gasps] [sighs] >> But, that's already that's already a success. So, we are now in a 3D world, but we're not seeing any 3D effects.

[00:38:21]So, we have subtly mastered the art of 3D already.

[00:38:26]So, Okay, we can also draw cube wires.

[00:38:34]What's cube wires? That's probably the skeleton around the cube, but let's not do that because I first want you to see the effect of the of the current drawing. So, what we currently need to do is we draw it we we create a camera.

[00:38:51]And let's not eagerly not use the update camera thing.

[00:38:57]What do we need it?

[00:38:58]Wait.

[00:39:00]Here, begin mode 3D is called using the same camera, and the same camera is updated in every iteration of the loop.

[00:39:07]I don't know if this is required.

[00:39:10]Why is update Why is update camera required? Because I could just do cam.position.x position.

[00:39:17]x is incremented, for example. I could just change the position x.

[00:39:25]Compile this. Of course, this doesn't work. Why doesn't it work?

[00:39:30]Uh has no member position because, of course, it's it has no member pause.

[00:39:37]That's just how I called the variable here. Of course, it's called position.

[00:39:42]If I compile this now, that works, and then this does not work.

[00:39:53]So, probably Mhm.

[00:39:57]Uh I'm not so sure about that.

[00:40:01]Maybe the camera is somehow read only.

[00:40:05]But that doesn't make sense.

[00:40:07]Because I'm passing a fresh camera here, and I'm creating it every single loop iteration.

[00:40:14]But I would have expected that I can't change the camera, and if we move begin the 3D mode then and the camera changes in each each iteration and we should already see some movement.

[00:40:25]But that's apparently not the case.

[00:40:28]Why? Let's have a look at update camera.

[00:40:32]Update cam here.

[00:40:38]Update camera. We pass a camera and a mode and this updates the camera position for the selected mode.

[00:40:47]What is the mode?

[00:40:54]Because here in the sample I saw that the camera comes with this attribute camera free.

[00:41:03]So maybe my camera is not free and cannot move.

[00:41:08]Camera free.

[00:41:11]Camera free mode.

[00:41:14]Where do we can specify the camera mode?

[00:41:18]Camera camera mode.

[00:41:23]It's not used anywhere.

[00:41:27]Oh, of course, because it's an enum enum and probably it's only referenced in library methods via an integer.

[00:41:37]But apparently >> [sighs] >> not so sure.

[00:41:46]Update camera. Why is this required?

[00:41:50]Is this even required? This is something I don't know.

[00:41:55]Because I'm creating a camera here and then I'm just changing its position.

[00:42:01]Why do I need to specify a free camera mode?

[00:42:06]Really?

[00:42:07]Free camera.

[00:42:31]>> Hmm.

[00:42:33]position.x target up field of view camera perspective camera position.x plus plus that should increment the camera position.

[00:42:52]Wait.

[00:42:58]Let's just Let me just stupidly print the cam.position.x here.

[00:43:06]Just to confirm that it's that it's changing.

[00:43:09]Of course this is This is a floating point number.

[00:43:14]Compile, execute. Yeah, and it is changing as you can see here. However, there was no movement in the running application.

[00:43:22]That's odd.

[00:43:25]And if I call update camera and I pass an address here of the camera. Wait. In begin mode 3D, what's the input here?

[00:43:46]It's the camera. Ah, it's a pass by value here.

[00:43:53]So, the 3D mode does not have a reference to the original camera. And if I change the original camera here I then I I I just I if I change the original camera here and I I have only passed the camera by value into the begin mode 3D, then begin mode 3D of course has no visibility, but of course I'm reiterating every time and passing the new value here.

[00:44:22]Mhm.

[00:44:24]>> [sighs] >> So, I I really don't get why I need to update the camera.

[00:44:29]But let's try to do it and also pass this camera three here. Camera three.

[00:44:35]Uh and let's see if this changes anything. And now it does seem to change something because now we see movement.

[00:44:44]Uh we see really weird movement. How about we zoom in a bit by setting the position closer to the cube? For example, only 5 m distance.

[00:44:56]Now we see a bigger rectangle.

[00:44:59]And there's some movement back there. I don't get what that is.

[00:45:04]What the hell is that?

[00:45:11]>> [sighs] >> What's going on, guys?

[00:45:17]Let's close a couple of tabs. Oh, I need the examples tab, of course.

[00:45:24]And let's go to the 3D cube here.

[00:45:31]And have a look. So, we update the camera.

[00:45:36]We pass the address of the camera.

[00:45:40]And when does this camera even change? The camera target does change if the Z or Z key is pressed and it's reset to zero.

[00:45:54]Else um Wait.

[00:46:11]How the hell does the movement here even change? How does the camera even change?

[00:46:17]Oh, how's this looking around implemented in the code down there?

[00:46:23]I don't see it.

[00:46:29]Update camera. Begin drawing. 3D mode.

[00:46:32]Draw cube. Draw cube wires. Draw grid.

[00:46:36]End mode 3D.

[00:46:38]End drawing. Where is the mouse handling even implemented?

[00:46:44]Is this something that Oh, wait.

[00:46:49]Ah, it's already active by default. So, if I move the mouse now, I see some mouse handling.

[00:46:57]Okay.

[00:46:59]Mhm, I see It seems to slowly click. So, what you are currently seeing is a cube.

[00:47:09]When we move the mouse, we look around.

[00:47:12]There's some new drawing happening here, but because the canvas is not cleared between updates, the background is not cleared.

[00:47:26]You see this line being drawn.

[00:47:28]And now you see I still don't see anything because you I need to compile, of course, and execute.

[00:47:37]And now you see moving away from the cube.

[00:47:41]Aha, but I was accessing only the X coordinate here. So, why is this moving away from the cube?

[00:47:49]So, probably the coordinate system is somehow different here.

[00:47:54]I'm looking I'm at Okay, I'm at at position Ah, I get it. I'm at position X5.

[00:48:00]X equals 5. If I increase X, then of course, I'm moving away from the cube because I am currently positioned at X equals 5. I'm looking at the cube and I'm moving away from the cube because X is incrementing here.

[00:48:18]Aha, okay.

[00:48:23]And I can still look around using the mouse because that's what Yeah, the mouse does this panning around here. Does this looking around. Okay, it slowly seems to click. So, if I don't change the mouse position the following happens. Oh.

[00:48:41]Ah, there it is. You see the Ah, okay. Somehow I can only move the mouse here and if I move it towards the center of the screen the rectangle already leaves the screen.

[00:48:54]That's not very That's not convenient at all.

[00:48:58]Oh, and I can already use the arrow keys here. That's already implemented by Raylib by Raylib. I can walk around the circle at the I can walk around the cube. All All these results are making me crazy, guys. So, we do have We do have a working 3D cube. I don't know I don't get why everything's working, but apparently everything is already implemented in Raylib.

[00:49:24]And I can move away from the cube and toward it. I'm just using the WASD keys here. Probably the left and right and up and down arrow keys also work. Yeah, they do work, but they are very slow.

[00:49:37]>> [sighs] >> And Okay, I get it. Now, the mouse pointer is annoying and that's what disable cursor was for disable cursor.

[00:49:55]Now, let's compile this and execute it.

[00:50:00]And now I Yeah, I can't even move the window because my cursor is disabled, which is not very useful. Can I somehow move away here?

[00:50:13]Where's the application? There it is.

[00:50:15]Yeah, okay, that's not very convenient for my use case because I need to be able to move the window so you can see it.

[00:50:24]Nah, forgot compiling. Now, let's execute it.

[00:50:28]There it is.

[00:50:30]And where's the cube?

[00:50:32]There it is.

[00:50:33]So, now what's left is we have this cube here as you can see in a nice perspective projection.

[00:50:44]That's nice.

[00:50:45]And then what's missing is we want to draw the wire frame of this cube. Let's search for cube here.

[00:50:54]Draw cube.

[00:50:57]Draw cube and draw cube wires. There it is.

[00:51:02]Let's do that down here as well. Draw cube wires.

[00:51:07]And the cube wires are also located at at the same position.

[00:51:12]And they have a width and a height and a width and height and length that is equal to the original cube.

[00:51:23]And a color and that color is white.

[00:51:29]And if we compile this now, we should have a cube here, perfect with a wire frame around it.

[00:51:38]How can I move above the cube? I probably have to fly upwards somehow, but the mouse is exiting the screen. Yeah, okay.

[00:51:48]Yeah, all right. I guess guys I guess can we call it a day? Is there anything else you want me to do?

[00:51:59]>> [sighs and gasps] >> I actually like the result very much.

[00:52:05]I preferred to this one here with this ugly coordinate system.

[00:52:10]So, this is quite a raw result.

[00:52:13]It's apparently if you understand it once how it works, in raylib it's quite simple to create a 3D object and move around it.

[00:52:22]That's quite nice. So, that's our result. Now, we could easily extend it if you want in another episode and we could place a new block next to this one and then another block next to this one and then a block on top of this one and then we already have a Minecraft clone that's almost indistinguishable from the original Minecraft. Well, well, well, there's so much stuff that we can do in 3D. Put your ideas in the comments and if you want to learn C from scratch and be able to create these projects yourselves and create real useful C projects that are not boring and um useful actually, then have a look at the No Nonsense C programming course that's linked in the description below the video. It's a course that takes you from zero C skills to quite capable C along with terminal skills and everything that everything that I do here you will be able to do perfectly fine yourselves without boring PowerPoint slides, only practicing.

[00:53:28]We We're only only going to explore stuff in the terminal and I give you practice exercises and if you follow them, I promise you the difference from before and after the course will be night and day.

[00:53:43]So, I also show a couple of tricks um terminal tricks and mental models that I use on a day-to-day basis. So, it's not just C, it's very very useful computer knowledge in general.

[00:53:57]So, have a look at that. It's linked under the video. Aside from that, I hope you guys enjoyed it. It's quite a simple project, I admit it.

[00:54:06]But, it's a project that allows us that allowed us to initiate the flame >> [snorts] >> that or to to spark desires for future C 3D projects.

[00:54:24]>> [gasps] >> All right, guys. I'm not going to talk >> [laughter] >> anymore and bore you to death. So, see you in the next episode. Bye-bye.