Infinite Mobility Framework

OcMesher is a tool for view-dependent, octree-based mesh extraction in unbounded scenes represented by Signed Distance Functions (SDFs).

Key features:

• Memory Efficiency: Handles unbounded scenes efficiently.
• High Detail: Provides high-fidelity mesh extraction based on specific camera views.
• Infinigen Integration: Used by default in Infinigen to accelerate video generation, improve rendering quality, and export terrain meshes for external simulators.

GLFW is an open-source, multi-platform library designed for developing applications using OpenGL, OpenGL ES, and Vulkan. It provides a platform-independent API for common windowing and input tasks, including:

• Creating windows, contexts, and surfaces
• Reading input (keyboard, mouse, etc.)
• Handling system events

GLFW natively supports Windows, macOS, and Linux (including both X11 and Wayland).

JSON for Modern C++ is a header-only C++11 library designed for intuitive JSON manipulation. It aims to make JSON feel like a first-class data type in C++, similar to how it behaves in Python, by using operator overloading and modern C++ syntax.

Key Characteristics:

• Single Header Integration: The entire library consists of a single header file (json.hpp), requiring no complex build systems or external dependencies.
• Intuitive Syntax: Uses C++ operator magic to allow easy creation and access of JSON objects.
• High Reliability: Heavily unit-tested with 100% coverage and validated with memory sanitizers and fuzz testing.
• Standard Data Types: By default, it uses std::string for strings, int64_t/uint64_t/double for numbers, std::map for objects, std::vector for arrays, and bool for Booleans.

GLM (OpenGL Mathematics) is a header-only C++ mathematics library designed for graphics software. It is based on the OpenGL Shading Language (GLSL) specifications, meaning it uses the same naming conventions and functionality as GLSL. This allows developers familiar with GLSL to use the same logic in C++.

Key features include:

• GLSL Compatibility: Classes and functions mirror GLSL.
• Extension System: Provides extended capabilities like matrix transformations, quaternions, data packing, random numbers, and noise.
• Interoperability: Works with OpenGL and is suitable for software rendering (raytracing/rasterisation), image processing, and physics simulations.
• Header-only: Easy to integrate as it requires no compiled binaries.

The library provides several binary formats to efficiently encode JSON values into byte vectors and decode them back. This is useful for scenarios where JSON is too bulky, such as network data exchange.

Supported formats include:

• BJData (Binary JData)
• BSON (Binary JSON)
• CBOR (Concise Binary Object Representation)
• MessagePack
• UBJSON (Universal Binary JSON)

BJData is a binary JSON-like format derived from the Universal Binary JSON (UBJSON) specification. It is designed to be both compact and quasi-human-readable, as semantic elements like data-type markers and strings remain human-readable.

Key features include:

• Optimized ND-arrays: Efficient storage for N-dimensional packed arrays.
• Expanded Numeric Types: Adds markers for uint16 ([u]), uint32 ([m]), uint64 ([M]), and float16 ([h]).
• Little-Endian (LE): Uses little-endian for all numerics to avoid conversion overhead on most modern platforms.
• Searchability: The format allows for direct searching or reading using simple processing due to its quasi-human-readable nature.

When defining or interacting with creature parts, follow these spatial conventions:

Axis Orientation

• +X: The long axis of the part.
• +Z: The up axis.
• +Y: The left side of a creature, or the leading edge of a leg or wing.
• Parity: Use 1 for the right side and -1 for the left side.

Surface Addressing (3D Polar Coordinates)

To address the surface of a Part, use the Length/Yaw/Rad coordinate system:

• Length: A 0-1 scalar representing the percentage of the length along the skeleton curve.
• Yaw: A [-1, 1] scalar specifying the tangential yaw to shoot a ray.
  • 0: Downwards
  • ±0.5: Left/Right
  • ±1: Upwards
• Rad: A percentage scalar (typically 0-1). The system raycasts using Length and Yaw to the surface, then moves Rad percentage of the way along that ray towards the surface.

When working with Eigen Tensors, several pseudo-types are used in the API documentation to describe behavior:

• <Tensor-Type>::Dimensions: An array-like object of int representing the tensor's dimensions. It has a .size attribute (the rank) and can be indexed like an array.
• <Tensor-Type>::Index: An integer type used for indexing along dimensions.
• <Tensor-Type>::Scalar: The underlying data type of the tensor elements (e.g., float for Tensor<float, 2>).
• <Operation>: Indicates a deferred operation. Operations do not return values immediately; they must be evaluated (e.g., by assigning them to a tensor) before values can be accessed. You can also wrap an operation in a TensorRef to access its dimensions before evaluation.

You can specify the desired runtime platform using the GLFW_PLATFORM initialization hint. This allows you to target specific backends like Win32, Cocoa, Wayland, or X11, or use GLFW_ANY_PLATFORM to let GLFW decide. You can also use glfwPlatformSupported to check if a specific platform is available on the current system and glfwGetPlatform to query which platform was actually selected.

// Example of checking platform support and querying selected platform
if (glfwPlatformSupported(GLFW_PLATFORM_WAYLAND)) {
    // Wayland is supported
}

// Query the currently selected platform
int platform = glfwGetPlatform();

When using binary_t, the way subtypes are handled depends on the target serialization format: