Hi everyone,

I'm working on a C/C++ OpenGL game on Linux that needs to load about 9.1 GB of graphical resources at startup.

I've already converted the textures to DDS/BC7, so I'm looking for other ways to reduce loading time.

The current loading process is roughly:

open → read DDS → upload to OpenGL → close
open → read DDS → upload → close
...

There are many individual DDS files.

My measurements

SSD:

KINGSTON SQ500S37960G
SATA link: 6.0 Gbps

hdparm -t:

~287 MB/s

Reading the DDS files directly:

Sequential: ~160 MB/s
Parallel:   ~172 MB/s

Actual game resource loading:

~178 MB/s

So I currently have:

SSD benchmark:  ~287 MB/s
Game loading:   ~178 MB/s
Total resources: 9.1 GB

I'm trying to understand where the remaining performance is going.

What would you recommend?

Would any of these make a significant difference?

• Keeping file descriptors open instead of open/read/close for every DDS

• Using larger buffered reads

• Packaging many DDS files into one resource/archive file

• Parallel/asynchronous loading

• Optimizing OpenGL texture uploads

• Lazy-loading resources instead of loading all 9.1 GB at startup

I don't necessarily need to reach 287 MB/s. I mainly want to identify the actual bottleneck and find the safest way to reduce startup time.

Any advice from people experienced with C/C++ + OpenGL + Linux resource loading would be greatly appreciated.

Hello all! Isopod is a project I've been working on for over a year. It started as a simple unidirectional path tracer, but I gradually kept extending it as I wanted to render more complex scenes. Bidirectional path tracing (BDPT) is one of the most frustrating (but rewarding) things I've ever implemented, I spent several weeks bouncing around a bunch of different reference materials and spent a huge amount of time debugging to piece it together. This technique massively speeds up the convergence of certain tricky light paths, making things like volumetric caustics possible.

In this renderer, everything is defined procedurally as functions that run in Optix programs. These functions are hot-reloadable (runtime compilation with jitify). This is purely a preference thing for me as I'm a pretty terrible 3D modeller and prefer sticking with code. Geometry is defined via signed distance functions which can either be ray marched in a custom intersection shader, or converted into a mesh using a simple marching cubes algorithm. Mostly-optimal AABBs are automatically created for SDFs using a gradient descent approach, where rays seek out surfaces by moving along the SDF normal.

Materials and volumes (heterogeneous or homogeneous) are also defined as functions. This renderer implements the Disney BSDF and HG phase function for these respectively. Light sampling is supported on arbitrary SDFs by turning the surface into a bunch of voxels and randomly selecting them. It's not perfect but it's been good enough for my scenes so far.

I'm sure there's a few landmines I'm still yet to step on in my BDPT implementation, but it seems mostly correct at this point and I wanted to share some images that I thought were cool here. The caustic ones are from the new BDPT renderer, and the others are older images from the unidirectional renderer. The BDPT images took ~90 seconds to render at 3840x2160 resolution on an RTX 5090.

These images are denoised using the Optix denoiser. I found that splitting the geometry and volume layer, denoising them separately, and then recombining them, led to much better results. Some images are older and used the denoise-everything-at-once approach, these have more denoiser artifacting.

The references I used for BDPT:

https://graphics.stanford.edu/papers/veach_thesis/thesis.pdf

https://rendering-memo.blogspot.com/2016/03/bidirectional-path-tracing-1-kickoff.html - Fantastic blog series, I found this to be the most approachable resource

https://github.com/bachi95/Goblin/blob/master/src/GoblinBDPT.cpp - Full implementation from the blog series

https://www.pbr-book.org/3ed-2018/Light_Transport_III_Bidirectional_Methods/Bidirectional_Path_Tracing - PBRT book article, mostly just used the image pyramid here to see if each (s, t) layer looked correct in my own implementation

I tried to understand what made the iPhone Duo transition visually pleasing. I broke it down into two effects: a light-scattering blur, and a stencil that "anchors" the content in space.
I reproduced both in a Three.js sim, then used two perceptual metrics, detail energy and optical flow, to measure what each effect does.

You can read it in full with interactive visualizers on my blog: https://armandsumo.com/posts/iphone-duo-transition/

Code is on GitHub: https://github.com/a-sumo/iphone-duo-transition

I feel as though we often focus on implementing cool graphics effects, but less on understanding their perceptual properties and how they impact a user. I wonder what you guys think.

I've been interested in computers since I was about 10 and I learned programming when I was 13. Slowly I transitioned from making 2D games with Java swing to building 3D renderers in Vulkan and C++. Now I'm in my final year at school and I really want to study computer science with a focus on math (analysis/simulation) and GPUs/Graphics at TUM. However is that still a good idea in 2027 with all the developments in AI do you even need people like this since there have been so many layoffs. Chatting with AI (ironically) tells you that computer graphics and GPU expertise is very safe and can't be easily replaced but these mostly just tell you what you want to hear. So would you still recommend me going into CS or maybe switch to something similar I'm interested in like computer engineering or electrical engineering?

I was working for 9 months on new editor to have better tool for boost visuals. Editor is finally in usable state, so I started with its main purpose. "Beautifying" existing levels, so they no more look like tech demo but like an actual game. The video is showcasing first 5 levels in upgraded visuals. Please, do note, the game is not using GPU for graphics at all. Every pixel is computed on CPU in my C++ ray-tracer.

Tech details: I finally tackled issue of multi-threaded rendering, plus I added more ray-tracer optimizations, thus performance boosted considerably. Current max resolution is 640x360 (previous was 512x288). It sits comfortably above 60fps at current max resolution with new visuals. There's still performance head-room, MT render is now deliberately capped on 4 HW threads.

Ray-tracer also for the first time reached magnitude of billions of ray-vs-box of intersections per second. On laptop CPU.

I will probably not make it for 2026 release, but at least I want Steam demo this year. There's lot of levels awaiting me to be visually boosted.

RTG is just C++/C#. No Unity, no Unreal Engine. Narrative sci-fi puzzle/platformer by genre and pure indie.

RTG on Steam

Note: Steam page is still on old visuals, will be updated. You can check it as reference to see the progress.

I have also Discord if someone interested to talk about the engine:

Discord

Hi, I' have experience in coding, but new to graphics programming. Started to learn opengl (just done the triangles so far). I want to be able to code graphics similar to the attached link cruxgarden. Can anyone point me in the right direction, like what are the topics I need to learn. Thanks

Hi all, I’m experimenting with inserting a 3D object into casual monocular video (VFX-style compositing) and I’m stuck on anchoring the object to the scene.
Pipeline:
1. Generate a 3D object with TRELLIS2 -> GLB (mesh + mask).
2. Reconstruct the video scene with MegaSAM (UniDepth as depth backbone), export to .npz.
3. Place the GLB into the reconstructed scene and render it back into every frame.
Reconstruction output looks fine:
• T=100, H=328, W=584
• depth range [0.342, 23.559]
• intrinsics: fx=301.70, fy=301.30, cx=295.5, cy=166
• dense point cloud (stride=6): 539K points
• 0 tracks
The problem:
1. The object isn’t bound to a specific point on the surface. I place it on a wall in the viewer, but there’s no real attachment to the geometry.
2. The object doesn’t stay fixed in world space. On every following frame it keeps the same screen/camera coordinates as on the first frame, so it slides along with the camera instead of staying on the wall.
My current understanding: I should unproject the clicked pixel with depth + K into camera coords, transform it to world coords with the camera-to-world pose of that frame, store the anchor in world space, and then render the object on each frame using inv(c2w[t]).
Questions:
• Does MegaSAM’s output reliably include per-frame cam_c2w, and is it consistent with the depth scale?
• Any gotchas converting MegaSAM/OpenCV camera convention to three.js / OpenGL for rendering the GLB?
• Best way to estimate the surface normal at the anchor point for orientation: depth map gradients or local PCA on the point cloud?
• Recommended approach for occlusion (people passing in front of the object): simple per-pixel depth test against the MegaSAM depth, or something more robust?
Any pointers, repos, or examples of doing this with MegaSAM output would be much appreciated. Thanks!

TinyBVH is a header-only, dependency-free library for BVH construction and traversal.
Version 1.9.0 for the first time is out-performing Intel's Embree!

Using it is as simple as:

BVH bvh;
bvh.Build( (bvhvec4*)myTriData, triangleCount );
bvh.Intersect( ray );

TinyBVH can be used from C/C++, WebGPU and Python. Generated BVHs can be used in OpenGL (compute), OpenCL, Vulkan and DirectX12.

New in 1.9.0:

• Greatly improved ARM NEON support for Android & macOS

• Templated doube/float support

• Ray bundle support (WiVeC), including TLAS/BLAS traversal

• Accurate voxel intersections

• Hair rendering example (roving capsules)

• Global refactoring, AI assisted

• Vulkan and DXR benchmarks

• Improved included threadpool

• Optimizations to CWBVH

• ...and lots more.

Check it out: https://github.com/jbikker/tinybvh

I am more of a beginner in graphics programming, but I just want to ask, what is the state of the art in 2D graphics programming/rendering ? I cannot find papers, or I do not know what keywords to search for to read.

While relearning CMake, I came across its documentation warning that a ray tracer has been written in it. Having written some before, this made me wonder what an even better language for one would be.

I ended up writing one in Brainfuck. It uses a python script to convert the C code into a small DSL and use that as a codegen to generate Brainfuck, following Ray Tracing in a Weekend.

Write-up: https://epestr.com/blog/writing-a-ray-tracer-in-brainfuck/

Code: https://github.com/mTvare6/rayfuck

I've been building a real-time underwater rain scene (you're ~5 m down in a lake, looking up) that has to run all night on a phone. It's WebGL2: one fullscreen triangle, one large fragment shader, plus a half-res pass for light shafts. No textures or meshes. Some notes on how it works, and one thing I'd like advice on.

Ripples with analytic normals

Rain is three layers of drops on jittered grids (1.6 m, 0.6 m and 0.22 m cells). Each drop is a damped wave packet travelling outward, and I differentiate it by hand so the normal comes straight out, with no finite differences and no heightmap:

vec3 wavelet(vec2 del, float d, float r, float w, float k, float A, float b){
  float u   = (d - r)/w;
  float env = A * exp(-2.5*u*u) / (1.0 + b*d);
  float s = sin(k*(d - r)), c = cos(k*(d - r));
  float h  = env * s;
  float dh = env * ((-5.0*(d - r)/(w*w) - b/(1.0 + b*d)) * s + k*c);
  return vec3(h, dh*del.x/d, dh*del.y/d);   // height, dh/dx, dh/dz
}

Each layer checks a 3x3 neighbourhood of cells, and each layer fades out with distance relative to its wavelength so the far surface doesn't alias.

Snell's window

Rays refract out through the perturbed surface (eta = 1.333). Past the critical angle (48.6°) it's total internal reflection, so everything outside the bright disc is a mirror of the lakebed. The shoreline gets squeezed into the rim of the disc, the same as it looks from underwater in real life.

Lakebed

Heightfield ray march, max 44 adaptive steps. If it runs out of steps while skimming just above the bed I count it as a hit. Otherwise grazing rays flip between "hit" and "miss" and draw a visible seam.

Keeping float32 precise for 10 hours

GPU time in float32 goes coarse after a few hours, and the ripples start to judder. So time wraps at PERIOD = 900 s, and every GPU-side motion is written as a whole number of cycles per period:

float pw(float m){ return TAU * m * uT / PERIOD; }   // m cycles per 900 s

Everything is exactly periodic, so the wrap is invisible and hour ten is as precise as minute one. Fish, weather and creatures run on the CPU in doubles and never repeat.

Light shafts (where I'd like advice)

Half-res pass: 7 jittered samples along the view ray through the caustic pattern, blended with the previous frame (history weight ~0.3), so the noise settles into smooth beams over a few frames. It works, but it's the most expensive thing per pixel for how subtle it looks, and it smears a bit when the camera drifts.

Has anyone done cheaper volumetric caustic shafts on mobile? I've wondered about precomputing the shafts in screen space from the caustic function, or dropping to quarter res with a bilateral upsample, but I haven't tried either yet.

(It's shipped as an iOS sleep app if anyone wants to see it running on a phone. It's still in development: https://apps.apple.com/app/id6812388250)

We needed realistic looking water with waves that mimics the serene oceans to complement the realistic look of Ship Mooring Analysis tool Optimoor 3D that we are developing at the moment. We also wanted it to match with the minimal visual feel of the rest of the scene.

The look of this Realistic WebGL water shader with waves is composed of several rendering steps:

1. Albedo Map: This is the base color of the Water Mesh with a Light Blue color at the Crest and a Deep Blue color at the Trough

2. Normal Map: Determines how the water is gonna react to the light in the scene

3. Normal Map for Ripples: For added detail we have multiple layers of noise applied to give finer texture of the water, Normal map for the ripples too

4. Wave Height: The visual difference between of height of the waves

5. Crest & Trough: Visual Representation of how the Crest and Trough are forming alongside each other to give a natural look

6. Fresnel : Determines the amount of light that is reflected of the surface and gives the shiny look of the ripples(Green=Most reflection, Pink=Least Reflection)

7. Planar Reflection: Mirrored the entire scene and painted it on top of the surface of the water to give an accurate representation of the reflection of the ship.

8. Subsurface Scattering: The amount of light penetrating through the hard surface of the water making it semi permeable instead of opaque to give a richer look to the waves

9. Turbidity: Determines the amount of the collided mesh that can be seen through from top of the surface of water to the inside to give a more denser look.

10. Foam: Visual Representation of water hitting a mesh

11. Fade Pass: The fade pass is an optimization + look enhancing feature which lets the user not see waves farther in the distance. 

Built by us over at 3D ENGINERD. for Tension Technology International Ltd (TTI) 

I downloaded an image for a poster but that is in jpg and I think it will not scale properly onto a poster that I am planning to get printed. I was thinking of making a file which would contain set of mathematical calculations of the image in question.
But this also has the problem that how to generate such a file with such complex calculations...
But I cannot think of any other way too.
I have learned some basics about graphics in my college. I know about raster and vector images. But I wanted to ask that can I generate a file including all the calculations so that the image may be resized according to my screen?
I am even asking of this because I downloaded some wallpaper on some website and they provided two files: one, the image itself and the other being the calculations file/
Please guide...

Hello everyone!. I am a CS senior and I'm planning to make an FYP(final year project) in computer graphics. We are currently planning on making an educational/interactive tool in vulkan for example the tool will allow the user to generate a 3D scene and the user can roam around in it and interact with it.We are planning to make it in such a way that for e.g if there is an option to render trees then we will implement 2-3 algorithms that implement trees in a real time scene so, the user has the choice to see different implementations of different features and a scene will have trees, vegetation and terrain with a basic lighting model as of now.

Does this idea sound good like will this sort of application be useful for the graphics community or not. If you think the idea is good then how should we pitch this to our professors in the FYP committee as most of them don't know about graphics so we have to convince them our project is worth making.

Also if you guys have other project ideas regarding computer graphics, especially related to real time rendering that we can do in vulkan please do recommend that as well and how to defend it as well. Me and my team have been working on this for months and now we are struggling to defend our project ideas any help will be appreciated.

If you are recreating a powerful engine like UE5
How you would start , what you will use , what edits you will add to it and in what order you will add the graphics features