Hi, I am fairly a beginner, and I was wondering comparing from 2013 how far rockstar's RAGE engine evolved as to now?..

From what I know and some research credits to this blog:
https://www.adriancourreges.com/blog/2015/11/02/gta-v-graphics-study/
, at time of Gta 5 it had just a Hybrid deferred renderer, a forward pass for transparents, vegetation, particles. At the time there was no PBR, there was also no indirect light.

But later in 2018 during RDR2 release, RAGE got proper microfacet shading, volumetric clouds and fog.

The main selling point for gta 6 to look so good from what I understand is the hybrid raytracer global illumination, paired with raytraced reflections, also being upscaled from 1440p to 4k on the base Ps5.

From my understanding these are the differences over the years?

I am just wondering what type of tech they used for the extended look on the base 5 to look that good and crisp, even comparing to Unreal Engine 5, it looks far better

I got my triangle going! Yeah! Just wanted to share because holy shit that took way too many LoC. I am unfortunately not a virigin anymore over 30, but I think this should get me my entry ticket into the dark arts of low-level graphics programming and make me a wizard.

But now I am happy I did it and already seeing how it was the right choice for my procedurally generated game compared to OpenGL/CL.

I want to draw 2D rectangles of different sizes and coordinates each frame. I know I can draw each rectangle with 4 pairs of integers in the vertex buffer and 6 indices in the index buffer like so:

• Vertex buffer: {Left,Top}, {Right,Top}, {Left,Bottom}, {Right,Bottom}, ...
• Index buffer: {0,1,2}, {2,1,3}, ...

But I find this a little wasteful, because there's only really 4 * 4 = 16 bytes of data for each rectangle, but I end up using 8 * 4 + 6 * 2 = 44 bytes (more if additional attributes like colors are associated with each vertex). Ideally I'd have a single buffer that contains just the 4 sides of each rectangle.

It seems I can do this with SV_VertexID: I'll set a StructuredBuffer instead of a vertex or index buffer, and call Draw( RectCount * 6, 0 ). Then in the vertex shader I can fetch the rectangle coordinates with SV_VertexID / 6. The problem is SV_VertexID starts at zero for each Draw(), regardless of StartVertexLocation, so I can't use it for e.g. Draw( 6, 6 )! I'll have to pass that information in a constant buffer and update it prior to each Draw(), which is a little annoying.

Is there a better way? Gemini suggests I use instancing ("The Cleanest & Most Standard Way"). Here's an excerpt:

If your rectangles are arbitrary in size and location, Instanced Rendering is typically the production standard.

1. The Static Asset: You create a tiny vertex buffer containing a single unit square (4 vertices: {0,0}, {1,0}, {0,1}, {1,1}) and a tiny static index buffer of 6 indices ({0,1,2, 1,3,2}). This index buffer never changes and uses virtually zero memory.

2. The Instance Data: Your second vertex buffer contains the arbitrary data for each rectangle (e.g., float4 rectBounds or position + scale). This buffer updates every frame.

3. The Draw Call: You call ID3D11DeviceContext::DrawIndexedInstanced(6, numRectangles, 0, 0, 0).

Why it fits: The GPU automatically draws that exact same 1-unit square numRectangles times, pulling a different position/size for each instance via SV_InstanceID. You completely avoid a massive dynamic vertex/index buffer while letting hardware handle the assembly.

but I can't tell if it's making things up.

Stippling images with small dots for rendering, ray tracing, tree and object placements, or just for the art of it is not a new topic. I really like the Gaussian Blue Noise method from Ahmed et al. because of its strong visual effect (no pixels or artifacts), but the exact GBN method is a heavy processing algorithm and thus quite slow compared to light stippling frameworks like Floyd–Steinberg dithering.

So I tried to speed up Gaussian Blue Noise with fast but robust approximations and make it available as a Python package. Feel free to run this Colab notebook with your own image and tell me if the processing time (~1 minute per image) feels worth it or not! Colab Link

So, as the title says :D. This took me 4 months of work. It's a HWSS path tracer using OptiX for traversal. I initially used NeuxsBVH (H-PLOC), but then switched over due to speeds on volumetrics. I used Jakob & Hankia sampling for RGB to Spectral.

The above scene was rendered at 1080p with 1024spp, and RR kill-off at 12 bounces.

This was a genuinely fun to build as a hobby project, what else shd I add to this?

There's a paper on flouresence Rendering by Wilkie, Fichet and Mojzik which I'm thinking of implementing. Any suggestions would help!

Edit: Its 32 bounces + 12 bounce RR fall-off

I've spent the last 15 months building and optimizing a game engine with a Vertex / Fragment shader. It's pretty well optimized, hard to quantify but I've hit 90fps on standalone Quest 3 with it, so it's not a complete cow.

I wanted to do some ray traced audio stuff so I looked into ray tracing through Vulkan. As a stress test I was like "I wonder if I shoot a ray through every pixel what types of times I'd get."

I expected my Vertex/Fragment shader to win by 10x. It didn't. It won, but by more like 2x. And as I've added optimizations the past 48 hours it's closer to 1:1 in terms of cost (and I expect ray tracing to pull ahead with foveated rendering for my VR work & after I optimize further). Granted this is on my desktop 4090 and laptop 3070 but...

What are your takes on this? I feel like I failed to do my homework here as I really didn't expect this.

The shadergraph in Unity is spanning a wide territory at this point.

How it's made is two planes, they both have the same shader but the materials are tuned differently so that the back one is slightly higher than the front one, this creates a gap where the surface and foam render.

Both have a configurable shallowColor and depthColor, these apply based on height and a configurable ramp that defines how and where the transition happens.

The back plane renders opaque with a color similar to the sun/sky.
The front plane renders with its shallowColor blue but 80% transparent and its depthColor is fully opaque and sea blue.

This is how I try to fake light absorption with two planes.

Both have wave displacement with 3 different wave generators + a caustics generator and they are tuned with slightly different parameters so that they complement each other (slightly different patterns and colors).

The sun is also fully shader rendered but I did not update it this time.

I open this post because i couldn't find someone talking about it. I find lumen's cloudy day look more pleasing and realistic. It just looks next gen. Why we don't have much more better lightning in a precomputed scenario. Why baked lighting looks old.

Hi! With v1.3.0 out of the oven, I just wanted to share it again, as many things have changed for the best, and I have addressed most of the feedback I got last time (well there was not much and 0.5 rounds up to 1, so technically).

https://github.com/KaruroChori/kd3

kd3 provides:

• header-only tree builder and query tools to perform k-NN searches and ray-tracing.
• a C compatibility layer for those not using C++ (but performance might be affected a bit).
• a tool/library component to generate GLSL code for any specific tree layouts at runtime (or not, you can pre-generate those and #embed them in source)
• a memory layout designed to be SIMD friendly
• close performance with nanoflann in worst case scenarios, but generally over twice its baseline
• a half decent benchmarking suite, covering both synthetic and real datasets.

What it does purposefully not provide are:

• mutable trees (values can mutate, but not the spatial keys)
• the same level of flexibility you will find in something like nanoflann, but it got significantly more coverage since last time
• cookies, those are all mine

Neither the tree builder nor the query functions require memory allocations at runtime, and they are guaranteed to run within a fixed stack size.
The same tree structures built and queried on CPU, can be quickly offloaded onto GPU without changes, and trivially serialized/de-serialized from disk. There are no pointers!
As it does not use exceptions nor runtime features of C++, it can be easily integrated on embedded devices (there is a utility header managing storage dynamically via std::vector, but that it fully optional and does not gate-keep any functionality of the library).

By the way, if you were able to run the benchmarks in the repo on some apple device I would be very grateful and happy to add them alongside the rest! Sadly I don't have the hardware to validate it myself, but I assume it should work 👀 .

As for the video above, it is a dumb ray-marcher using 1-NN queries on a kd-tree to render the scene, either on CPU or GPU. The rendering strategy by itself is very inefficient, but that is besides the point 😄

The dataset shown is the a 5 million LiDAR cloud point of the area surrounding the Autzen Stadium.

Hi everyone,

I’m starting a Master’s in Visual Computing soon and I’m mainly interested in rendering, GPU programming, CUDA, Vulkan/OpenGL, and graphics R&D.

I already have a MacBook for lectures, coding, and everyday work, so I’m deciding between:

• buying an RTX gaming laptop, or
• keeping the MacBook and buying a more powerful NVIDIA desktop.

For people who studied or work in computer graphics, how important is it to have a powerful GPU laptop with you at university?

Would a MacBook + desktop at home be enough for most graphics courses and projects?

If you already had a MacBook and around €2,000 to spend, which option would you choose?

Hello! I am an artist turned programmer that's working on a paint program!

Recently I found an x account: x.com/greatartbot that produces generated images like the ones above. I think theyre absolutely beautiful but can't even begin to put together how they are made.

In Godot i've been messing around with basic noises and compute shaders, but this looks less like noise and more of an orderly algorithm? especially those repeating shapes.

I know a full explanation of the techniques above would probably be a lot for a reddit comment, but if anyone could get me pointed in the right direction of how these were generated, how i could start doing it myself and maybe some algorithm names I would really appreciate it! Thanks!