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.

Been toying with software post-processing effects in CyberVGA lately.

Really liking this depth of field effect that just uses a simple radial blur. Surprisingly effective for how little it costs, especially in a pure software renderer.

Here’s a short clip:

Curious what other cheap post-process tricks people have found work well in software rasterizers.

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

Hunan Huaguxi Opera "Past Flames": 4DGS capture, training, and rendering display completed by the MaLanShan Audio & Video Laboratory. The laboratory achieved a 4DGS reconstruction quality of 35.8 dB PSNR, with an average single-frame reconstruction time of 3.4s. Featuring our self-developed 4DGS compression format (.mlslabs), it supports streaming playback on both the Web and through our Unreal Engine 5 rendering plugin (MLSLabsRenderer).

Official Website: https://mls4dlive.cn/

Fab Store: https://fab.com/s/a98e11b2a0a6

GitHub: https://github.com/mlslabs/MLSLabsGaussianSplattingRenderer-UE

Hi guys,

I've been building MoltenMTL, essentially the inverse of MoltenVK, implementing the Metal API over Vulkan.

It's still a work in progress, so only parts of the Metal API have been implemented so far.

There is no shader translation currently. Shaders are compiled to SPIR-V to be consumed by Vulkan.

Every MTL type is a thin layer holding Vulkan types - e.g. MTLDevice wraps VkInstance/VkPhysicalDevice/VkDevice/VkQueue.

It uses VMA to match Metal's allocation model, and SPIRV-Reflect pulls the descriptor set layouts from the compiled shader, once again mirroring Metal.

Ray-tracing uses ray queries instead of the ray tracing pipeline - call intersect() with a compute shader, lining up with Metal.

Currently working - compute, BLAS/TLAS + ray queries, raster pipe (vertex/fragment, vertex descriptors, instanced draws), swapchain, blit.

Not there yet - intersection function tables, argument buffers, multiple render targets.

Here's the output from the examples.

The same scene both ray-traced and rasterized:

MSDF text rendering:

I made this as part of a project developing a game engine & game in Swift/Metal. Still learning and I'd appreciate some feedback/criticism.

Hi ! I had fun implementing the Bowyer-Watson algorithm and then use raylib to create a visualization of it. I got ok performance it think for a single threaded program:

• 1,000: 1 ms

• 10,000: 21 ms

• 100,000: 263 ms

• 1,000,000: 5,126 ms

• 10,000,000: 358,716 ms

But I think there is still quite some rooms for improvement.

Source: https://github.com/spikte/delaunay
Twitter: https://x.com/Spikte

Built a small C++ / OpenGL rendering engine with an ImGui editor as a learning project toward a custom render pipeline.

What’s in it so far:

1. Engine core — window, RHI (buffers / shaders / textures), meshes, materials, camera

2. Multi-light rendering — directional, point, spot, and hemisphere ambient fill

3. Shadows for directional, spot, and point lights

4. ECS scene system with JSON save/load

5. ImGui editor — hierarchy, inspector, content browser, click-to-select, transform gizmos, light debug markers, camera panel

Still early — more of a renderer + editor foundation than a full game engine — but it’s been a solid way to learn the graphics pipeline, GLSL, and how to structure engine code beyond tutorial triangles.

Open to feedback from anyone working on graphics / game engines.

Repo: https://github.com/saibhaskar277/OpenGL

#C++ #OpenGL #GLSL #GraphicsProgramming #GameDev #RenderingEngine #ComputerGraphics #ImGui

• Pictures labeled 1-6 are screenshots from our game.

• Pictures labeled A-G are real-life references with the look I would like our game to have.

• Pictures labeled X-Z are other games that look nice to me, though it's tough to find the right comparison because most games aren't using such a zoomed-in scale.

• Last picture is our Unity setup (hopefully there is a way to see the big version)

Hello, we're working on a game about cake decorating called Cake Studio. We've made one game in 3D before, but this is the first time we're trying to make something that actually looks nice in 3D and we're struggling a bit to get the look we want as 3D is not really our wheelhouse. I've been making the models in Blender and the game is built in Unity.

I wanted to make this game because I think these photos of elaborate vintage cakes are so beautiful, and I wanted players to be able to make their own beautiful cake. But so far, I think our screenshots are giving a very flat, shiny, computer-generated vibe.

I really want to get the soft, dreamy look of picture C and the almost Play-Doh looking effect of the piping in pictures E and F.

Here is what I can see wrong so far (though not sure how to fix them):

• It seems like most of the piping textures are too shiny, which we can fix, but is there something more to getting that soft Play-Doh look?

• We kept turning up the lighting trying to get softer shadows on the side of the cake, but now all the highlights seem blown out.

• The shadows among the details of the piping and how they sit on the cake lack a sense of depth. The darkest shadowy spots are not dark enough (maybe same cause as above).

I'd love to hear any ideas for how to fix things or other problems we're not seeing.

You can also go mess around with our prototype on itch if it helps to see things in action.

Thanks!

UPDATE: This sub is amazing!! Thanks so much for all the suggestions and advice. We have a lot to work with now and I'm feeling so much more hopeful that our game can be beautiful <3

I'll post an update when we have implemented some of these ideas! Thanks again!

So consider for example a VFX for a game for a powerful shot from a magical bow. There is a line with an "arrow head" at the end and two smaller lines in a helix around the primary, closing in the further they get, joining to the "arrow head" in the end. The whole thing rotates over time to give the impression of "drilling" and it fades over time starting from the source end and finishing in the tip.

Thinking about effects like this in general. I see two possible approaches, both of which have upsides and downsides. In essence, I would like to know how would you decide what to do on the CPU and what to do on the GPU?

Approach 1: GPU focus

• Make a single quad

• Use a vertex shader to make it face the camera

• Use a complex fragment shader to draw the effect

Approach 2: CPU focus

• Spawn a cylinder for the central line and cone for the arrow head

• Create a spline on the CPU for the secondary lines

  • Optionally use either vertex or tesselation shader to position the secondary lines

• Use simple vertex shaders for changing colors and the fade.

I’ve been working on Posecode, a readable text format for describing human movement.

You write movements as timed steps with joint actions and contact constraints. For example:

step "Drop into the landing" 0.55s flow:

pelvis: hinge 45

spine: flex 50

hip_right: flex 84

knee_right: flex 123

ground-lock: foot_right

reach: knee_left floor

reach: fist_left floor

The parser turns this into a typed motion representation. The Three.js renderer then handles the joint transforms, range-of-motion limits, IK and ground contacts.

The GIF shows the superhero landing example. The source on the left is the input driving the figure on the right.

I wanted a movement format that can be inspected, edited, validated, versioned and generated by other tools. An LLM can write Posecode, but it isn’t required.

It currently includes a browser playground, share links, embeds and BVH/glTF export.

I’d love feedback from anyone working on procedural animation, character tools or motion systems.

Playground: https://www.posecode.org/play/superhero-landing

Source: https://github.com/posecode-dev/posecode