I'm curious, why the move "back" from "modern C++" to C with classes?
I use a mixture of both styles.
Modern C++ styles are great for RAII, resource management, clean code with solid invariants, easy composition of objects, etc....
C-styles are great for the KISS and YAGNI principles, non-bloated code (
smaller, very simple, isolated systems with minimal dependencies) that's easy to maintain or even re-write.
e.g. a model loader might be a 'modern' C++ class, that implements some kind of resource loader interface, and can be plugged into some kind of opaque file-system interface.
However, inside the model loader, the internal data-structures that make up a "model file" might just be plain old C structures that can be memcpy'ed around the place.
Actually, for simplicity, I don't share any code between my engine's model loader, and the tool that creates model files -- instead a specification document of these data-structures is all that's shared. A C# model convertor program can write out these binary structures to a file, and then the engine can load such a file and just cast the loaded memory block to a particular type of struct. Without any kind of parsing/deserializing step, the model file's structures are immediately ready for use
A lot of people are doing similar things with their "component systems" these days, where components are just plain-old-data, allocated in large arrays. You can then have large chunks of fairly typical looking C++ code that interact with these big arrays of plain C data.
With the responses i've gotten, [making an engine] doesn't seem scary.
People's responses are going to be extremely irrelevant, because you are not in the same situation as other people. Other people have different definitions of what an engine is, different experience levels, different skill-sets, different games to be made, different support networks and colleagues, different amounts of free-time and different expectations.
The best thing to do is start off with a big list of all the things you need to do, then pick one item and break it down into another list of tasks that need to be done to build this thing. Then for each task, break it down into another list of steps of how you'd achieve it.
Along the way of doing this, you're probably going to encounter a lot of tasks where you'll need to learn some new knowledge in order to complete them (e.g. how to use a std::vector).
As long as you've got a huge list of tasks that involve learning and discovery like this, you can't really come up with any kind of sensible time-frame or expectation of what your results are going to be like.
Great to see you made a game engine using a bunch of what i want to use too (c++, lua, physx, directx, fmod) ... and in a year.
For full disclosure though -- before I wrote my own engine in a year, I spent 4 years practicing using every feature of the GoldSrc game engine while studying, a year building a game engine around the Gamebryo graphics engine professionally, spent 4 years making my previous hobbyist engine, tested out endless open-source and publicly available engines in my spare time, and worked as a graphics programmer on half a dozen commercial games (
using 3 different proprietary engines)... Then after all that, I'd learned enough to be extremely confident in making my own commercial-quality engine from scratch in a short time-frame.