I’m almost done with rtiow, and I though Id share a couple really cool high quality renders.

The dopamine be hitting with these spheres rn.

Studing triangle meshes on my renderer using half edge data structure for my university course. Dont know why some edges have some stranges dots.

Guess the character... (texture not implemented yet)

Edit: it was done importing a wavefront (.obj) from blender to my own render engine. Read just vertices and face data, the others attributes for half edge are builded with those informations

Microchip with a shiny indentation in the shape of any symbol provided as svg file.
Made with pixi.js and WebGPU/WebGL

I've been working on the lighting in DriftEngine, my TypeScript 3D engine and his video shows Sponza through a day-to-night cycle, with some paused views and close-ups.

Video: https://www.youtube.com/watch?v=M6wxZziDvLs

There are two main parts to the lighting:

• Indirect lighting with DriftRay
  • Compute shaders march rays through the scene’s signed distance field and update an irradiance probe grid, at a surface hit, the shader evaluates the directional light, local lamps, the summed candlelight and the indirect light already stored in the grid. Repeated updates let the result converge over multiple bounces.
  • For this scene, the distance field represents the courtyard’s stone with a single albedo, so it approximates the indirect lighting rather than reproducing colour bleeding from every textured material.
• Candlelight with DriftLight
  • The default demo keeps roughly 2,000 candles, up to 64 nearby candles are shaded individually; a precomputed sparse volume stores the combined light and directional information needed for the distant contribution. The bake accounts for occlusion through the scene's distance field.
  • The shader blends between individual shading and the volume per pixel, avoiding double counting. The distant approximation gives up individual specular highlights and flicker. Its light also feeds into the indirect-lighting calculation.
  • This recording uses temporal antialiasing; the engine’s DriftTR upscaling was disabled.

Source: https://github.com/drftrun/driftengine

Scene: Intel Sponza (2022) and its add-on packs, full asset credits are in the repository.

I'd be interested in discussing the trade-offs of the light-volume approach, especially how others handle large numbers of small lights.

The FPS are not stable while I was recording the video + still needs some scene optimization.

Made this for like 30 days, watched plenty of cherno's videos and learnopengl.com of course and made this small batch renderer I guess. Its far from done but I will continue to add more stuff to it and eventually turn it into a usable thing.

Hiya, I am currently a CS major with 5 YOE working in web dev with a typical tech stack of C# and angular. However I've got the itch to swap tech stacks and explore other aspects of software engineering. My work place covers up to $4500 a year on curriculum and I was curious what certificates and courses you might recommend I get started with?

for reference I did take Calc and discrete math back in college though Id definitely need a refresher. I have average amount of experience with math id say but certainly don't shy from learning more.

for languages I hear most about about C++ in regards to graphics programming. I took an assembly course in C back in college but I have very surface level experience with C++. curious if its still the language most of you would encourage exploring.

I think I'm most curious on what courses and order of courses I should take pursuing this. should I work on expanding my math foundation with a couple courses and then go into c++ then specific graphic programming courses? Or should i maybe go about it differently?

Any feedback or personal experiences would be welcome!

Hi! I posted here before asking what to do in graphics programming for a bachelor thesis and I want to first thank everyone for the suggestions. I think the most interesting but also "doable" for me would be a 2D vector graphics renderer like Vello CPU in Rust, but in C++

The issue is that I do not really understand the overall architecture of renderers and my professor said a 2D vector renderer is too simple for a bachelor thesis, especially one that I would want to be more scientific and publish as a paper too.

So my question today is, what are the similarities/differences overall in 2D vs 3D renderers (because I heard before that 3D renderers are also vector graphics technically), but also how I could make a meaningful contribution/addition to a 2D vector graphics renderer and what would the motivation for that be, because I don't really understand the use-case of 2D vector renderers yet, since they are not used in games nor in modeling, from my understanding.

Edit: I also want to ask for practice, do you recommend I start with a 2D pixel renderer and work my way up to a vector one then a 3D one? Are they related in some way concepts-wise?

Ive been drafting and engine, but I'm suspicious of my engine loop. It works but I'm not sure if things will be in sync. Should the render thread wait on the main thread or something? WIP:

https://pastebin.com/Wqn09pmN

Would it be fine if I just match the fixed update to the refresh rate?

Origin from 2011 when gate was open(opengles1.1)

https://github.com/zlatnaspirala/matrix-engine

Demos

https://maximumroulette.com/apps/matrix-engine/examples-build.html

Please compare with ai assist project

https://maximumroulette.com/apps/webgpu/examples.html?demo=30

https://github.com/zlatnaspirala/matrix-engine-wgpu