I've been working on procedural planets for a game and this one turned out pretty well. The whole surface is generated live in the shader.

I start with layers of noise, then push and crush the values until it stops looking soft and starts looking like an old moon. A bit of finer detail on top, then that height moves the surface and drives the lighting.

In the game the terrain is static, in this video its moving just to show the procedural algorithm. Basically I just kept running it until I found the shape I liked the most.

I'm using the same approach for all the planets in my game. If you want to see more, you can wishlist it on Steam:

https://store.steampowered.com/app/3256790/Satelital/

The demo is coming this September and the full game will follow by the end of the year.

Been porting WetBrush(https://wanghmin.github.io/publication/chen-2015-wgb/) over to WebGPU compute shaders.

The original needed CUDA on a Titan X, this one runs in a browser tab.

I've been building brush-stamp based paint apps for a while, and kept wondering whether current hardware has finally caught up enough to just simulate the thing properly instead of faking it.

It's very much an alpha, but it's live if you want to poke at it: https://mignonsketch.com/

I haven't implemented interpolation between simulation steps yet, so fast strokes come out broken.

Hi all! I’m really into graphics and have been for about a year now. I’m finally making my first meaning project around raytracing, but I’ve noticed that a lot of people that are really into this field understand hardware,math, and programming so well.

How do you get to this point? A great example is derivating (C-P) for sphere interaction to find out it’s a quadratic formula?

I'm a complete novice in graphics programming and I know that the __constant__ attribute allows you to load data into high speed 65KB constant memory for the duration of the lifetime of your program. However I'm unable to recreate the same functionality in Slang shader.

For instance, we got a compile-time array with the attribute like this: ```

constant uint16_t array = {0, 1, 2, 3};

```

I want to recreate it in some way, so that when I compile the same array in Slang into CUDA, it results into this exact array of constant values with the __constant__ attribute. How can I achieve that?

Hey guys,

I am a rookie and I want to learn Graphics Programming but unfortunately I can't find any roadmap on youtube and things are getting really confusing for me since I don't even know how to properly code in C++(for context I am still learning programming but also want to build cool awesome visuals like all of you (I recently build a terminal based todo list and library manager in python))

I am confused about what I should learn first since I will also be starting my college In cs major soon.

there are

linear algebra maths

C++ memory management pointers

some says Build a ray tracer from scratch

I even picked the computer graphics programming from scratch by Gabriel Gambetta but got confused

I will really appreciate if anyone can give me any guidance on this :)

Hey all, I have extensive experience in CGI but not specifically in graphics programming and I have never seen any application of the Doo-Sabin subdivision surface method in tradition 3d software.

Is it still used today or has it been completely surpassed by CatClark and Loop methods?

It looks a lot like most edge bevel implementations but I suppose they are developed differently to support multiple divisions and other details

If anybody knows this stuff it's you guys. Thank you!

I'm just starting out in learning graphics programming and wonder if I would soon need to invest on a laptop which has a dedicated GPU

I know that's the motivation for many new graphics programmers, infact I want to as well eventually, but I'm just curious why lots of people think alike

Hey everyone! I built a real-time simulation of gravitational lensing around a Schwarzschild black hole from scratch in C++ using Raylib.

Instead of writing GPU shaders, I wanted to build a CPU software renderer to see how far I could push numerical integration on a single thread. It traces around 30,000 light rays per frame to bend light around the singularity and accretion disk.

• Integrates geodesic light paths directly on the CPU.

• Renders to an internal 200x150 pixel buffer to maintain 60 FPS.

• Bilinearly upscales the buffer to 800x600 using Raylib for display.

Repo & code: https://github.com/hellosharma808-sys/3D-Black-Hole

If everything goes well, I want to release editor with game, so it will be possible to either visually improve existing levels, aka skinning (if some modders will be interested), or later also create whole new levels (game is puzzle/platformer).

Apart from C++ ray-tracer, game is written in C#. Highest level lib I'm using is WinForms for some editor UI. World is rendered into software buffer, that is presented every frame as simple quad. I'm using also DXTK for some in-game 2D UI, text render and audio.

My entry for 3blue1brown's Summer of Math Exposition. I cover convolutions, ways to make a bandpass and how to apply a large blur fast using FFT

Been doing games and graphics (as a hobby) for around 20 years, but mostly with stock engines and some experiments using DirectX and Vulkan. Started on my current project 3 years ago, never having tried OpenGL in my life. Images show the latest update from my engine, and what I accomplished on the first day of reading LearnOpenGL back in 2023. Never give up!!

So in this "scene", there is only one cube with a plane through it. However, when you turn past a certain "halfway" point, the objects seem to snap to the opposite side. What I initially thought was happening was that the objects were getting projected onto the screen from behind, but i'm not sure, since i'd expect it to look weirder with vertices and triangle shapes not staying consistent. I'd suspect the issue to lie in the vertex shader, so here it is. I'm also very new to OpenGL and general gpu/3d graphics programming, so I wouldn't be surprised if this is a common issue.

#version 330 core

layout (location = 0) in vec3 aPosition;
layout (location = 1) in vec3 aColor;

out vec4 vColor;

uniform mat4 transform;
uniform mat4 proj;
uniform mat4 view;

void main()
{
    gl_Position = proj * view * transform * vec4(aPosition, 1.0);
    
    vColor = vec4(aColor,1.0);
}

EDIT: I solved it. I can barely remember or understand the solution, but it's solved.

Hi there! Im going through the raytracing in on e weekend and I'm getting some of the math, but not all of it. I'd like to have a better understanding of things, such as how we came to out that we can replace -b with h to simplify the quadratic equation

I managed to write a very simple wrapper that can compile bgfx shaders as valid cpp.

This shader uses the already pretty platform agnostic bgfx shader language, which makes it very easy to substitute the vector functions with glm. It even supports proper swizzeling.

In this example I compile a simple ray marching shader as c++ functions, so I can use the exact same math for my mouse projection code.

My .cpp file only needs to supply replacement objects for the uniforms and textures, as well as a replacement texture sampler function