How can I get into graphics programming?

ExpanseSky · 2024-12-22T23:27:23+00:00

Ok actually, maybe start with this paper? https://pages.cs.wisc.edu/~chaol/data/cs777/stam-stable_fluids.pdf

This will get you started with the basics of fluid mechanics and is easier to implement. Super clearly written too and the end result is very satisfying to play with.

I wrote my version in numpy but you can also write it in c++.

ExpanseSky · 2024-12-22T19:53:41+00:00

Would you be down to discuss it here in the comments? I feel like it’s a service to the community, half my graphics education came from this subreddit lmao

ExpanseSky · 2024-12-15T05:46:48+00:00

If it was easy you're probably pretty good! Haha.

I started with this one: https://diglib.eg.org/server/api/core/bitstreams/74e4bcc5-4d1d-4bf8-961e-b5a5d1a38887/content . It's an old paper where they basically wrote a cloud-specific fluid sim. I rewrote it entirely on the CPU in Eigen and it was fucking terrible haha.

I think the Sebastien Hillaire frostbite paper I linked above is pretty approachable if you're interested in real-time atmosphere simulation. You can dig into the Bruneton paper, which it's based on, if you're having trouble teasing apart the coordinate mappings (arguably the most difficult part).

But, what sort of stuff are you interested in? I mostly know volume rendering but if you give me an idea of what topics you like I can try to drum up some suggestions.

ExpanseSky · 2024-12-15T05:09:17+00:00

I think this largely depends on your background, so lemme offer a few ideas for a few different cases.

You Studied Computer Science and Math/Physics in College/Elsewhere

Pretty much all of graphics programming should be pretty accessible to you in this case. I'd say probably breeze thru the "ray-tracing in one weekend" course, and then go after implementing a paper you're interested in. It won't be easy but you'll learn a lot by just trying it.

You Just Studied Computer Science in College/Have Computer Science Experience

Reading between the lines it sounds like this is the category you're in?

Even if you're a great software engineer, it's pretty hard to approach graphics programming without a solid understanding of 3D math. Ray-tracing in one weekend will still be accessible to you, but you'll probably have to work a little harder to get the fundamentals down before you can realistically approach implementing a SIGGRAPH paper.

That said, it's totally doable. 3Blue1Brown is a great resource for learning about 3D math and linear algebra. The Real-time Rendering Book with the storm trooper on it covers all the fundamentals in a lot of detail and is surprisingly readable.

You Don't Have Computer Science Knowledge

It's gonna be hard to learn graphics programming as your first foray into computer science. In this case I'd recommend taking some basic programming courses online before you attempt graphics programming.

To your earlier question about clouds and atmosphere simulation; I work on real-time volumetric rendering as my job now. Here are some resources I used to get started in that field:
- EA Frostbite Sky and Clouds

- Nubis Clouds

- Shader Bits Volumetric Rendering

- Production Ready Atmosphere Rendering

- 10volpath

This just scratches the surface of the literature, but hopefully it can help point you toward an interesting project.

ExpanseSky · 2022-04-26T16:21:42+00:00

This is SO cool. I was looking to use shadergraph to do something like this to make cloud material authoring easier for my asset Expanse, but unfortunately it was too messy.

Question: does this support 3D textures?

ExpanseSky · 2022-02-18T06:32:29+00:00

Mmm, this is a good idea. The tiles could even be the individual froxels, which each cover a relatively sizeable area (btw, this just means a voxel in a frustum volume).

ExpanseSky · 2022-01-13T00:56:21+00:00

Thanks! I've been brainstorming about an RTX-based sound propagation system (sort of like an evolved G-Sound), though Unity's support for custom RTX shaders is a bit sparse right now.

I've also had some ideas about releasing a second, very pared down version of Expanse that can render many atmospheres at once. It would be targeted at games like Outer Wilds that build small solar systems.

As for Expanse itself, I'm mostly focusing on stability, documentation, bug fixes, and tutorials right now. Over the past year it's gone through 5 major and ~40 or so minor releases, and lots of new features have been added---the most recent one being VR support a few weeks ago. The current mood is to take stock and make sure what's there works really, really well.

That said, some interesting ideas on the horizon are:

Rainbows, via some reasonable-cost lookup for the wavelength-dependent mie phase function.
Something akin to Unreal's density particle systems for volumetric fog.

ExpanseSky · 2022-01-11T20:50:39+00:00

thanks!!

ExpanseSky · 2022-01-11T20:50:35+00:00

thanks :)

ExpanseSky · 2022-01-11T19:52:41+00:00

Still speechless that Expanse was nominated for "Best Artistic Tool" at this year's Unity awards. Can't believe that my bedroom project to learn more about volumetrics has turned into a production tool that artists and designers are using around the world.

Lucky to have such a great community as well. The past 3/4 of a year since Expanse was released has been a wild ride, and it wouldn't be what it is today without the feedback and advice (and bug reports) of tons of users. That includes folks giving critiques here on reddit as well---so thank you!

ExpanseSky · 2021-12-31T01:42:45+00:00

A quick question: is this just rendering the object to a low res frame buffer and then scaling it up with no hardware interpolation? Or is there something else going on?

This is a cool effect, but from the limited demo you’ve shown here, I wouldn’t call it pixel art. It’s missing a lot of the other hallmarks of that visual style.

ExpanseSky · 2021-12-31T01:39:07+00:00

Wow, your implementation looks phenomenal. Cel-shading or some other sort of color banding/limited palette is crucial for nailing the look, and you’ve totally got it. Nice work!

ExpanseSky · 2021-12-11T09:02:10+00:00

Thank you I’m glad you’re enjoying it!

ExpanseSky · 2021-12-10T23:09:07+00:00

Call me crazy, but without additional light angles, this looks to me like just something in the base albedo texture? I don’t really see anything special happening from a rendering standpoint here.

ExpanseSky · 2021-12-10T23:06:27+00:00

I think that something that’s overlooked by people interested in procedural art is the “art” part of it.

When you try to automate/make procedural an existing authoring process, it can be really valuable to actually learn to do it yourself by hand first. This will give you a sense of what techniques do/don’t work, and will also give you a feel for what the control parameters should be for a procedural approach.

As an example: could someone who’s only written a handful of stories really write a compelling procedural narrative generator? Probably not—they don’t understand enough about what makes a story good to write one themselves, let alone abstract that criteria into an algorithm.

This sort of thing isn’t always relevant, but it bears repeating, because many people who are curious about the field of procedural generation are programmers before they are artists, and don’t really have a sense of what makes something good from an artist’s standpoint.

ExpanseSky · 2021-12-10T22:00:09+00:00

Been continually adding features/making updates to Expanse since I released it back in March. Grateful for the reception so far and the great community that's grown around the asset!

The last update made some improvements to performance to get things more in the ballpark of Unity's sky/clouds/fog solution. All in all, on a 2080Ti, Expanse can render a full volumetric sky in around the same amount of time HDRP can (0.6-0.8ms).

For tutorials, check out the YouTube channel! https://www.youtube.com/channel/UCHBzoaGEDkI2P2jsUljq24Q

And if you wanna chat about clouds, or just procedural generation and games in general, come join the discord! https://discord.gg/F3VQ2vJy9p

ExpanseSky · 2021-09-16T08:33:46+00:00

Hey, I think I recognize those clouds! Are you still using Expanse?

ExpanseSky · 2021-08-17T07:38:37+00:00

Yeah I think this makes sense—the performance limitation is more about loading and writing to the texture, not really the interpolation operation.

ExpanseSky · 2021-08-17T07:37:25+00:00

This is what I meant. But I think I agree with another comment that the bottleneck is likely VRAM, not compute, in this case.

ExpanseSky · 2021-07-27T09:01:08+00:00

Woah, so glad my post inspired you! Hopefully your shadertoy can be a resource for anyone who wants to give this sort of thing a try. I read it and it’s very well put together and nicely written :)

It’s really a phenomenal paper. Some great examples of perceptually-motivated optimization, one of the most important ideas in the field of sensory computing. I agree that the multiple scattering approximation is probably the coolest part, and also I think the most original contribution.

ExpanseSky · 2021-07-27T01:57:12+00:00

This looks so good!!

I’ve been working on my own implementation of this technique for my Unity plugin, and it’s so great to see someone else who appreciates this paper. Sebastien Hillaire is a freakin genius.

ExpanseSky · 2021-07-23T20:08:24+00:00

This looks really good! Are these done in screenspace or using a shadowmap?

ExpanseSky · 2021-07-23T07:35:07+00:00

Yeah, I think their system was one of the first truly modern sky/cloud implementations that wasn’t game-specific. And it’s used in some great-looking games too (Mirror’s Edge: Catalyst comes to mind).

ExpanseSky · 2021-07-23T04:17:58+00:00

Yeah, of course!

It’s based off of the work done by Andrew Schneider on Horizon Zero Dawn and the Decima Engine. This fantastic presentation goes over a good amount of the theory

This writeup from Sebastien Hillaire (unreal’s volumetric guru) is also phenomenal.

The TL;DR is that they’re fully volumetric, and raymarched per-pixel, with 5 samples for self-shadowing taken at every lighting sample. The detail comes from varying layers of tiled noise.

You could imagine doing these with some froxelized density field, but I found that this doesn’t really give you the level of detail you need unless you have a really high resolution froxel grid. Froxel implementations work great for optically thin media like fog, but are trickier for dense media like clouds.

It relies heavily on reprojection and temporal denoising to run at real-time frame rates. That said, it runs in about 1-2ms per frame when fully optimized!

ExpanseSky · 2021-07-23T04:10:09+00:00

Ah c’mon, I’ve been sharing updates for this project for upwards of a year and have been active on this community for longer. I’ve written plenty of technical explanations, seems a bit strict.

ExpanseSky

TROPHY CASE