Jump to content

View more

Image of the Day

Boxes as reward for our ranking mode. ヾ(☆▽☆)
#indiedev #gamedev #gameart #screenshotsaturday https://t.co/ALF1InmM7K
IOTD | Top Screenshots

The latest, straight to your Inbox.

Subscribe to GameDev.net Direct to receive the latest updates and exclusive content.

Sign up now

hot swap / live reload

4: Adsense
  • You cannot reply to this topic
4 replies to this topic

#1 petya-kurochkin   Members   


Posted 20 April 2017 - 12:37 PM


Sorry for opinion-based question, but I'm a newbie in C++ so I'm not able to make decisions on my own yet :-) 



Today I've done a proof of concept of live reload C++ code that could be okay for level editors / scripts and so on. I think there're a lot of people who also use such mechanism in their game editors.

What do you think about it? How do you keep the save of app when it changes? What problems does it have? Is it better for you than lua/python/js?

I see the next advantages:

  1. After I've done with experiments, I can just include source code to my project and compile it statically.
  2. I can use all low-level API that, usually, is not available in scripting languages.
  3. Should work fast (but I haven't measured yet).
  4. Full-featured IDE is available (in Python I have some problems with autocomplete, JS also doesn't know about types/etc, for your own script you I also need my own IDE :-) ).

Disadvantages (?):

  1. I'm not sure that it's fast yet (virtual functions, dynamic linking).
  2. I'm not sure it's stable yet. Perhaps, between reloading it'll give me some kind of segfault. But not in my hello worlds it's still stable :-/
  3. Perhaps, C++ is not good at scripting? :-/

Edited by petya-kurochkin, 20 April 2017 - 12:38 PM.

#2 Nypyren   Members   


Posted 20 April 2017 - 02:18 PM

It should work fine as long as you handle every low-level nuance of compiled code and data that you are going to use.

Allocated objects from version N may need their vtable pointers patched when version N+1 code is loaded.

Allocated objects for types that had their binary layout change need to be remapped.

Any function pointers or pointers to static data that you're reloading need to be patched.

You might decide that it's easier to serialize all dynamically allocated data when unloading version N and deserialize it after version N+1 loads. It might be hard to make sure you don't have lingering references anywhere.

Edited by Nypyren, 20 April 2017 - 02:19 PM.

#3 ApochPiQ   Moderators   


Posted 20 April 2017 - 02:41 PM

The advantages of hot-swapping code tend to increase dramatically with team size.

In other words, if it's just you, you might get some small wins from it, but you'll probably drain a ton of time into the kinds of bit-twiddling issues that Nypyren listed.

If it's a lot of people (read: at least 5) and they're all better C++ programmers than they are at [some scripting language X], then this can be a big win, because you don't have to lose your mental model of how the language works while iterating.

In any case it's a cool tech demo to have in your back pocket and I think it leads to learning a lot about how C++ is implemented in the real world, which is valuable knowledge. Just be careful not to fall into the trap of spending more time on your reloading infrastructure than you do on your game :-)
Wielder of the Sacred Wands
[Work - ArenaNet] [Epoch Language] [Scribblings]

#4 ddengster   Members   


Posted 21 April 2017 - 01:26 AM

I've had hotloading code in my game for some time now, it comes in the form of a reloadable dll where I recompile and reload code. Here's some best practices that I recommend.

- Avoid having to fiddle with vtables (that means not having your class hierarchies inherit across the reload dll). Instead, pass in a vector of structs which contain functions and values to be reloaded. The highly probable cause of most crashes resulting from this reloading code is using old function addresses that not longer exist on the dll since it was reloaded, weren't wiped on the executable.

- Start with a small sub-system in your game first. Particle systems are one of those; try tweaking and live reloading some particle movements. It's a different experience compared to tweaking knobs/sliders on a GUI.

#5 Juliean   Members   


Posted 21 April 2017 - 04:54 AM

Is it better for you than lua/python/js?

C++ as a scripting environment for gameplay, over [everything else]? Never. I really like low-level coding in C++, and far prefer it to ie. C#, but for coding gameplay, its too verbose to me, even with C++1X, and requires you to do too much "unnecessary" shit to be worth it (.h/.cpp-splits ie). Moreever, you'd probably need a good editor binding for your C++-code to be worth a damn as a replacement for regular scripting - think in terms of Unreal, where you can mark variables of your C++-classes to be editable in the editor, etc... . And thats probably much more trivial with "common" "scripting languages" like lua, which support reflection.

TBH, I personally even prefer visual scripting far over regular scripting/coding these days anyway (my current projects gameplay-code is 100% "Blueprints"), so I'd never ever go to C++ for that. Just my 2 cents, might be just personal preference for all its worth.

Edited by Juliean, 21 April 2017 - 04:55 AM.