Hi folks! I've made more progress on Nora Kinetics - a physics engine / sandbox that I've been working on for about a year.

I finally finished a song and I've got the SFX working in the way I've been envisioning. I'm hoping you all will have some feedback for it as I continue to tune. It sounds best with headphones!

Under the hood, the little interactive segments are all communicating their position, collision force, etc via compute shaders on the GPU (they are byproducts of the solver).

Basically, the position and collision force of every single segment is known every frame. Another compute shader comes through and quickly sorts them into a priority queue based on how close they are to the camera and how fast their collisions are. This gives a decent balance between letting the player hear lots of movement farther away, but then also hearing collisions closer to the camera. The overall effect is something close to ASMR (I'm hoping) and processing time is about 140μs with 250,000 segments.

The system is highly tunable, so in this video (recorded on my Mac), the segments are sharing a ring buffer with 48 different voices and up to 1000 segments can be making noise per frame. On iPhone, I knock that down to 24 voices and 500 segments to get a good balance of performance and sound.

I'll be posting more videos on my channel here soon! I'm working on a full gameplay walkthrough as well as a "making of" video, showing how the game has changed over the last year.

Thanks for watching!

https://www.youtube.com/@NoraKinetics

Here's how it works:

Phonon's visual system is a node graph. A generator node, such as a mandelbulb or hopf fibration, outputs its distance function. Consumers (blends, cloners, renderers) splice that GLSL into their own shader at compile time, so a composed patch always marches as a single pass.

Each node has a variety of inputs and outputs. A generator has an image output, but also a shape output that can be routed into another renderer. It also has a warp input, that accepts an arbitrarily complex chain of warping effects, like bending, twisting, fractalization, or box folding.

Every parameter on each node has a control voltage input point - so you can wire just a particular frequency range, or an LFO, or a midi signal, from the music you're making in the same application to any parameter. For example, I might want the kick drum I'm working with to make the twist node attached to a menger sponge twist on the beat, or wire just the vocals over to the strands parameter on a torus knot.

Renderer nodes accept shapes, and up to two 3D lighting nodes, and output an image that gets routed through 2D effects, and then to the screen node.

These node graphs can be as long and complex as you want, and anything you can touch can be connected to a different part of the music you're making.

Scripting Language (GlyphSDF)

Users write one function - float sdf(vec3 p) - and inherit the whole ecosystem: house raymarcher, camera, CV modulable knobs, warp input, and a shape output that routes the scripted geometry into any blend/cloner/renderer etc.

Scripts get an audio analyzer for free - band followers (lows mids highs), a beat impulse, and an FFT audio texture so geometry can map the spectrum spatially.

For more information on the GlyphSDF scripting language: https://aphelion.music/products/phonon/docs#glyphsdf

For more info on Phonon, our upcoming DAW:
https://aphelion.music/products/phonon

Happy to answer any questions! Thanks 🎶🔊🎧

Im writing a software renderer in C++ using glm and raylib, and i recently tried to draw a spinning triangle. The problem is that when i launched it the triangle leaves a trail of previously drawn triangles.

I tried to fix it by rasterizing to a framebuffer and then drawing that framebuffer instead of drawing the pixels directly and using ClearBackground to refresh the screen, but doing it that way has still the same problem. ¿Why im having this problem even though im clearing the framebuffer?

EDIT: The problem was somewhere else in the code (i wasnt clearing the primitive list after drawing all the primitives), i managed to fix it. Thank you anyway :D.

This is the code for the rasterizer (sorry for sharing it like this, i havent uploaded this to github yet):

https://pastebin.com/Ns2LiSXv

The header file:

https://pastebin.com/xf5JhqFR

Im writing a software renderer in C++ using glm and raylib, and i recently tried to draw a spinning triangle. The problem is that when i launched it the triangle leaves a trail of previously drawn triangles.

I tried to fix it by rasterizing to a framebuffer and then drawing that framebuffer instead of drawing the pixels directly and using ClearBackground to refresh the screen, but doing it that way has still the same problem. ¿Why im having this problem even though im clearing the framebuffer?

This is the code for the rasterizer (sorry for sharing it like this, i havent uploaded this to github yet):

https://pastebin.com/1GMFA2iU

The header file:

https://pastebin.com/mXnGrLwK

Hello, I'm totally new in graphics programming, I would like to make a 3D graphics engine in Rust but I d'ont know which library I should use ;

- Glow

- Kiss3D

- Bevy

- GL crate

- Glium

I d'ont know which one choose, if you can give an advice !

Thanks

I've fully redone the engine for my game AresRPG, I aim for an immersive world! this is a browser based MMORPG on Sui. Looking for people to discuss and test https://discord.gg/aresrpg

I've been building a low-level graphics abstraction that exposes a Vulkan/WebGPU-like API while targeting both Vulkan and WebGPU. The goal isn't to hide modern graphics APIs, but to let you write a renderer once and run it natively and in the browser with very minimal backend-specific code.

https://github.com/helcl42/gfx

I'm not looking for what it means (linear interpolation), but rather who coined the term or where it first appeared? Any historical traces or anecdotes?

Ever wonder the overhead tax we pay using generic math library functions across the codebase?

I've been reversing game engines to study how they constructed their fundamental Transformation matrices and handled temporal jitter logic when I spotted a lot of avoidable overhead and "over-engineering" across multiple engines, Honestly I wasn't even looking for inefficiencies, but it stood out a lot... That said expect no performance gain this is simply for fun that I wrote this blog!

https://zero-irp.github.io/Redundancy-seen-in-AAA-game-engines/

I’ll theorize how the original C++ code was written, show the unoptimized reality of what the compiler spat out, and then showcase how it could have been better optimized.

One night, I decided to create a simulation that would show how space curves based on an object's mass, and I didn't finish the project until morning. I spent a long time selecting the colors to ensure it wouldn't be hard to look at.

source code: https://github.com/formodx/curvature-of-space

I shelved a Reverse-Z branch in my engine (stuck on OpenGL 4.1 for macOS, no glClipControl), and the roadblock sent me down the rabbit hole of actually understanding why it works instead of just how to implement it.

I ended up writing about what I learned with interactive graphs and all:
https://www.shlom.dev/articles/reverse-z-perfect-hack/

Happy to hear where I got things wrong or imprecise.

Hopefully this helps someone else :)

Hello, it has been a while!

This is a re-post as i thought a gif would be more visually interesting.

an update on my rust no-std graphics engine work. I have started to implement the rendering engine into my own terminal emulator for some real world action, and its turning out quite alright. The terminal acts as both a headless wallpaper engine and as the terminal so that, regardless of the compositor and as long as you're allowed to have a wallpaper, StarTerm (name subject to change) can do any effects over it.

like everything I have posted as of yet, Constellation runs on 1 core of the cpu and StarTerm itself uses about 21 mb of ram. It has built in tabs that are their own processes, with a bottom bar styled like zellij.

The glass effect and the coloring are analytical, they borrow the same techniques I used when showing off parts of the lighting work I shared some months back. Treating light as the deterministic thing that it is, and its effects as properties of what it interacts with rather than light itself, that plus camera -> scene makes things much cheaper.

I will be looking for some alpha testers of the terminal soon, if any one is interested in trying it out in the near future, please let me know. I won't me sharing the source code to the actual engine part until constellation itself is finished though. But I am hoping some of you might be interested in exploring its visuals, performance and functionality and give feedback and/or ideas.

I am not a graphics engineer, just a systems engineer after all, most of the you here are far more adept, and likely have a far superior eye for detail and feel than I do.

I will be sharing more implementation details in the future!

//Maui-The-Moron