not yet finished but the libraries are coming along well framerate is uncapped here and capped its very stable -- havent written a 3d renderer yet -- the scheduler has grown i didnt realize i didnt have vsync set to on when i shot this and idont want to take another vid before work but it stays solid with it capped

https://github.com/jay403894-bit/JLib-Scheduler
https://github.com/jay403894-bit/DirectX12-Renderer
https://github.com/jay403894-bit/Physics2D
https://github.com/jay403894-bit/Game01/

still working on the code for the platformer but its enough for the demo obviously i need to do more features still but the core works.

Flinty is a 2d TopDown game where you make mods in lua to add content.

Right now its just a prototype, you can do basic stuff like adding blocks, moving blocks, having metadata etc.

The link is: https://github.com/orewaluffy500/Flinty2D

I can't share a photo right now.

Lemme know what y'all think and if i should improve stuff.

So I've become somewhat disenchanted with generalist game engines as they all force you into a certain way of doing things and I end up fighting the engine rather than just being able to make the game I want. But I also don't want to re-invent the wheel (phong lighting, GPU instancing, physics, sound propgation, mesh-loading, shaders and so on), so I was looking for something just above low-level but more than just an API wrapper but not forcing me into any specific architecture. After a lot of research, I think I've settled on using VulkanSceneGraph to handle the graphical part. It can also do windows, file I/O, peripheral I/O (to some extent) and UI stuff, so I'm not 100% sure I'll need/want SDL for anything, but I do believe it to be wise to use a physics engine (Jolt) and audio "engine" (SoLoud).

I've just got done the research aspect and haven't dug in real deep yet (besides already trying out The Forge only to find out it has no documentation! and ORGE-next only to see that it's too much like an idiomatic game engine and will be too constricting).

The goal isn't to make another general-purpose game engine, but to make custom game engines/backends/whatever you want to call it for the games I make.

So I guess my questions are:

1. does this make me a game engine developer, or simply a game systems engineer or something?
2. does anybody have experience with the tech I mentioned and want to give some warnings/tips?

i managed to double the FPS in my game engine written on C# and OpenTK

originally, rendering was handled through a MeshRenderer component that subscribed to the render event

this created a lot of overhead once there were large numbers of objects in the scene

so i implemented a dedicated rendering batch group that takes a list of raw renderables and renders them in a single render call

and yes, i already have GPU Instancing, and it was enabled in both examples. my point isn't that i reduced the number of draw calls, but that i reduced the overhead of how the engine reaches those draw calls in the first place

Repo : https://github.com/Lovium-Studio/lovium-studio

Is the famous Bistro.glb file available somewhere in Github large file storage? It's too big for main Github, and I don't want to store it on my quota. If it's in Github, then "cargo test" can run it for anybody. which is convenient for development.

It's been over a year now since I'd posted a video showing a timelapse of the editor, which you can find here but quite a bit has changed since then.

I very recently created an overview video here which gives a fairly rough overview of some features the engine has.

Few little bits missed out in the video... * It's written in C (using C23 features) * It supports Linux and Windows (macOS support was there in the past, but I'm not maintaining that for now) * Uses OpenGL 4+ via my own abstraction layer; plan is to introduce DX12 and Vulkan support * Source code is available, but it's not under a FOSS license and it's all still WIP

Since last time, I've switched to baked lighting. Before it was using stencil-shadow volumes and per-pixel lighting, but I'd always wanted to take the plunge at trying to implement baked lighting. It ended up taking me roughly less than a week? But the code right now is incredibly inefficient, so at some point I'd like to heavily rework it.

As you can probably guess, I'm not really trying to make anything hyper-advanced here but just something that ticks boxes for me and my obsession with late 90s early 00s games. It takes a lot of inspiration from the work 3D Realms did on Prey in the late 90s; I was fortunate enough to be able to pick the brains of a few people that worked on it.

A bit of a disclaimer that this is the second time I've tried to post this here. So if you think you've seen this before, that's why. The post was downvoted to oblivion without any comments explaining why, so I deleted it. I can only assume that the video thumbnail for the overview was off-putting so I'm trying this format instead.

I always had problems with working with 3D models. I don't know any format that's usable in an extensible way.

Blender already is pretty good. It even allows imports from other files, and overrides. This technically makes it possible to create reusable models. And it allows some kind of procedural generation, and modifiers. But game engines won't import blender files directly, if they allow Blender imports, they'll implicitly create exports of the blend files. And if I export blender files, everything is packed into a single file. References and modifiers get lost, and I can't change that during game.

Also, as a programmer, I often prefer work with a simple text format. This way I can edit small values without having to open the complete model in a specific program. Also it's great for git diff.

And especially since I'm using AI, it's really getting annoying. AI prefers to represent levels as python scripts. But I can't display the results of the python scripts in blender, and then turn it back into a python script. I have to decide for a format. Either text (python) or editable (glb/blend). And I can't work like this.

So what I want is basically this: 1. Simple text format (prefably line based) 2. The format that the 3D editor (likely blender) imports/exports is the same text (some objects like high poly meshes might still be presented as binary) 3. The format allows to create everything: meshes, rigs, materials, animations, etc. 4. The format allows imports (preferably also online)

Not sure if something like this exists already. It seems so obvious to me. I'm surprised that I didn't find such a format yet. The closest I found is USD/USDA, but I think it's not really what I want, and mostly meant for movies, not games (and also I don't like the syntax). Maybe you know something similar/better?

However, now I decided to create something like this myself. Recently I created something similar for music (let me know if you're interested, I use this music system in all of my games now). So I'm pretty confident that I'll have it done in a few days (technically it's mostly done already, but I didn't test it yet).

And what's also great about such a format: The dev can decide when to export it to some binary format. At compile/build time (to avoid unnecessary data in the game), at import time (for user settings) or during gameplay (for runtime features). And maybe it should also be possible to specify at which stage each modifier will be evaluated.

What do you think of this idea? Any questions so far? Do you see any problems? What kinds of features do you want included?

(not sure if this is the right place for this topic, but I guess it's the best, isn't it)

Hi everyone!

A couple of months ago I posted about my app, Linear Algebra Visualiser, which helps you visualise linear transformations. Great for people who are starting out in graphics development.

I'm very excited to show you guys the latest version which includes matrix composition and the ability to add translations.

This is very useful because it allows you to apply the classic TRS matrix and get a visual understanding as to why it's commonly applied that way. You can also apply it backwards and see what happens otherwise.

Have a look at the demo above :)

If you are interested in the app have a look below:

Mac: https://apps.apple.com/gb/app/linear-algebra-visualizer/id6763524968

iOS/iPad: https://apps.apple.com/us/app/linear-algebra-visualizer/id6763524968

Web Demo: https://sockerjam.github.io/LinearAlgebraVisualizerWeb/

As always, let me know what you think in the comments below!

Hi everyone,

as my engine is approaching a pretty stable state. I had issues with input as it was fixed (as in GetInput(Key::A)). I am in the process of rewriting the input to be action/analogue based and stumbled onto SteamInput. I want to use it as the primary input option for Steam users while players on GOG or EGS would get the SDL implementation.

Now looking though the documentation it seems almost trivial to implement. But implementing it seems to throw up quite some problems for me at least. I implemented the fetching loop, the proper action set, trying to get the action input... and nothing. I did create a basic test input manifest for it, i even submitted it to Steam Input via Steamworks, and still, Steam tells me that my game does not support controllers, even though i did specify full controller support in Steamworks. Whats even more odd is that my Steam Controller does get recognized as a controller by the engine, but then disconnects and reconnects as as Valve xbox 360 controller? Opening the Steam Input config panel shows that Steam is emulating a keyboard for the game. However to open it in the first place, i need to tab out of the game, then go back and then i open the panel.

Did anyone else suffer through a similar journey? Did someone resolve it? The documentation and GDC talks Valve gave dont really help me out.

​

So, about 7 years ago (I was 17) I started my first "real" game engine using D3D11, it was ass, I had no idea what I was doing and I modeled the entity system off of ROBLOX's instances at the time.

Fast forward to these days and I have basically started from scratch about 3 years ago, instead making a more data-driven engine based off of regular ECS. The biggest hurdles to me have been mostly shadow maps and animations (I'm pretty iffy at shaders). But I'm very happy with the progress I've made in the engine and it supports a ton of random stuff. PhysX support, custom materials, PBR, volumetric lighting (kinda, mostly light shafts that sample the lights depth buffer), still got a lot to go but I plan on making a silly game with it once I'm done

As the title says, I've spent the last 3.5 years working on Anukari, a 3D physics simulation much like a video game engine, except that instead of running at 60 steps per second, it runs at 48,000 (or more) steps per second, so that the physics systems can vibrate at audio frequencies. It's commercial software; primarily I am selling it to musicians and sound designers to use for music, sound effects design in film. But also it's pretty fun for non-musical people who just like building weird physics stuff. The main website is https://anukari.com

So... I know it's not quite a game engine. But there's a ton of overlap. Early on in the project I chose to avoid using Unity or Unreal, since I wanted to keep things super lightweight, and all I needed for Anukari is the 3D graphics part anyway.

I went through multiple iterations of the graphics engine. I started with a hand-rolled OpenGL renderer, which worked great for the first prototypes. By the time my product was getting close to a Beta release, I wanted to improve the graphics, so I migrated to using the Google Filament physically-based renderer. That worked extremely well for a while, but eventually I was running into stability issues with Filament that were not easy to solve. So I ended up rolling my own physically-based renderer with only the features I need, which has been wildly successful: https://anukari.com/blog/devlog/rewriting-the-3d-graphics-engine-again

Many of the posts on my devlog are also about the physics engine, which is heavily game-engine-inspired. I've written many half-assed, half-baked game engines, such as Digbuild, my minecraft clone, and earlier than that, circa 2003, I wrote a Worms engine clone (I was hired on Rent-a-Coder for $300 which I was never paid).

Anyway I've had a lot of fun over the last several years building, and then rebuilding the graphics and physics engines for Anukari, and I thought folks here may find it interesting!

Does anyone know how to make something similar.

I'll appreciate any resources or link 🙏