BitPack | practical tool to efficiently save | Compression library

Finding this on github

This approach is generally safe only if all of the following are true:

• The type contains only "inline" data. This means only fundamental types (no pointers or references) and arrays thereof.
  • Nested objects that also meet these criteria are also OK.
• All of the types have the same representation on all systems/compilers where the program will run.
  • The endian-ness of the system must match.
  • The size of each type must match.
  • Any padding is in the same location and of the same size.

However, there are still some drawbacks. One of the most severe is that you are locking yourself in to exactly this structure, without some kind of version mechanism. Other data interchange formats (XML, JSON, etc.), while more verbose, self-document their structure and are significantly more future-proof.

So, ultimately what I wanted to do is impossible on most mobile systems. It was mostly a hope to expand my potential customer base, but I've decided that the extra complication isn't worth it, and I've dropped mobile support for now.

However, it is possible to get this setup working across DX11.1+, DX12, OpenGL 3.0+, OpenGL Core, and Vulkan. You need to create a native plugin for Unity, and bind all of your rendering resources manually. I couldn't get the P/Invoke approach working,because there's no exposed way to synchronise them with the rendering context. I did want to do this to remove Unity's mesh interop cost anyhow, so it's probably a good thing to be forced into. Anyhow, I wanted to post back here for anyone trying something similar in future and say that it seems the only way to do this is with a native plugin.

One approach:

Add a constructor which takes void*.

Since literal 0 is implicitly convertible to a void* null pointer, and literal 1 isn`t, this will give the desired behavior indicated. For safety you can assert that the pointer is null in the ctor.

A drawback is that now your class is constructible from anything implicitly convertible to void *. Some unexpected things are so convertible -- for instance prior to C++11, std::stringstream was convertible to void*, basically as a hack because explicit operator bool did not exist yet.

But, this may work out fine in your project as long as you are aware of the potential pitfalls.

Edit:

Actually, I remembered a way to make this safer. Instead of void* use a pointer to a private type.

It might look like this: