You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
98 lines
3.3 KiB
Markdown
98 lines
3.3 KiB
Markdown
# Blob Object
|
|
A simple utility for embedding an arbitrary binary blob into an ELF or COFF object file.
|
|
You can then link your program against that object file to be able to access
|
|
the binary blob as a C array.
|
|
|
|
This project will only be updated rarely, if ever.
|
|
This isn't because the project has been abandoned;
|
|
it's just trivial enough that (other than the caveats described below)
|
|
there are few reasons that an update would be necessary.
|
|
|
|
This project is public domain (see `LICENSE`), so feel free to use it however you'd like.
|
|
Credit is optional.
|
|
|
|
## Installation
|
|
This project has no dependencies and can be built with Meson:
|
|
`meson setup build && cd build && meson compile && sudo meson install`
|
|
|
|
You can also compile it manually with your C compiler; meson is just for convenience:
|
|
```bash
|
|
cc -o blob-object-elf subprojects/blob-object-elf/src/main.c
|
|
cc -o blob-object-coff subprojects/blob-object-coff/src/main.c
|
|
```
|
|
|
|
## Usage
|
|
`blob-object-(elf|coff) <output file> <section name> <symbol name> <blob file>`
|
|
|
|
You can include the generated blob object in C using these declarations:
|
|
```c
|
|
// the size in bytes of the blob. can be uint64_t with ELF, but COFF is restricted to 32-bit.
|
|
extern uint32_t const <symbol name>_size;
|
|
// the address of this constant is the beginning of the blob
|
|
extern uint8_t const <symbol name>;
|
|
|
|
// get a reference to your data
|
|
uint8_t* my_data = &<symbol name>;
|
|
```
|
|
|
|
### Example for compiling GLSL shaders to SPIR-V and into your Vulkan program
|
|
Here's an example of how you might use this to include compiled SPIR-V shaders in your executable:
|
|
* `glslangValidator -V100 -o "frag_shader.spv" "frag.glsl"`
|
|
* `blob-object-elf frag_shader.o shaders frag_shader frag_shader.spv`
|
|
* `gcc my-vulkan-program.c frag_shader.o`
|
|
|
|
I wrote a hack to make shader compilation part of the build processess with meson:
|
|
```meson
|
|
compile_shader = find_program(meson.source_root() / 'compile-shader.sh')
|
|
shaders_gen = generator(
|
|
compile_shader,
|
|
output: '@PLAINNAME@.o',
|
|
arguments: [
|
|
'@BUILD_ROOT@',
|
|
'@INPUT@',
|
|
'@OUTPUT@',
|
|
'@PLAINNAME@',
|
|
]
|
|
)
|
|
|
|
sources += [
|
|
shaders_gen.process('shaders/shader.frag'),
|
|
shaders_gen.process('shaders/shader.vert')
|
|
]
|
|
```
|
|
|
|
`compile-shader.sh`:
|
|
```bash
|
|
#!/bin/bash
|
|
build_root="$1"
|
|
src="$2"
|
|
obj="$3"
|
|
name="$4"
|
|
|
|
if [[ "$OSTYPE" == "msys" ]]; then
|
|
make_blob="$build_root/subprojects/make-coff-blob/blob-object-coff.exe"
|
|
else
|
|
make_blob="$build_root/subprojects/make-elf-blob/blob-object-elf"
|
|
fi
|
|
|
|
base_name="${name%.*}"
|
|
ext="${name#*.}"
|
|
|
|
spv="$obj.spv"
|
|
|
|
glslangValidator -V100 -o "$spv" "$src" && $make_blob "$obj" shaders "cg_${base_name}_${ext}" "$spv"
|
|
```
|
|
|
|
## Caveats
|
|
* `blob-object-coff` is restricted to <4GB blobs because COFF is a 32-bit format
|
|
* `blob-object-elf` cannot be used on native Windows because it depends on POSIX
|
|
(fix: this program should use standard library headers instead of POSIX and bundle its own elf.h)
|
|
* both generators are hardcoded to generate object files flagged for x86_64 for their respective platforms
|
|
(fix: add an argument to select which platform to build for)
|
|
|
|
Fixing these things would be pretty trivial; feel free to send a PR.
|
|
I'd also be willing to do it myself if anyone ends up actually using this,
|
|
so you could open an issue instead too.
|
|
|
|
It'd also be nice to support Mach-O (MacOS) and combine both blob-object commands
|
|
into a single executable. |