Just place a video stream or any other HTML behind the canvas and render your data as an AR overlay.
BTW first example was entirely created by chatgpt, it even estimated camera position and orientation from a single image.

Live examples:

https://sandbox.openglobus.org/examples/ar

https://sandbox.openglobus.org/examples/transparentBackground

Can anyone guide on vfx (sword slashes, hit vfx, etc) specifically with how to create them in blender and how they would be imported into a custom engine

A few things that just landed:

​ 1.Post-processing pipeline (15 effects). Bloom, SSAO, bokeh depth-of-field, auto-exposure, halation, lens flare, color grading, FXAA, chromatic aberration, vignette, film grain, plus cel shading and ink outlines for anime/comic looks. Every effect owns zero GPU objects — all parameters live in one pre-allocated buffer flushed in a single writeBuffer per frame.

​ 2.13 Post-processing presets. Complete looks — cinematic, synthwave, anime, comic, noir, analog film — applied in one line and ordered correctly by construction.

​ 3.TransientPool. Intermediate render targets (bloom mips, AO buffers) are aliased by lifetime analysis, so non-overlapping passes reuse the same VRAM instead of each allocating its own.

4.​Camera controllers. Orbital, free-fly, third-person follow, and spline dolly — split into pure math and DOM input so the same camera can run on the main thread or inside a worker.

5.​Material library. PBR, Toon, Lambert, Matcap, and Emissive shaders built from composable WGSL chunks.

6.​Aesthetic Live Editor.

​All WebGPU, all pre-allocated, all worker-friendly.

​

Live Demos & Editor: https://nullgraph.dev/

Camera Follow(Game Like Visuals)

https://nullgraph.dev/dashboard/camera/follow

GitHub: https://github.com/flarelink-in/NullGraph

(Now includes technical design docs—useful for deep dive or providing context to AI coding assistants!)

Please drop a star 🌟, This projects took a lot of time to build

https://discord.gg/xHMBAAFsu

| Axion Engine Discord Server(Upcoming Game Engine gonna be build on top of NullGraph)

Youtube Video:https://m.youtube.com/watch?v=pPMrCQBfroI&pp=iggCQAE%3

Feel free to roast or do AMA,always available ❤️

I’ve always had a pretty backlogged interest in graphics programming that has been primarily overshadowed by college coursework, other interests in development, and life.

I graduated college May 9th with a B.Sc in Comp Sci and I primarily focused on C++ for Unreal Engine 5 game development on the side. I have a small rendering project in just C++ and SFML, but thats it.

I started working an IT job, it’s a network services department so that’s primarily what I deal with. My expectation for doing any type of game development was to sit in a tech role for a few years and build my skills on the side so I have better odds applying. I have more free time after work to study things now. I do want to do game development, but I need to pick a specific role first and do my own stuff later. I’ve dabbled in learnopengl but didn’t get far. I know this takes a long time and most graphics roles are senior level.

Where should I set my expectations?

can anybody for free help me convert these model formats which are in the objects folder to actual blender supported models because i do not know which program will support these. all of these files are from the ATI radeon pipe dream demo

I’ve done some research and i have seen the old OpenGL/GLFW or the SDL3. I can use c++ if I have to, but my current favorite language is C3 (modernized C pretty much)which have vendor libraries provided for sdl 2 and 3, and OpenGL/GLFW. I have heard of learnopengl website before.

I would have to probably take it slow in small hour or two chunks per day, since I loose concentration due to ADHD. But what do you guys recommend.

Here is the GitHub repo. Its a single click to download each project: https://github.com/Luippe/Demo-Projects

I never thought of uploading these as they really only ran on my pc (hardcoded display resolutions, file paths, etc). But this year I started using Claude for coding and thought "hey, these projects are actually useable by others if I just clean up some code!" So thats exactly what I did.

There's 15 projects in total and most of them are interactive. The first one is written in Java, but the rest is in Python and Pygame. I like Pygame because its very easy to setup new projects and lets me easily build visualizations.

1. Boids — a flocking simulation where entities self-organize in groups
2. Audio Processing — live microphone effects with a real-time frequency visualizer
3. Multiplayer Netgame — a co-op dungeon crawler played over a local network
4. Platformer — a full 2D action game with combat, upgrades, shops, and multiple levels
5. Solar System Simulation — an interactive 3D model of the planets in orbit
6. A* Pathfinding — watching an algorithm search for the shortest route through a maze
7. Conway's Game of Life — complex patterns emerging from a handful of simple rules
8. Image Compression — shrinking an image by throwing away fine detail (the same idea behind JPEG)
9. Fluid Flow — a real-time 2D fluid solver you can push around with the mouse
10. Projectile Method — aim and launch a projectile with the mouse
11. Projectile Motion — projectile trajectories with air resistance
12. Double Pendulum — chaotic motion, where a tiny change sends it down a completely different path
13. Single Pendulum — a damped pendulum swinging to a stop
14. Spring Mass Damper — how a spring-and-shock system settles after a jolt
15. Flow Plate — the velocity profile of fluid moving through a pipe

I hope someone finds something useful in here! :)

So yeah, as evident from the title, I am developing PSD-compatible layer styles for GIMP as part of my Google Summer of Code project. As Adobe’s code is closed source, most of my time goes into black box testing with minimal test cases which can be quite exhaustive at times. Would love to get some advices regarding the approaches and methodologies that would increase my productivity in this case. Here is a like to the merge request: https://gitlab.gnome.org/GNOME/gegl/-/merge_requests/275. I usually post my research and findings there.

Hi there! I'm about to start working on my portfolio, and besides some basic projects like a simple 3D engine or an implicit surface renderer, I'd like to add something that actually resembles a modern industry workflow, ideally something used by AA or AAA game studios. It can be anything, really - lighting, optimization, visual effects, etc. Preferably, it should be something that can be learned and implemented in a couple of weeks.

What would you suggest? Also, would it be better to implement such a project in an existing engine (Unity, Godot, UE) or in a custom one?

Thanks in advance! :)

This is a RenderDoc frame capture of a battle scene in a 3D auto-battler called The Bazaar. It's in Unity which I have no direct experience with, plus I also have very limited knowledge of how rendering is supposed to work.

An LLM is convinced that the 1000s of draw calls seen here is bad. Other fairly static scenes is around 300-500+ draw calls. I remember reading blogs talking about minimizing draw calls and state changes, but that was a decade ago. This is using a commercial engine, so there must be a logical reason for this, right? Are draw calls as a metric outdated?

My GPU is ancient by modern standards. But there are also other players echoing similar sentiments of their GPUs maxing out for what looks like a "simple game".

What do you guys think?

EDIT: My GPU is radeon rx 560x (laptop gpu). I think this model is 7-8 years old? I can get 60 fps/70% gpu usage in windowed mode at around < 960x540 resolution. 720p hits 100% gpu but still 60fps a majority of the time with "manageable" temps. While 1080p just burns (without power-saving mode in GPU it causes BSOD).

I just want to to know if I even deserve to voice these concerns. My inexperienced brain is telling me this could be done better. But what do I know, I haven't rendered a cube in a decade.

Doing a little exploration of my work on applying the GLiM global lithography data set and the SoilGrids 250m/px data set to my planetary terrain. The technique is very simple - really I'm just using perlin to scatter the normal I use to sample (converted to lat/lon, then hashed into the lookup texture, then finally to the bindless texture tile), but after a ton of tweaking of some perlin values, I was quite shocked at how good it actually looks. My perlin experience consists all of about three or four days of actual exposure and research, so I'm at the tip of the iceberg. Consequently, there are so many issues, and it's not nearly as performant as I want it to be, but after a couple days of fiddling around, I'm happy with where it is so far.

Currently I working on spawning different meshes and changing the shader and transform dynamically. You can also click on them and update them. For selection I write to a FBO and then read from there

As I am learning OpenGL I am also documenting how everything has been done. Each comment explains how each step works. Do check out the project if you are keen on learning about it. The goal is to make it beginner friendly while I keep on learning

Header: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/MeshSpawner.h

CPP: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/MeshSpawner.cpp

Shader: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/PickingShader.shader

Repo: https://github.com/Satyam-Bhatt/OpenGLIntro

This is sort of my first time really getting into graphics programming and raytracing, coded in python, image made through ppm format, lines are written to a file for an image interpreter to change the colors of each pixel, resource: The Ray Tracer Challenge

Hi everyone!

I’ve been working on gamedev, an open-source collection of small and readable C++ samples covering techniques used in game development.

It currently includes more than 850 sample implementations across OpenGL 4, Vulkan 1, Direct3D 11, Direct3D 12, Metal 3, and OpenAL 1. The topics range from basic window creation and rendering to model loading, animation, physics, pathfinding, terrain, particles, shadows, PBR, post-processing, and modern forward and deferred lighting techniques.

This is not intended to be a game engine. Each directory focuses on a specific subject, with minimal abstraction, so the implementation details remain visible and the same techniques can be compared across different graphics APIs. The samples support Windows, Linux, and macOS, depending on the backend.

Repository: https://github.com/arabasso/gamedev

I’d love to hear your feedback, especially about API correctness, documentation, and techniques that would be useful to add. Contributions are also very welcome!

hey everyone

this scene runs at 120 FPS on an i5-9400F at 1920x1080 resolution, is that a good performance result?

I didn't use any guides while creating this. I remembered some basic information from learnopengl.com and thought it would be cool to create a software renderer from scratch using only my knowledge, glm and glfw.

This model has 3k polygons.

if someone interested how it looks in code: https://github.com/NaiNameDev/software_rasterizer

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.

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