0645429df9
The root dir of our repository has grown quite a lot the past few months.
I'd like to make it more clear where the bulk of the engine lives (`src/`) and
also make it more clear which Mach libraries are consumable as standalone projects.
As for the name of this directory, `libs` was my first choice but there's a bit of
a convention of that being external libraries in Zig projects _today_, while these
are libraries maintained as part of Mach in this repository - not external ones.
We will name this directory `libs`, and if we have a need for external libraries
we will use `external` or `deps` for that directory name. I considered other names
such as `components`, `systems`, `modules` (which are bad as they overlap with
major ECS / engine concepts), and it seems likely the official Zig package manager
will break the convention of using a `libs` dir anyway.
Performed via:
```sh
mkdir libs/
git mv freetype libs/
git mv basisu libs/
git mv gamemode libs/
git mv glfw libs/
git mv gpu libs/
git mv gpu-dawn libs/
git mv sysaudio libs/
git mv sysjs libs/
git mv ecs libs/
```
git-subtree-dir: glfw
git-subtree-mainline: 0d5b853443
git-subtree-split: 572d1144f11b353abdb64fff828b25a4f0fbb7ca
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
git mv ecs libs/
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
143 lines
5.4 KiB
Zig
143 lines
5.4 KiB
Zig
// TODO: implement custom allocator support
|
|
|
|
// /*! @brief
|
|
// *
|
|
// * @sa @ref init_allocator
|
|
// * @sa @ref glfwInitAllocator
|
|
// *
|
|
// * @since Added in version 3.4.
|
|
// *
|
|
// * @ingroup init
|
|
// */
|
|
// typedef struct GLFWallocator
|
|
// {
|
|
// GLFWallocatefun allocate;
|
|
// GLFWreallocatefun reallocate;
|
|
// GLFWdeallocatefun deallocate;
|
|
// void* user;
|
|
// } GLFWallocator;
|
|
|
|
// /*! @brief The function pointer type for memory allocation callbacks.
|
|
// *
|
|
// * This is the function pointer type for memory allocation callbacks. A memory
|
|
// * allocation callback function has the following signature:
|
|
// * @code
|
|
// * void* function_name(size_t size, void* user)
|
|
// * @endcode
|
|
// *
|
|
// * This function must return either a memory block at least `size` bytes long,
|
|
// * or `NULL` if allocation failed. Note that not all parts of GLFW handle allocation
|
|
// * failures gracefully yet.
|
|
// *
|
|
// * This function may be called during @ref glfwInit but before the library is
|
|
// * flagged as initialized, as well as during @ref glfwTerminate after the
|
|
// * library is no longer flagged as initialized.
|
|
// *
|
|
// * Any memory allocated by this function will be deallocated during library
|
|
// * termination or earlier.
|
|
// *
|
|
// * The size will always be greater than zero. Allocations of size zero are filtered out
|
|
// * before reaching the custom allocator.
|
|
// *
|
|
// * @param[in] size The minimum size, in bytes, of the memory block.
|
|
// * @param[in] user The user-defined pointer from the allocator.
|
|
// * @return The address of the newly allocated memory block, or `NULL` if an
|
|
// * error occurred.
|
|
// *
|
|
// * @pointer_lifetime The returned memory block must be valid at least until it
|
|
// * is deallocated.
|
|
// *
|
|
// * @reentrancy This function should not call any GLFW function.
|
|
// *
|
|
// * @thread_safety This function may be called from any thread that calls GLFW functions.
|
|
// *
|
|
// * @sa @ref init_allocator
|
|
// * @sa @ref GLFWallocator
|
|
// *
|
|
// * @since Added in version 3.4.
|
|
// *
|
|
// * @ingroup init
|
|
// */
|
|
// typedef void* (* GLFWallocatefun)(size_t size, void* user);
|
|
|
|
// /*! @brief The function pointer type for memory reallocation callbacks.
|
|
// *
|
|
// * This is the function pointer type for memory reallocation callbacks.
|
|
// * A memory reallocation callback function has the following signature:
|
|
// * @code
|
|
// * void* function_name(void* block, size_t size, void* user)
|
|
// * @endcode
|
|
// *
|
|
// * This function must return a memory block at least `size` bytes long, or
|
|
// * `NULL` if allocation failed. Note that not all parts of GLFW handle allocation
|
|
// * failures gracefully yet.
|
|
// *
|
|
// * This function may be called during @ref glfwInit but before the library is
|
|
// * flagged as initialized, as well as during @ref glfwTerminate after the
|
|
// * library is no longer flagged as initialized.
|
|
// *
|
|
// * Any memory allocated by this function will be deallocated during library
|
|
// * termination or earlier.
|
|
// *
|
|
// * The block address will never be `NULL` and the size will always be greater than zero.
|
|
// * Reallocations of a block to size zero are converted into deallocations. Reallocations
|
|
// * of `NULL` to a non-zero size are converted into regular allocations.
|
|
// *
|
|
// * @param[in] block The address of the memory block to reallocate.
|
|
// * @param[in] size The new minimum size, in bytes, of the memory block.
|
|
// * @param[in] user The user-defined pointer from the allocator.
|
|
// * @return The address of the newly allocated or resized memory block, or
|
|
// * `NULL` if an error occurred.
|
|
// *
|
|
// * @pointer_lifetime The returned memory block must be valid at least until it
|
|
// * is deallocated.
|
|
// *
|
|
// * @reentrancy This function should not call any GLFW function.
|
|
// *
|
|
// * @thread_safety This function may be called from any thread that calls GLFW functions.
|
|
// *
|
|
// * @sa @ref init_allocator
|
|
// * @sa @ref GLFWallocator
|
|
// *
|
|
// * @since Added in version 3.4.
|
|
// *
|
|
// * @ingroup init
|
|
// */
|
|
// typedef void* (* GLFWreallocatefun)(void* block, size_t size, void* user);
|
|
|
|
// /*! @brief The function pointer type for memory deallocation callbacks.
|
|
// *
|
|
// * This is the function pointer type for memory deallocation callbacks.
|
|
// * A memory deallocation callback function has the following signature:
|
|
// * @code
|
|
// * void function_name(void* block, void* user)
|
|
// * @endcode
|
|
// *
|
|
// * This function may deallocate the specified memory block. This memory block
|
|
// * will have been allocated with the same allocator.
|
|
// *
|
|
// * This function may be called during @ref glfwInit but before the library is
|
|
// * flagged as initialized, as well as during @ref glfwTerminate after the
|
|
// * library is no longer flagged as initialized.
|
|
// *
|
|
// * The block address will never be `NULL`. Deallocations of `NULL` are filtered out
|
|
// * before reaching the custom allocator.
|
|
// *
|
|
// * @param[in] block The address of the memory block to deallocate.
|
|
// * @param[in] user The user-defined pointer from the allocator.
|
|
// *
|
|
// * @pointer_lifetime The specified memory block will not be accessed by GLFW
|
|
// * after this function is called.
|
|
// *
|
|
// * @reentrancy This function should not call any GLFW function.
|
|
// *
|
|
// * @thread_safety This function may be called from any thread that calls GLFW functions.
|
|
// *
|
|
// * @sa @ref init_allocator
|
|
// * @sa @ref GLFWallocator
|
|
// *
|
|
// * @since Added in version 3.4.
|
|
// *
|
|
// * @ingroup init
|
|
// */
|
|
// typedef void (* GLFWdeallocatefun)(void* block, void* user);
|