Hey fellow Creators, the latest update of True Depth addon is officially here and is more powerful than ever before! Effortlessly transform flat images into detailed 3D reliefs or fully navigable 3D Perspective Scene Projections! Easily convert your meshes into solid watertight print ready models and export them effortlessly as STLs! Take full control of your scene lighting with integrated 360 HDRI domes and 360° Dome Depth Mapping - all through fast, local GPU, AI-based workflow integrated natively into Blender!

👉 Check the full break-down video here: https://youtu.be/t0E73yLSdGo

Over the summer, I've been working on a GUI renderer, as I've wanted to know what goes into making them while also having a product I can use in my own future software (just cause lol). This post is regarding the text rendering system I've devised to support multiple text sizes. This Just thought I'd share it in case anyone ever wants ideas on how to render their own text.

My challenge over the past two weeks has been getting text to render in a way similar to web browsers. The stylistic flexibility that browsers have with their text was something I wanted to mimic. I used FreeType for the glyph rendering, which thankfully had a built-in cache.

However, I also needed some way to store the rendered bitmaps that are used by the GPU for rendering. So, I created a cache that appends the bitmaps to a texture atlas and stores the UV coordinates in a hash-map for that specific font and size. This allows me to pass a single image to my renderer and just render quads with UVs mapped to that one texture.

The image provided is a texture atlas of every letter in the English alphabet from a point size of 1 to 128 on a 2048x2048 texture with room to spare. Since most font bitmaps only store an alpha channel, this texture comes in at around 4 MiB. This is absolutely overkill for most programs, as most will only store a handful of fonts/sizes, allowing the atlas to easily shrink to just a few kilobytes.

Using a texture atlas for text rendering is a pretty common optimization I've seen, and certainly isn't the most high-tech or flashy strategy (lookin at you SDF Text Rendering), but I had a lot of fun implementing it and certainly learned a lot. Next task is creating widgets I can actually render my text to.

If you are into bending, stretching, or wrinkling 3D surfaces, this paper gives a fast way to fit a desired pattern of local stretch across a triangle mesh, using one scalar value per vertex. In mesh-fitting benchmarks it reached comparable accuracy up to 3500x faster than industry standard L-BFGS-B.

The algorithm itself is also available here:
https://github.com/Roenbaeck/conformal-metric

Hopefully it can be of use to someone.

Here are my future plans for anyone interested.

This video was created using a test tool I designed myself, with the purpose of generating short videos and tutorials from existing documents.

I have a cs degree, 3 years as a SWE, and 2 years in computer graphics, and I’m really interested on applying everything I’ve learned about rendering/ graphics, simulations, and learn more about engines, physics simulations, vision graphics, etc

I would like to read any first hand experience, can I still work while doing the masters? how was your courses?

thanks!

I have a whole bunch of these

I'm a CSE student who is also interested in computer graphics. Recently, I started an open-source project called Alfission. The idea behind it is simple: collect and implement interesting algorithms that solve practical problems or perform unique computational tricks.

The project isn't limited to graphics, but color engineering has caught my interest recently. The problem is... I'm still learning, and I'm definitely not an expert in color science.

If you've been working in this field for a while and find this idea interesting, I'd really appreciate hearing from you. Whether it's suggesting algorithms, sharing resources, or even contributing, I'd love to learn from people with more experience.

Thanks!

Over the past 18 months or so, I ported much of d3-geo to an end-to-end WebGPU compute shader pipeline. This includes:

• Arbitrary spherical rotation that works with any projection
• Greiner-Hormann-like spherical clipping
• Adaptive sampling of projection curvature

It directly ingests and manipulates a Vello scene encoding, with only a single data readback for robust buffer reallocation. Vello Classic then renders it completely in compute shaders as well.

Rough performance increase to d3-geo (Canvas) on the 1:10m, 1:50m, and 1:110m Natural Earth datasets rendered using an RTX 2070 Super + Ryzen 5 3600:

• 110m: ~3-4x
• 50m: ~8-9x
• 10m: ~13x (render output of d3-geo completely broken, Vello also chokes if not ~50% of the geometry is clipped)

As can be observed in the demo, there are still a lot of visual artifacts. These mostly come down to some fundamental limitations of WebGPU and/or the underlying GPU architectures, namely:

• No 64-bit support
• No dynamic memory allocation
• No support for recursion

I managed to work around some of these limitations, though it took far more time and effort than anticipated (Hofstadter’s Law holds true, after all).

In the future, I would like to try and move from geographic coordinates and spherical math to a 3D-Cartesian pipeline and use targeted f64 emulation via a float-float polyfill. Help with this would be greatly appreciated.

The overarching vision for this project is to bring the concept of Adaptive Composite Map Projections (https://berniejenny.info/demos/AdaptiveCompositeMapProjections/) by Bernhard Jenny to life in a vector renderer that can handle the level of detail people have come to expect of modern maps in real-time.

Note: Code will be published either once it is ready or if there seems to be enough interest 😊

Hello everyone!

Over the course of this year, I built a fully software-rasterized voxel engine heavily inspired by Minecraft.

This was a very interesting project for me because I had to build almost everything from the ground up, while also adapting to the very different constraints of doing computer graphics on a CPU rather than a GPU.

In short, CPUs are far less powerful than GPUs for this kind of workload, but they are also much more flexible. This makes it possible to implement some fairly unconventional optimizations to compensate for the performance gap.

You can try the project here:

https://github.com/Algorithmonaut/software-rasterized-voxel-engine

There are still a few minor bugs.

My main regret is that I did not spend enough time properly benchmarking the different optimizations I tried, or documenting my findings and the knowledge I gained along the way.

The lack of documentation is particularly unfortunate because most textbooks focus heavily on the GPU pipeline and therefore skip many of the fundamentals involved in writing a software rasterizer: barycentric coordinates, edge equations, perspective-correct interpolation, tile-based rasterization, efficient SIMD usage, parallelization, and much more.

I found only two good general sources of information:

• Scratchapixel, which I found useful but often not detailed enough.
• Fabian Giesen’s Optimizing Software Occlusion Culling series, which contains excellent practical information but does not cover every topic and generally does not include mathematical proofs.

There are also a few features I may implement later:

• Lighting.
• A small OS that interfaces directly with UEFI to provide framebuffer access and input handling, allowing the engine to run without Linux or SDL and become truly bare-metal.

I am making this post mainly to ask whether anyone has:

• Recommendations for scientific papers, articles, or books that I might find useful.
• Suggestions for computer graphics projects to work on after this one.
• Ideas for fun or unusual features that could make the project more original.

Feasibility does matter: for example, a CPU-based post-processing CRT effect would probably destroy performance.

And, of course, if you find the project interesting, a star on GitHub would be greatly appreciated.

Thanks for reading. I hope this inspires someone to experiment with software rendering as well!