PhysicsEngine | Cute little physics engine | Animation library

You have uninitialized values in your objects. This creates in non debug build random values, in this case the pattern 0xCDCDCDCD is a typical Visual Studio debug value for these uninitialized values.

You may want to use C++11 initialization capabilities as you don't provide a custom constructor. For instance:

if your program (.exe) ONLY use stuff declared and/or defined by the interfaces of the dll's then there is no need for your program-build to be aware of anything that those dll's are using in their implementations.

However if anything from your utils-project is made visible in an interface-header of either dll and you use that in your program code ,then you have a depedency from your program to the utils.dll. Now you need to inform your build environment where to find stuff.

to be concrete:

if you need to include the directory of utils for your build ,then there is a include for a header-file from the utils-project in one or more of the headers of Renderer- and/or PhysicsEngine.

if you need to include the lib-file of utils for your build ,then there is call to one or more exported functions (or methods of an exported class) of the utils.dll

Solution : sanitize the interface-header files of your dll's

Your foundation = line isn't actually calling a constructor. It's trying to cast the raw pointer to a shared_ptr using the syntax called a "functional cast" or "function-style cast" (#2 here), and then assign the result to the foundation variable (which has already been default-constructed). That won't work because shared_ptr has no cast from a raw pointer (to prevent it from accidentally taking ownership of things it shouldn't).

The best way to fix the problem is to use your constructor's initializer list to actually initialize foundation with the pointer:

Your problem isn't the "paint queue", it's the fact that you're violating the single threaded nature of the API, by calling Thread.sleep within the context of the EDT.

Instead of using for-loops with Thread.sleep in them, you should make use of a Swing Timer which updates the state of the variables paintComponent relies on (and call repaint)

Swing Timer can be thought of a pseudo loop, whose ActionListener is called within the context of the EDT, making it safe to update the UI from

Start by having a look at Concurrency in Swing and How to Use Swing Timers for more details

As a conceptual example...

The engine will stall while processing a heavy load (e.g. if you do an infinite loop) inside any function. Things which rely on Time.DeltaTime will start acting up if the frame rate drops too low. It won't really matter whether that's Update or FixedUpdate.

What you can do if you need a process to run a heavy load is to use an coroutines e.g. IEnumerator function and yield, which allows you to split processing over a number of frames, or to have some function called via a callback. e.g. if you have an AI check path 5 times a second you can either handle that in Update with a counter each frame or you can schedule a callback.

Basically, there's going to be limit in how much code you can run per frame without degrading performance. Clever rewriting should make that unnecessary. See if you can cache results of calculations or pre-calculate as much data outside play as possible.