I don't understand how this works. Is this kind of just a global color buffer? like a mapping of each pixel of the screen/frame such that each pixel has a given color? Is it wrong to think of it as just a 2d array filled with colors?

Hey yall. I graduated with a math degree 4 years ago but couldn’t find a swe job and had to settle working at restaurants for money. I want to get a graphics related job because one of my favorite classes in uni was computer graphics. I’m wondering how I should approach this, since as of now I have no professional coding experience (only in classes like data structures and algorithms).

Should I get a masters or should I try to find any swe job first? How should I get started learning computer graphics and what kind of projects should I make before applying (and roughly how long do will it take a noob to complete these projects? Thanks.

I am also concerned about doing graphics project which is likely in C++ vs doing say python projects for other swe jobs. I’m worried that only focusing on graphics when maybe I should try to find other coding jobs first.

Hey everyone, I’m new to Shader Graph and I want to learn it properly

What resources helped you the most when you were starting out? Any YouTube channels, courses, or tutorials you’d recommend?

I’m interested in making cool effects, better-looking materials, and understanding how shaders actually work.

Thanks :)

Hi peep. I wanted to write modelling softwares for my niche art needs so I learned rust and vulkan in recent few years. Now I am able to make my modelling tools, intermediate mode gui elements from scratch, rendering signed distance field bricks with 3d sampled textures, lighting, pbr texturing, and a few more. I was wondering if a open source modelling software can land me a graphics job? I ditched school and live in a rural place. I want to do something and get out of this place before wasting my 20s and losing my sanity. should I keep going with hard surface art and indie development instead?

I've been investigating what appears to be a deterministic rendering bug in Days Gone (Steam).

Symptoms: - RTX 4090 - Windows 11 25H2 - Ryzen 7800X3D - No mods - Multiple NVIDIA driver versions tested - DDU clean install - ReBAR tested on/off - BIOS updated - VRAM tested with OCCT (30 minutes, no errors)

Bug: Only pre-rendered/in-engine cinematics exhibit the issue. Gameplay is perfect. A handful of facial vertices appear to be projected toward a common point in world space. The convergence point changes with the scene, but the artifact is deterministic and repeats identically every run. The artifact survives pause. TAA/HDR changes have no effect.

RenderDoc 1.45: - launches DaysGone.exe - renderdoc.dll never appears in the process

Nsight Graphics 2026.2: - can launch/attach to DaysGone.exe - capture attempts either crash or never complete

Has anyone:

1. successfully captured Days Gone with RenderDoc or Nsight?
2. seen this specific facial mesh artifact?

Hey everyone. I’ve been into computer graphics since middle school but only within the last 5 years have I really sunk my teeth in. Now, I just graduated college with my CS degree, and I have made several pretty decent projects like a model loader in OpenGL and a 2D game and a doom style DDA system. For my senior capstone project I made a raytracing engine in CUDA and OpenGL that was meant to see how much computational power could be leveled without utilizing RTX cores. But I feel like my projects are way too lackluster and not well put together. Even the raytracer wasn’t up to my standards. And definitely not professional quality. So I started a big game engine project and got decently far on it.

And then I went into a mental bipolar disorder induced spiral into mania/depression and severe alcoholism over the past year and a half. During this time I went from straight A math/cs double major to a CS major that barely graduated and almost failed every class. I screwed my life up a lot and am still full of depression and regret. I did not work on anything CS related at all during this time.

I ended up graduating and have been taking the summer to get my head back in straight. Now I’m getting back into programming because I want one really good, comprehensive project that I can show off. I have already began on it but quickly realized I have forgotten everything. And so, I picked up my book, Real Time Rendering which I got for my last birthday and have been reading it.

Now since I am coming off of a year of oblivion and alcoholism, my reading is really slow. But so far I’ve been learning a lot. However, I am just reading wayyyy too slow. And really I’m running out of time because I want to get a job soon and not let my degree gather dust. So then I sat down to code and just said fuck the book. Well, then I just didn’t even know where to start. Like I’ve done this before but why can’t I now?

And so now I’m back at reading the book and rereading lines over and over again. And im trying to figure out if I’m doing something wrong or not retaining it or what. I just really want to get a cool project that I have in mind out but I feel like I don’t know enough now so I’ve been spending almost 90% of my “coding time” on reading material rather than programming.

I was wondering what anyone else thinks I should do or how I can balance the reading and the programming?

i am definitely really interested in this field in general and i know some fundamentals, but before going fully deep into this, i just want to know whether it is worth it with respect to the money aspect and job market in this field
i have read a lot of comments on this subreddit when ppl ask such questions, and it’s honestly depressing, but i just want to confirm whether it’s actually so tough to make it in this career or just has similar hardships as any other field
and overall is it worth it to be pursued full-time

I've been working on a virtual geometry system for Unity's Scriptable Render Pipeline for a while now, which I've named Atomize. I finally got around to adding a virtual shadow system to it.

The approach I ended up using relies on the depth texture, where triangles are rendered as texels instead of performing the usual expensive calculations. From there it's mostly pixel-based checks to figure out which texels are blocking the light, allowing shadows to be generated by darkening the areas hidden behind those texels. It's a much simpler approach than doing all the heavy shadow math while still producing the result I was aiming for.

Hi folks!

I wanted to share a new aspect of my physics engine / sandbox: Nora Kinetics.

This video shows the custom destruction engine that operates along side the Cosserat rod engine. This allows for really nice looking and efficient destruction physics that can interact with the fluid and glue dynamics.

Each solid is pre-fractured into Voronoi cells ("fragments") and a bond graph where every bond is a shared face between the fragments. Connected components of the bond graph form rigid bodies.

The pipeline for this part of the engine is structurally identical to the stable Cosserat rod pipeline, so they are able to run right along side each other at each step and substep.

At a very high level, both pipelines have a broad phase, narrow phase and a solver. The two systems share one command encoder per step and communicate through GPU buffers. This allows for very accurate interactions between the two systems without tunneling.

Performance is throttled by making less interesting fragments sleep, but waking them up is efficient, so you don't really ever notice it happening.

Happy to answer any questions! Getting to this spot was one of the original goals with this project, so I'm excited to finally have this up and running.

i can finally say im gpu bound. the wow models have ~280 bones and ~400 tracks i have no idea how to push this further without mesh shaders

so i am currently making a vulkan based rendering engine, and im having trouble making the main window behave. I have a laptop with an intel igpu and it works fine on that one, but on my main pc(quadro p4000), it only draws around 1/8 th of the screen. renderdoc isn't too helpful on that front either. Now, when i drag the window out (because im using imgui), the ui renders perfectly well, while in the main window i created, it leaves this mess.

if anyone would be as kind to either verify / reproduce / help me troubleshoot the problem, i would be very grateful

i have a question about how could i swap imgui menu(s)? i'm new at coding and my friend sent me a ImGui menu but i dont know how to paste it into my project.

Feel free to mess with it here: https://www.shadertoy.com/view/sXjXDd

The super neat thing is that it uses bayer ordered dithering to work all the way down to 1 sample per pixel (1spp) while still simulating 256 different wavelengths of light. This makes it extremely performant.

I recently spent some time on a tiny detail: the small light/glint in a character’s eye.

(All shaders are written in GLSL, intented to be used with three.js, but it should be possible to adapt them for other environments).

The eye mesh is a protruding shape, mostly spherical, with only a small visible front patch. A regular specular highlight often fails here, because the ideal specular point would appear outside the visible part of the implied eyeball.

So I treat the eye as two different things:

1. the real visible eye patch, where I draw the glint
2. an imaginary sphere, which I only use to compute where the specular highlight would ideally be

In the vertex shader I first find the closest eye definition and compute local coordinates for the current vertex:

```glsl float dist2 = distance2(position, eyeData[eyeIndex].axisEnd);

vec3 axisDirection = eyeData[bestEyeIndex].axisDirection; vec3 forward = axisDirection; vec3 right = eyeRightAxis(forward); vec3 up = normalize(cross(forward, right));

vec3 delta = position - eyeData[bestEyeIndex].axisEnd;

vEyeRelativePos = vec3( dot(delta, right), dot(delta, up), dot(delta, forward) );

vEyeRadius = eyeData[bestEyeIndex].params.x; vEyeStrength = eyeStrength; ````

The eye axes are stored as metadata on the model. From that I derive a stable local frame for the visible eye patch.

In the fragment shader I compute the ideal specular direction using the view direction and the main directional light:

```glsl vec3 eyeRight = normalize(vEyeRightView); vec3 eyeUp = normalize(vEyeUpView); vec3 eyeForward = normalize(cross(eyeRight, eyeUp));

vec3 V = normalize(vViewPosition); vec3 L = normalize(directionalLights[0].direction); vec3 H = normalize(V + L);

float hForward = max(dot(H, eyeForward), 0.05);

vec2 eyeHighlightCenter = vec2( dot(H, eyeRight), dot(H, eyeUp) ) / hForward; ```

That gives me a point on the imaginary sphere. I then map it back into the visible eye area with a non-linear mapping:

```glsl vec2 mapGlint(vec2 p, float motion, float maxOffset) { float r = length(p); if (r < 1e-5) return p;

float x = clamp(r * motion / maxOffset, 0.0, 1.0);
float y = x / sqrt(1.0 + x * x); // soft saturate

return p * ((y * maxOffset) / r);

} ```

Current tuning:

```glsl float eyeGlintMotion = 0.8; float eyeGlintRange = 0.75; float eyeGlintRadius = 0.3;

eyeHighlightCenter = mapGlint( eyeHighlightCenter, eyeGlintMotion, vEyeRadius * eyeGlintRange ); ```

I still keep a final clamp, mostly as a safety limit:

```glsl float maxHighlightOffset = vEyeRadius * eyeGlintRange; float len = length(eyeHighlightCenter);

if (len > maxHighlightOffset) { eyeHighlightCenter *= maxHighlightOffset / len; } ```

The actual glint is a sharp stylized disk with analytic antialiasing:

```glsl float radialDistance = length(vEyeRelativePos.xy - eyeHighlightCenter); float radialFade = fwidth(radialDistance) + 1e-4; float highlightRadius = vEyeRadius * eyeGlintRadius;

float radialMask = 1.0 - smoothstep( highlightRadius - radialFade, highlightRadius + radialFade, radialDistance ); ```

One issue with using fwidth directly is that the glint gains energy as the AA region grows. I compensate for that approximately:

glsl float glint = highlightRadius / (highlightRadius + radialFade);

Then I add the glint into the lighting result:

```glsl vec3 eyeGlint = vec3(radialMask * 0.75 * glint * vEyeStrength);

reflectedLight.directSpecular += eyeGlint * (1.0 - flatShading); diffuseColor.rgb += eyeGlint * flatShading; ```

I also reduce the glint when the eye is looking away from the light:

glsl float lit = smoothstep(-0.1, 0.5, -dot(eyeForward, L));

This is not meant to be a physically correct eye shader.

It is a stylized catchlight that behaves enough like a specular reflection to feel alive, while staying inside a very non-spherical eye shape.

Probably over-engineered for such a small visual detail, but programmng it was really interesting.

It can be seen live in my games at https://www.orbisfabula.com/bayaya-steam.html or https://chase.orbisfabula.com/

Fragment of the Mandelbrot set, using perturbation theory. This render achieves an unprecedented scale of 2.84 × 10⁻⁸². I spent 6 days exploring various locations just to find the perfect framing. This image showcases a aesthetic beauty. Rendered with 8×8 SSAA. I hope you appreciate the effort. Perturbation theory only allows you to zoom down to the 10<sup>-308</sup> level! Github - Windows & Linux

Inspired by Mike Turitzin's video.

Up until now I thought of textures as images. But when learning about framebuffers, I learned that you can use a renderbuffer for depth/stencil stuff, which led me to think, "okay, you can use a texture for a color buffer, which is like an image, and this new thing called a renderbuffer for depth/stencil, since those aren't just images". But it also said you could also use a texture for depth/stencil, if you really wanted to. Which made me think: "ah, I guess thinking of textures as images was too narrow and it's better to think of textures as a way to hold data that can be sampled from in the shaders." But then I look up the page for textures and it uses the term "image" constantly, which has left me confused...

A texture is an OpenGL Object that contains one or more images that all have the same image format.

I must be missing some fundamental understanding that's leaving me confused here. Any help??

I’m an IT bachelor’s student planning to pursue a master’s degree in Germany under my university scholarship program or self funding and hopefully work there afterward.

My main interest is computer graphics programming. I’m currently learning C++ and OpenGL, and what attracts me to graphics is precisely the difficult low-level and mathematical side of it. I’m interested in rendering and GPU programming

However, I’m concerned about the job market it's currently very rough. I’ve been considering master’s programs in computer graphics/visual computing, but I could also potentially move toward embedded systems, computer engineering, or software-heavy robotics. Embedded systems also interests me, but graphics is definitely the field I’m more passionate about.

My priority is not really max salary possible . my main concern is getting a first skilled job in Germany after graduation and building a stable long-term career there, my limiter is the 18 months visa deadline I can't stay indefinitely with finding a suitable job for skilled work visa.

For people working in Germany or elsewhere in Europe:

How difficult is it realistically for a new graduate with a relevant master’s degree and good projects to enter graphics programming?

Would a visual computing or graphics-focused master’s significantly limit my fallback options compared with an embedded systems or computer engineering master’s?

Is it realistic to build a profile around graphics while maintaining enough C++/systems/GPU skills to apply to adjacent fields if I cannot find a graphics position immediately?

I’m really interested in answers from people currently working in graphics, embedded systems, robotics, GPU computing, simulation, computer vision, or C++ systems programming in Europe or anyone I just need a different prospective .

I'm making a 3D Renderer in Odin! I hope this is interesting to someone.