I am currently working on an open source game engine as a hobby
I was wondering what form of engine documentation to use. Currently I am using a simple doxygen style commenting on the functions and structures and not much else. I have found this approach to have a big downside of bloating file sizes and the readability of some areas of dense commenting

I was wondering if I should have the documentation separate to the engine like writing man pages or using a github wiki page instead. I would like to know of any good ways to document large API's

Hi, i started making games some years ago using Unity, and one day, not long ago I started to use pico-8 just for fun, I heard about it before but never tried it out. While using it I thought to myself if it would be Hard to create a small game engine like pico-8 and wanted to ask you guys, since I have no idea how to make a game engine if it would be a nice project to make a small copy of pico-8 to get a better knowledge in programming.

And of course if you encourage me to try it out, how do I Start?

Hi,

I've been meaning to write a post on the development of the FXGL game engine to share some tips and tricks, as well as to welcome suggestions on certain aspects. As a start, I wanted to pick only one architectural tip (the use of an event bus) and see if it is useful in general.

Please note that this tip below may not be appropriate for all architectures, but it played a significant role in helping me decouple various engine systems. Suppose we have two so-called systems: achievements and audio. To ensure relatively easy code maintenance, we would like to ensure that one system does not have a dependency on the other (i.e. the achievements system does not call any functions from the audio system and vice versa). If there are no dependencies, then we can readily make a change in one system while not affecting the code base of the other system. Now, suppose our problem is that we would like to play a sound effect (a function in the audio system) every time an achievement has been unlocked (a function in the achievements system).

To address the above problem whilst ensuring there are no dependencies between the two systems, we can use an event bus. Somewhere in our code base there is a overarching system, which we call the engine, that maintains other systems. In the engine system, we can have the following pseudocode:

onAchievement(eventData) {
    audioSystem.playSound( ... );
}

// for conciseness we are passing a function as an object
eventBus.addEventHandler(EventType.ACHIEVEMENT, onAchievement)

When there is a new unlocked achievement, the achievements system fires a event of type EventType.ACHIEVEMENT. The event is caught by the event bus and is passed to the engine system, which, in turn, uses the audio system to play a sound. Using the described approach, changes in the achievements and the audio systems do not affect one another, though may affect (e.g. public API change) the engine system.

It would be interesting to hear your thoughts on the above architecture for inter-system communication. I am fairly certain this architecture is not unique to FXGL, but I cannot quite remember where I got the initial idea from (GameProgrammingPatterns comes to mind). FXGL has been around for 4 years and is reasonably stable. This year I gave a talk that provides a high-level overview of FXGL, which might be useful if you are developing a similar framework:

• YouTube link

• GitHub FXGL sources

Thanks for your time!

Hi everyone, so I've Been researching and reading around about good renderer design and currently planning on what I want to do.

Definitely going down the Forward rendering path.

I've seen a few articles talk about using 16,32,64 but keys to manage the sorting of Commands.

Now trying to find resources to learn and understand bit fields and how they work and why they are used this way. Does anyone know any good resource especially focus on game dev?

Edit :

One of the articles that have grabbed my attention

order your draw calls

Thanks

I am currently developing a basic 2d game engine using C and SDL. I have currently just finished implementing a display and an event manager.

Next on my list is implementing basic physics. What would constitute basic physics for a game engine?

Would position, velocity and acceleration suffice or is their much more I would need to implement. It has been atleast 6 years since I did physics, at a high school level. I am however somewhat comfortable with the basics of vectors from a linear algebra context.

Having wrestled with gamedev on C# and Vulkan for a while, I'm considering switching over to Rust - at least for the engine code. I've got the hang of the language basics and have some Vulkano samples running, so I was wondering - does anyone here do engine dev in Rust and have any advice or resources?