I've finished the demo, this bit is the heavy code that makes binary data. Next is this bit which is made per map and is a nice little way to make a map. I didn't include encouonter data just to save time and effort. I'll also be saving this in my library for obvious purposes. Unfortunately, php is always subject to annoying changes so a better solution might be advisable for the future, but this is a simple way to look at it. Of course, it wouldn't be complete without the binary dump. 570 bytes and includes most of what you'd need.

Fortunately, you can use
extern "C"
to define functions that use the C API, which I would not expect to change (and which is the easiest way to interact with other languages, since every mainstream language has some way to call C functions).

The code I use is literally this: It assembles (using GNU assembler) on both x86 and ARM, as it doesn't contain any actual assembly instructions. The ".word 0" at the end of each part is there to ensure that the strings are null terminated, so that C doesn't get confused.

Seems like more work than necessary. Triangles is all normal, but trying to map pixels to only 2 triangles (why not use a quad at that rate?) seems like you'd be better off using a 2d library like SDL2 and blitting it in, since you're ultimately doing the same thing, anyway, if i'm reading what you're saying right. If i were to use the GPU, i'd make flat polies (either quads or triangles) and use traditional textures then find out some way to throw the transparency onto the GPU (i've never really looked into this outside of SDL and layered windows, but i imagine the GPU has some function for dealing with an alpha channel in a texture).

I like Python's indentation, as it makes it easy to tell what code is part of which block, and it avoids bad indentation style. Also, indentation is easier to type than curly braces. (The only issues with this are when you try tpo mix spaces and tabs in the same program, which can cause strange error messages in some cases, and when trying to post code in places that eat whitespace.)

OpenGL ES doesn't have quads.

(Some platforms, like the Raspberry Pi, only support OpenGL ES (unless you use something like LLVMpipe).)

I don't know if that's going to remain the case, though. You'd think they wouldn't bother changing the mangling for C++ (as it is right now, it's just _Z[function name here][parameter suffices here]), but that's precisely what they want to do, and possibly change internal handling of certain types. They specifically cite this as a problem for "why we can't move forward," which indicates to me that this is indeed what they want to change. See, that's what I tried to do, but I had trouble actually exporting that.

Also, you have to be careful with .word, because a word in ARM is 4 bytes, not 2, where as it's 2 bytes in x86. For your null terminators, there, that's not a problem. And then there's also the ugly trouble of forcing it to export it since it tries to make a.out into an ELF instead, which isn't trivial on all systems. For example, on my one system, ld is not available, and objcopy wants a target. And, given it has a specific target machine, sometimes this doesn't start at offset 0, which can be a problem, since it can vary per architecture.

This isn't too bad if you're trying to embed it into your program, but if you're trying to use this to make a binary format for something external to the program itself, that's a problem.

It can make it unreadable if you have a long object chain or want to spread a long function call out over several lines to comment on each parameter. Also, trivial things like a quick "fprintf(stderr, "File not found!\n"); exit(1);" can't be thrown on one line (which makes things seem far less verbose, as you'll see in the php code above). And, let's not get into the forever into egypt stuff with excessive nesting. Oh yeah, forgot about that. Still, it's easier to make a pseudo-quad and map the image to that ("draw_quad(x, y, xsize, ysize, texture);") so that you only have to deal with it that way. They'll be quads as far as you're concerned, but you just have to write the code that makes a quad out of triangles that you then texture. And I did google the alpha channel thing and indeed gles supports alpha channels. And, of course, for performance you'll want to cache as much as you can. The less you touch the FPU, the better.

That is the wierd thing, I am using a rtx 2060 and a 4600h, so it's pretty new hardware. But I do agree, this is early access so hopefully it will be optimized. It might also just be because I used the Linux version which probably isn't tested that much.

So they still update Unreal 4 as well.

https://www.epicgames.com/site/en-US/news/unreal-engine-4-27-is-now-available