I am going to teach you how to draw a 3D object.

I'm going to start with some useful information about the project bellow. First, it takes about 10 - 15 seconds to generate the map. Second, use WASD to move left, right, forward, and down and use space and right shift(not left shift) to go up and down.

To start, the only type math used in this tutorial is linear equations. You will still be able to use this tutorial and render your own 3D objects if you don't know linear equations but it may be more challenging and you likely won't understand how 3D projections work. Ok, now that were done with that, lets figure out how to project a 3D point onto a plane(a flat 2D surface). The reason I used the word project is because you take the point in 3D space, than you draw a line to the player's eye. From here you find the x and y point at z 80. Any position at z 80 is going to be referred to as the canvas. The number 80 after z would be represented by a variable player_fov aka the players field of view. This variable will be used in the equations. Than from there you would draw that point at that position on the screen. The way to sum that up would be your projecting a beam of light from a 3D point and seeing where it hits the players eye. Now lets get into the math that projects the object.

Here's a good image that helps shows what my program dose to project a vector3(x, y, z) point onto the canvas. The link to the website the image was taken from is right bellow the image and it also was the most helpful website for me when it came to learning how 3D projections work:**Computing the Pixel Coordinates of a 3D Point**

And this gif further explains it:

Step 1, the first step is to remove b(the y intercept) from the equation:

y = mx + b

This will make projecting the object easier. To do this I am going to use a few variables, object_x(the x position of the object), object_y(the y position of the object), object_z(the z position of the object) and player_x(the players x position), player_y(the players y position), player_z(the players z position). The outputs will be new_object_x, new_object_y, and new_object_z. Those outputs will be used in all the equations. Now onto the equation to remove b:

new_object_x = player_x - object_x

new_object_y = player_y - object_y

new_object_z = player_z - object_z

Step 2, now we will find the y position of collision on the canvas(defined at the top). The output will be screen_y and the variable m is the slope. The equation to do this is:

m = new_object_y / new_object_z

screen_y = m * player_fov + object_y

Step 3, this is the final step and gets the x position of collision on the canvas. The output will be screen_x and the variable m is the slope. The equation is:

m = new_object_x / new_object_z

screen_x = m * player_fov + object_x

If you don't want to write any code yourself than this is the code to project a 3D point written in python3:

```
def convert_3D_to_2D(vec3_pos):
vec3_dist = [vec3_player_pos[0] - vec3_pos[0], vec3_player_pos[1] - vec3_pos[1], vec3_player_pos[2] - vec3_pos[2]]
try:
m = vec3_dist[1] / vec3_dist[2]
except ZeroDivisionError:
m = 0
y = m * player_fov + vec3_pos[1]
try:
m2 = vec3_dist[0] / vec3_dist[2]
except ZeroDivisionError:
m2 = 0
y2 = m2 * player_fov + vec3_pos[0]
return [y2, y]
```

You now are done with the math! And congratulations on finishing the tutorial! I hope this worked for you and if you have any questions or need help than feel free to ask in the comments.

Here's some images of a 3D map made using perline noise rendered using this 3D projection method and ran without a maximum render distance on my computer(not on repl):

And here's some more images of the world(not ran on repl) using my ray tracing lighting system that traces a ray from each point to the sun and check to see if it collides with anything. This feature is to slow for repl and will not be implemented. In this image I was getting around 0.3 fps:

The project bellow is the same code as used to create those images except repl runs pygame very slowly and therefore I had to implement a maximum render distance to allow you to move around the map in real time. Another feature in my project is a smoothish lighting system. Basically I subtract the height of one of the three points on the triangle being rendered from another. Than I used the clamp function shown bellow to limit how much darker or brighter an object could be. This function is also written in python3:

```
def clamp(value, min_, max_):
return min(max(value, min_), max_)
```

After doing this I add the new value that I generated to the r, g, and b color before clamping each of the values to be within 0 - 255 using the same function shown above. I also have one more tip that may help, only draw a triangle if all of the three points x and y positions are grater than 0 otherwise there will be weird lines when you pass an object. One final feature in my program is a noise function. This creates the terrain that is rendered to the screen smoothly. First off, this is not an actual perline noise algorithm but it still creates smooth terrain. The way this function works on a basic level is it goes from the bottom left to the top right and on the way it gets the average height level of the terrain around it(If there is no terrain around it than it sets its height to a random value). It than choses a random value from a range of values till the value is a certain range(this range is random making the heights of the terrain even more random) away from the average terrain height. When it finds this height than it adds the height to a 2D array. I also added a chance to spawn a peak and if it dose than the height is forced to be a lot higher than the average creating a jump in the height of the terrain around it. That's all it takes to recreate the noise function. A tip to create a 3D game is to use a mesh(a list of shape positions that creates and object when rendered) and use a triangle as the shape it renders. Another useful tip is to order the terrain from top left to top bottom so when rendered the terrain will not overlap and create a weird visual bug. I will be updating this tutorial once I added in camera rotation so you to can look around you world at more angles than now. I have also started a ray tracer and have put the prototype on repl, the link is bellow. And finally, with all this new found information, you should be well enough equipped to create your own 3D game or game engine from scratch. Good luck!

Interesting facts:

There are 22500 polygons(triangles) in each map

There are 67500 vector3(x, y, z) points in the entire map

Good sources from learning more about 3D projections and the math behind it:

Computing the Pixel Coordinates of a 3D PointThe Geometry of Perspective ProjectionHow to convert a 3D point into 2D perspective projection?My Original Post Of This Project That Describes More Of The Python3 Code I UsedClick Here To Go To My Ray Tracer

Even though this is python, this is still really cool! Nice!

@EpicGamer007 Thanks!

Really cool would be an *understatement* for this! Amazing job!

@jeweledfox Thanks!

I’m crying you make it sound so easy why did I never learn this

Its not easy, it took me like ten hours. I can help you learn how to do it if you want. Also, during the ten hours the funniest thing happened and when I move to the left the entire world would become a burrito. It took like 2 hours to fix.

@Highwayman I'm still working on a bug where when you go bellow the ground the ground flips upside down and comes to the player. I'm also working on a ray tracer that is taking years to run.

@Highwayman I've also been working on a new lighting system that took like 4 hours because it uses ray tracing, obviously ray tracing is not possible in real time on repl.

Lol a burrito 😂 I kinda wanna see that.

I can help you with the speed problems. I can take your calculations and transfer them into C++ imported functions so that it runs faster, that might help. It’d be interesting to see how that worked out.

Also yeah! That would be cool!

@TurtleAndrew

@Highwayman That would work, the main reason it's slow is I'm using ".index" and "in" on a list of objects which is super slow. I need to find a faster method of detecting collision. The tracing of the rays is super fast, I used the ray tracer using a different collision detection method for lighting on the 3D projections program and it still runs well. I did not add it to the one on repl.

@Highwayman I dont have any images of it being a full burrito but here's an image of it starting to turn into a burrito.

@TurtleAndrew fyi that was a flat square not curved.

@TurtleAndrew fyi that was a flat square not curved.

@Highwayman Also, the ray tracing light system doesn't take 4 hours to run, it took that long to make.

@TurtleAndrew Here's what that lighting system looks like.

Looking at the burrito beginnings like oh no here we go lol.

Ohh I was confused ye I did think you meant how long it was running like a hyperbole.

Aye that’s nice, it also has a lot more color it seems?

@TurtleAndrew

@Highwayman That was a very old image.

Ope really I think I’m forgetting things oops 😬 @TurtleAndrew

@Highwayman its all good. I also did fix the burritoing. It would go full burrito. I dont have that old code or any more images of the burritoing.

@Highwayman I just got reflections working on my ray tracer.

@TurtleAndrew I also fixed a mathematical error and am running it again. I was averaging colors and added 5 and only divided by 3 not five.

@TurtleAndrew i do know how to add the burritoing back in i think

@TurtleAndrew It worked but didnt because of other changes, i just needed to make one of the 1D lines 3D

Wait so you can just make it burrito now whenever like hey XP

Ya know I never fully understood what ray tracing is

for, cause it’s like some people are telling me it simulates gravity basically and others are like it’s just f’ing graphics deal with it and others... well yeah, hard to get a handle of lol.Oof reminds me of my last math test lol I forget exactly what I did, but I do remember that I did like 2+3 = 7 or something ridiculous like that and my teacher was like where is your logic, d~a~.

@TurtleAndrew

@Highwayman For ray tracing, you baiscaly cast rays for each pixel on the screen from the player and see where it collides, here some links that may help you understand how it works:

Click here for a ray tracing tutorial that helped me

@Highwayman I can kind of make it burrito whenevere but i made a change at some point that will stop it from going full burrito. I basically need to make a 1D line a 3D line using the Pythagorus theorem.

@Highwayman I can teach you the math for ray tracing and 3D projections, they are really similar btw.

@TurtleAndrew Also, ray tracing doesn't simulate gravity but it dose simulate light allowing for reflections, refractions, and transparency. It also takes like a year to run :(. I still have to wait like 30 more minutes for it to run with fixed reflections.

@TurtleAndrew This gif might help, its from this website:

@TurtleAndrew Also, sorry but i never had the burritoing happen with my ray tracer. Just think though how cool it would be if it did happen on my ray tracer.

Lol a burrito if Ray tracer. The reflections just start lifting off the ground 😜

That gif was super helpful, ye!

Makes sense I was a little skeptical when they said they were using it to simulate gravity lol.

They seems to be ye because that gif is kinda looking like what you talked about in the tutorial ye that’sbe interesting.

@TurtleAndrew

@Highwayman Yes, the tutorial is explaining that image and also going over the math to do what the image dose. If i can find the math to make a burrito shape than i could ray trace a burrito with refection and all. But the requires finding the outside points on a flattened circle.

@Highwayman Also here's the most recent render from my ray tracer including two mirrors and two walls:

It seems to be coming along quite smoothly, not counting the burrito of course XD @TurtleAndrew

oof wow I haven't been on repl.it for a MONTH

@Highwayman Yes it is. I also finished the ray tracer and created a ray marcher which is the same thing but uses more math so it can run quicker. Also on the ray marcher you can move your camera around and it gets 60fps(this is only the one i programed on c++ the one on python takes 2 minutes to load because python is slow)

Haha yup that’s python for you lol.

Is that just because you only added the moving camera feature to the ray marcher or is it because the ray caster just can’t handle it?

@TurtleAndrew

@Highwayman It's because the ray marcher is the only one i also made on c++ and c++ is like 10000000000000 time quicker than python.

Makes sense. @TurtleAndrew