Several things.
1. Manager class.
"Manager" classes are usually a bad name, that is not a single responsibility. For cases like this, often there is a resource loader that parses and builds, resource cache that has the instances, resource proxies for use before the loading has taken place, and a resource pool where they are all accessed.
2. Singleton vs singleton.
There are "Singletons", as in the design pattern Singleton where only a single instance can be created. There are also singletons that happen to only have one instance created.
The first one, having code that strictly enforces only a single instance be created, typically through automatic means, that is a bad idea. Having code that happens to only create one instance but could create more if the programmers wanted, that is fine. In your case the static member variables mean there can only be one instance ever, and it will cause problems.
Get rid of your static values. The make the code fragile and will force you to rewrite both this system and code that relies on it later.
3. Global variables.
Sometimes global variables are a viable solution. The critical key to determine if it is Good or Evil is if the global variable has shared mutable state. If any code anywhere can change the value at any time, that is Evil. The bugs are usually subtle and difficult to find.
For example, someone not log ago shared a bug about how their game would work just fine for a time, then suddenly all the text would become corrupt. They could not find the change. Nothing in their code indicated what was going on, one moment all the text was just fine, the next everything became visibly corrupt. Debugging showed that the contents of the strings was unchanged. After much hunting, someone realized the display was actually unicode, the 8-bit characters were being interpreted as 16-bit characters. After even more investigation they found one of the libraries they were using for text had a flag that set if the text mode was 8-bit characters or 16-bit characters. Somehow, something in the code was changing that global flag. Fortunately at that point it became a matter of memory breakpoints. They discovered that the Unicode flag was being set and cleared multiple times in various places in multiple libraries every frame. At that point the fix was straightforward, but the problem took quite a long time to track down.
Having a well-known instance is a hidden dependency, but if you implement strict rules to ensure the well-known instance is immutable and will not change, it is sometimes an acceptable tradeoff. This is typically implemented as a globally accessible structure that has pointers to instances. The pointers are configured at startup and can be replaced.
However, a better solution is ...
4. Dependency Injection.
If you are familiar with SOLID development principles, you should know about handling dependencies. In well-designed systems there should be interfaces for behavior. Code should be written to accept objects that implement the interface rather than accept concrete types. Then developers can build new concrete types and they will automatically integrate and work cleanly with the code.
If you have written your code according to SOLID principles, it is easy to inject the concrete class. It sounds hard, but really it just means providing constructor parameter and/or a member function that accepts a new interface.
For example, if you went with a combination of a texture loader / cache / proxy / pool rather than a monolithic "Manager" class, and each of the loader / cache / proxy / pool types had an interface, you could add a function that sets their owning pool, accepts an object that accepts the interface, and then the object uses the interface. Alternatively, you can require the interface pointer be passed to any calls that need it, which is the most explicit way to do things but requires a bit of discipline.
When code needs several interfaces passed to it, it can also make sense to have a structure with a bunch of interface pointers. Fill out the structure with the active objects and pass the structure around for less typing.