Ask HN: Where do I start with first principles in 3D rendering?

> 1. Create a window 2. Render pixels in that window that allow 2D/3D space drawing/coloring. 3. Create some basic shapes from a square to a cube and further real-time transformations. It can't be that complicated can it? Hah.

All this really depends on what language you want to do this on. (A viable example on Java)[https://youtu.be/KA6rJZOfTTQ]. I think what you want is basic software rendering, so be advised: software rendering gets really slow really fast.

I tried something akin to this a couple years back l, it didn't end too well, but I learned a ton in the process, feel free to (take a look )[https://github.com/jonnelafin/PB3D], but the code is crap, so I think you are better off on writing your own.

Also these are some wikipedia articles on perspective transformations etc:

(Perspective projection)[https://en.m.wikipedia.org/wiki/3D_projection] (Perspective projection -> Mathematical formulas) (Rotation matricies)[https://en.m.wikipedia.org/wiki/Rotation_matrix]

https://playground.babylonjs.com/ is nice to dabble and you can start right now.

You already know about shaders and pixels, but I really recommend doing a blender tutorial to understand the pipeline from modeling to computer graphics. There is a lot of shared terminology.

Aside from that, modelling can be immense fun.

First thing you'll need is to somehow open a window in your preferred OS and language and get a simple "hello triangle" (many tutorials for that) running in any OpenGL version.

There are OpenGL bindings for most languages, so pick the one that gets you started fastest. I usually use Windows with C (through the raw win32 API - which isn't everybody's cup of tea and can be somewhat confusing), but maybe there are XCode projects that show a simple window with an OpenGL demo in Objective C or Swift.

Also if you're familiar with the Java world (maven, etc.) you can use LWJGL, which provides really simple Java wrappers around the OpenGL C API.

Once you have the window up and running, you should understand how GPUs actually work. GPUs are basically separate CPUs at this point, but they also do something that's tough to reproduce on a CPU: they do rasterization. That means they take a bunch of triangles, expressed as floating point numbers, and splat them all together onto a regular integer-based grid (your framebuffer for your monitor or game window).

The bare minimum for OpenGL 4.x is two shaders: a vertex shader and a fragment shader (fragment just means "pixel" unless you do more advanced stuff like multisampling antialiasing etc.) The bare minimum vertex shader just takes a vertex and passes it through unchanged. The bare minimum fragment shader sets a color and takes no input. Fragment shaders run after rasterization. That's why they operate on pixels. Vertex shaders run before rasterization.

Of course the GPU also does nice stuff like interpolating per-vertex values across each pixel of the triangle. That's why so many "hello triangle" delos show a gradient across the triangle. It's an easy easy to show off that feature (which is important for textures later).

I'd get away from thinking in terms of pixels/shapes/solids. There are higj-level wrappers around OpenGL that do such things (like Java3D), but are you really learning graphics if you don't study the bottom levels?

If you really want to start with 2D, I suggest going through all the steps of setting up OpenGL, and then just render two textured triangles forming a quad covering your window. Then to draw to the window in 2D, you just write to the texture buffer and re-send it to OpenGL. It's more work, but you'll be more confident going into real modern 3D stuff.

Hopefully I've given you some ideas. I think you're somewhat torn between low-level and high level, and I regret to inform you that you really can't easily have both out of the box, and you should probably start at the low-level.

Although, there are maybe some simplistic 3D engines like OpenScenGraph that might be close, in some ways, to what you want.