// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint
import 'dart:ffi' as ffi;

class NativeLibrary {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  NativeLibrary(ffi.DynamicLibrary dynamicLibrary)
      : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  NativeLibrary.fromLookup(
      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
          lookup)
      : _lookup = lookup;

  ffi.Pointer<ffi.Void> create_filament_viewer(
    ffi.Pointer<ffi.Void> context,
    ffi.Pointer<ResourceLoaderWrapper> loader,
    ffi.Pointer<ffi.Void> platform,
    ffi.Pointer<ffi.Char> uberArchivePath,
  ) {
    return _create_filament_viewer(
      context,
      loader,
      platform,
      uberArchivePath,
    );
  }

  late final _create_filament_viewerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ResourceLoaderWrapper>,
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('create_filament_viewer');
  late final _create_filament_viewer = _create_filament_viewerPtr.asFunction<
      ffi.Pointer<ffi.Void> Function(
          ffi.Pointer<ffi.Void>,
          ffi.Pointer<ResourceLoaderWrapper>,
          ffi.Pointer<ffi.Void>,
          ffi.Pointer<ffi.Char>)>();

  void destroy_filament_viewer(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _destroy_filament_viewer(
      viewer,
    );
  }

  late final _destroy_filament_viewerPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'destroy_filament_viewer');
  late final _destroy_filament_viewer = _destroy_filament_viewerPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ResourceLoaderWrapper> make_resource_loader(
    LoadFilamentResourceFromOwner loadFn,
    FreeFilamentResourceFromOwner freeFn,
    ffi.Pointer<ffi.Void> owner,
  ) {
    return _make_resource_loader(
      loadFn,
      freeFn,
      owner,
    );
  }

  late final _make_resource_loaderPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ResourceLoaderWrapper> Function(
              LoadFilamentResourceFromOwner,
              FreeFilamentResourceFromOwner,
              ffi.Pointer<ffi.Void>)>>('make_resource_loader');
  late final _make_resource_loader = _make_resource_loaderPtr.asFunction<
      ffi.Pointer<ResourceLoaderWrapper> Function(LoadFilamentResourceFromOwner,
          FreeFilamentResourceFromOwner, ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> get_asset_manager(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _get_asset_manager(
      viewer,
    );
  }

  late final _get_asset_managerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('get_asset_manager');
  late final _get_asset_manager = _get_asset_managerPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void create_render_target(
    ffi.Pointer<ffi.Void> viewer,
    int texture,
    int width,
    int height,
  ) {
    return _create_render_target(
      viewer,
      texture,
      width,
      height,
    );
  }

  late final _create_render_targetPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.IntPtr, ffi.Uint32,
              ffi.Uint32)>>('create_render_target');
  late final _create_render_target = _create_render_targetPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, int)>();

  void clear_background_image(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_background_image(
      viewer,
    );
  }

  late final _clear_background_imagePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_background_image');
  late final _clear_background_image = _clear_background_imagePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void set_background_image(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> path,
    bool fillHeight,
  ) {
    return _set_background_image(
      viewer,
      path,
      fillHeight,
    );
  }

  late final _set_background_imagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('set_background_image');
  late final _set_background_image = _set_background_imagePtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  void set_background_image_position(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
    bool clamp,
  ) {
    return _set_background_image_position(
      viewer,
      x,
      y,
      clamp,
    );
  }

  late final _set_background_image_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Bool)>>('set_background_image_position');
  late final _set_background_image_position = _set_background_image_positionPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double, double, bool)>();

  void set_background_color(
    ffi.Pointer<ffi.Void> viewer,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _set_background_color(
      viewer,
      r,
      g,
      b,
      a,
    );
  }

  late final _set_background_colorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float)>>('set_background_color');
  late final _set_background_color = _set_background_colorPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, double, double, double, double)>();

  void set_tone_mapping(
    ffi.Pointer<ffi.Void> viewer,
    int toneMapping,
  ) {
    return _set_tone_mapping(
      viewer,
      toneMapping,
    );
  }

  late final _set_tone_mappingPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'set_tone_mapping');
  late final _set_tone_mapping = _set_tone_mappingPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void set_bloom(
    ffi.Pointer<ffi.Void> viewer,
    double strength,
  ) {
    return _set_bloom(
      viewer,
      strength,
    );
  }

  late final _set_bloomPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float)>>(
      'set_bloom');
  late final _set_bloom =
      _set_bloomPtr.asFunction<void Function(ffi.Pointer<ffi.Void>, double)>();

  void load_skybox(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> skyboxPath,
  ) {
    return _load_skybox(
      viewer,
      skyboxPath,
    );
  }

  late final _load_skyboxPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>('load_skybox');
  late final _load_skybox = _load_skyboxPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  void load_ibl(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> iblPath,
    double intensity,
  ) {
    return _load_ibl(
      viewer,
      iblPath,
      intensity,
    );
  }

  late final _load_iblPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Float)>>('load_ibl');
  late final _load_ibl = _load_iblPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, double)>();

  void remove_skybox(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _remove_skybox(
      viewer,
    );
  }

  late final _remove_skyboxPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'remove_skybox');
  late final _remove_skybox =
      _remove_skyboxPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void remove_ibl(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _remove_ibl(
      viewer,
    );
  }

  late final _remove_iblPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'remove_ibl');
  late final _remove_ibl =
      _remove_iblPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  int add_light(
    ffi.Pointer<ffi.Void> viewer,
    int type,
    double colour,
    double intensity,
    double posX,
    double posY,
    double posZ,
    double dirX,
    double dirY,
    double dirZ,
    bool shadows,
  ) {
    return _add_light(
      viewer,
      type,
      colour,
      intensity,
      posX,
      posY,
      posZ,
      dirX,
      dirY,
      dirZ,
      shadows,
    );
  }

  late final _add_lightPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(
              ffi.Pointer<ffi.Void>,
              ffi.Uint8,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Bool)>>('add_light');
  late final _add_light = _add_lightPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, int, double, double, double, double,
          double, double, double, double, bool)>();

  void remove_light(
    ffi.Pointer<ffi.Void> viewer,
    int entityId,
  ) {
    return _remove_light(
      viewer,
      entityId,
    );
  }

  late final _remove_lightPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'remove_light');
  late final _remove_light =
      _remove_lightPtr.asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void clear_lights(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_lights(
      viewer,
    );
  }

  late final _clear_lightsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_lights');
  late final _clear_lights =
      _clear_lightsPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  int load_glb(
    ffi.Pointer<ffi.Void> assetManager,
    ffi.Pointer<ffi.Char> assetPath,
    bool unlit,
  ) {
    return _load_glb(
      assetManager,
      assetPath,
      unlit,
    );
  }

  late final _load_glbPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('load_glb');
  late final _load_glb = _load_glbPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  int load_gltf(
    ffi.Pointer<ffi.Void> assetManager,
    ffi.Pointer<ffi.Char> assetPath,
    ffi.Pointer<ffi.Char> relativePath,
  ) {
    return _load_gltf(
      assetManager,
      assetPath,
      relativePath,
    );
  }

  late final _load_gltfPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('load_gltf');
  late final _load_gltf = _load_gltfPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Char>)>();

  bool set_camera(
    ffi.Pointer<ffi.Void> viewer,
    int asset,
    ffi.Pointer<ffi.Char> nodeName,
  ) {
    return _set_camera(
      viewer,
      asset,
      nodeName,
    );
  }

  late final _set_cameraPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('set_camera');
  late final _set_camera = _set_cameraPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void set_view_frustum_culling(
    ffi.Pointer<ffi.Void> viewer,
    bool enabled,
  ) {
    return _set_view_frustum_culling(
      viewer,
      enabled,
    );
  }

  late final _set_view_frustum_cullingPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'set_view_frustum_culling');
  late final _set_view_frustum_culling = _set_view_frustum_cullingPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();

  void render(
    ffi.Pointer<ffi.Void> viewer,
    int frameTimeInNanos,
    ffi.Pointer<ffi.Void> pixelBuffer,
    ffi.Pointer<
            ffi.NativeFunction<
                ffi.Void Function(ffi.Pointer<ffi.Void> buf, ffi.Size size,
                    ffi.Pointer<ffi.Void> data)>>
        callback,
    ffi.Pointer<ffi.Void> data,
  ) {
    return _render(
      viewer,
      frameTimeInNanos,
      pixelBuffer,
      callback,
      data,
    );
  }

  late final _renderPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              ffi.Uint64,
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<
                  ffi.NativeFunction<
                      ffi.Void Function(ffi.Pointer<ffi.Void> buf,
                          ffi.Size size, ffi.Pointer<ffi.Void> data)>>,
              ffi.Pointer<ffi.Void>)>>('render');
  late final _render = _renderPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>,
          int,
          ffi.Pointer<ffi.Void>,
          ffi.Pointer<
              ffi.NativeFunction<
                  ffi.Void Function(ffi.Pointer<ffi.Void> buf, ffi.Size size,
                      ffi.Pointer<ffi.Void> data)>>,
          ffi.Pointer<ffi.Void>)>();

  void create_swap_chain(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Void> window,
    int width,
    int height,
  ) {
    return _create_swap_chain(
      viewer,
      window,
      width,
      height,
    );
  }

  late final _create_swap_chainPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Uint32, ffi.Uint32)>>('create_swap_chain');
  late final _create_swap_chain = _create_swap_chainPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int)>();

  void destroy_swap_chain(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _destroy_swap_chain(
      viewer,
    );
  }

  late final _destroy_swap_chainPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'destroy_swap_chain');
  late final _destroy_swap_chain =
      _destroy_swap_chainPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void set_frame_interval(
    ffi.Pointer<ffi.Void> viewer,
    double interval,
  ) {
    return _set_frame_interval(
      viewer,
      interval,
    );
  }

  late final _set_frame_intervalPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float)>>(
      'set_frame_interval');
  late final _set_frame_interval = _set_frame_intervalPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double)>();

  void update_viewport_and_camera_projection(
    ffi.Pointer<ffi.Void> viewer,
    int width,
    int height,
    double scaleFactor,
  ) {
    return _update_viewport_and_camera_projection(
      viewer,
      width,
      height,
      scaleFactor,
    );
  }

  late final _update_viewport_and_camera_projectionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
              ffi.Float)>>('update_viewport_and_camera_projection');
  late final _update_viewport_and_camera_projection =
      _update_viewport_and_camera_projectionPtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, double)>();

  void scroll_begin(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _scroll_begin(
      viewer,
    );
  }

  late final _scroll_beginPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'scroll_begin');
  late final _scroll_begin =
      _scroll_beginPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void scroll_update(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
    double z,
  ) {
    return _scroll_update(
      viewer,
      x,
      y,
      z,
    );
  }

  late final _scroll_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float)>>('scroll_update');
  late final _scroll_update = _scroll_updatePtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, double, double, double)>();

  void scroll_end(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _scroll_end(
      viewer,
    );
  }

  late final _scroll_endPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'scroll_end');
  late final _scroll_end =
      _scroll_endPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void grab_begin(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
    bool pan,
  ) {
    return _grab_begin(
      viewer,
      x,
      y,
      pan,
    );
  }

  late final _grab_beginPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Bool)>>('grab_begin');
  late final _grab_begin = _grab_beginPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double, double, bool)>();

  void grab_update(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
  ) {
    return _grab_update(
      viewer,
      x,
      y,
    );
  }

  late final _grab_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float)>>('grab_update');
  late final _grab_update = _grab_updatePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double, double)>();

  void grab_end(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _grab_end(
      viewer,
    );
  }

  late final _grab_endPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'grab_end');
  late final _grab_end =
      _grab_endPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void apply_weights(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> weights,
    int count,
  ) {
    return _apply_weights(
      assetManager,
      asset,
      entityName,
      weights,
      count,
    );
  }

  late final _apply_weightsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Int)>>('apply_weights');
  late final _apply_weights = _apply_weightsPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Float>, int)>();

  void set_morph_target_weights(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> morphData,
    int numWeights,
  ) {
    return _set_morph_target_weights(
      assetManager,
      asset,
      entityName,
      morphData,
      numWeights,
    );
  }

  late final _set_morph_target_weightsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Int)>>('set_morph_target_weights');
  late final _set_morph_target_weights =
      _set_morph_target_weightsPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>, int)>();

  bool set_morph_animation(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> morphData,
    ffi.Pointer<ffi.Int> morphIndices,
    int numMorphTargets,
    int numFrames,
    double frameLengthInMs,
  ) {
    return _set_morph_animation(
      assetManager,
      asset,
      entityName,
      morphData,
      morphIndices,
      numMorphTargets,
      numFrames,
      frameLengthInMs,
    );
  }

  late final _set_morph_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Int>,
              ffi.Int,
              ffi.Int,
              ffi.Float)>>('set_morph_animation');
  late final _set_morph_animation = _set_morph_animationPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Int>, int, int, double)>();

  void set_bone_animation(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Float> frameData,
    int numFrames,
    int numBones,
    ffi.Pointer<ffi.Pointer<ffi.Char>> boneNames,
    ffi.Pointer<ffi.Pointer<ffi.Char>> meshName,
    int numMeshTargets,
    double frameLengthInMs,
  ) {
    return _set_bone_animation(
      assetManager,
      asset,
      frameData,
      numFrames,
      numBones,
      boneNames,
      meshName,
      numMeshTargets,
      frameLengthInMs,
    );
  }

  late final _set_bone_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Float>,
              ffi.Int,
              ffi.Int,
              ffi.Pointer<ffi.Pointer<ffi.Char>>,
              ffi.Pointer<ffi.Pointer<ffi.Char>>,
              ffi.Int,
              ffi.Float)>>('set_bone_animation');
  late final _set_bone_animation = _set_bone_animationPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>,
          int,
          ffi.Pointer<ffi.Float>,
          int,
          int,
          ffi.Pointer<ffi.Pointer<ffi.Char>>,
          ffi.Pointer<ffi.Pointer<ffi.Char>>,
          int,
          double)>();

  void play_animation(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int index,
    bool loop,
    bool reverse,
    bool replaceActive,
    double crossfade,
  ) {
    return _play_animation(
      assetManager,
      asset,
      index,
      loop,
      reverse,
      replaceActive,
      crossfade,
    );
  }

  late final _play_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Int, ffi.Bool,
              ffi.Bool, ffi.Bool, ffi.Float)>>('play_animation');
  late final _play_animation = _play_animationPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>, int, int, bool, bool, bool, double)>();

  void set_animation_frame(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int animationIndex,
    int animationFrame,
  ) {
    return _set_animation_frame(
      assetManager,
      asset,
      animationIndex,
      animationFrame,
    );
  }

  late final _set_animation_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Int,
              ffi.Int)>>('set_animation_frame');
  late final _set_animation_frame = _set_animation_framePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, int)>();

  void stop_animation(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int index,
  ) {
    return _stop_animation(
      assetManager,
      asset,
      index,
    );
  }

  late final _stop_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>, EntityId, ffi.Int)>>('stop_animation');
  late final _stop_animation = _stop_animationPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int)>();

  int get_animation_count(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
  ) {
    return _get_animation_count(
      assetManager,
      asset,
    );
  }

  late final _get_animation_countPtr = _lookup<
          ffi
          .NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'get_animation_count');
  late final _get_animation_count = _get_animation_countPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();

  void get_animation_name(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> outPtr,
    int index,
  ) {
    return _get_animation_name(
      assetManager,
      asset,
      outPtr,
      index,
    );
  }

  late final _get_animation_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>, ffi.Int)>>('get_animation_name');
  late final _get_animation_name = _get_animation_namePtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>, int)>();

  double get_animation_duration(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int index,
  ) {
    return _get_animation_duration(
      assetManager,
      asset,
      index,
    );
  }

  late final _get_animation_durationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Int)>>('get_animation_duration');
  late final _get_animation_duration = _get_animation_durationPtr
      .asFunction<double Function(ffi.Pointer<ffi.Void>, int, int)>();

  void get_morph_target_name(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
    ffi.Pointer<ffi.Char> outPtr,
    int index,
  ) {
    return _get_morph_target_name(
      assetManager,
      asset,
      meshName,
      outPtr,
      index,
    );
  }

  late final _get_morph_target_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int)>>('get_morph_target_name');
  late final _get_morph_target_name = _get_morph_target_namePtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Char>, int)>();

  int get_morph_target_name_count(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
  ) {
    return _get_morph_target_name_count(
      assetManager,
      asset,
      meshName,
    );
  }

  late final _get_morph_target_name_countPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('get_morph_target_name_count');
  late final _get_morph_target_name_count =
      _get_morph_target_name_countPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void remove_asset(
    ffi.Pointer<ffi.Void> viewer,
    int asset,
  ) {
    return _remove_asset(
      viewer,
      asset,
    );
  }

  late final _remove_assetPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'remove_asset');
  late final _remove_asset =
      _remove_assetPtr.asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void clear_assets(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_assets(
      viewer,
    );
  }

  late final _clear_assetsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_assets');
  late final _clear_assets =
      _clear_assetsPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  bool set_material_color(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
    int materialIndex,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _set_material_color(
      assetManager,
      asset,
      meshName,
      materialIndex,
      r,
      g,
      b,
      a,
    );
  }

  late final _set_material_colorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('set_material_color');
  late final _set_material_color = _set_material_colorPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>, int,
          double, double, double, double)>();

  void transform_to_unit_cube(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
  ) {
    return _transform_to_unit_cube(
      assetManager,
      asset,
    );
  }

  late final _transform_to_unit_cubePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'transform_to_unit_cube');
  late final _transform_to_unit_cube = _transform_to_unit_cubePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void set_position(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    double x,
    double y,
    double z,
  ) {
    return _set_position(
      assetManager,
      asset,
      x,
      y,
      z,
    );
  }

  late final _set_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Float,
              ffi.Float, ffi.Float)>>('set_position');
  late final _set_position = _set_positionPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, double, double, double)>();

  void set_rotation(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    double rads,
    double x,
    double y,
    double z,
  ) {
    return _set_rotation(
      assetManager,
      asset,
      rads,
      x,
      y,
      z,
    );
  }

  late final _set_rotationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float)>>('set_rotation');
  late final _set_rotation = _set_rotationPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>, int, double, double, double, double)>();

  void set_scale(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    double scale,
  ) {
    return _set_scale(
      assetManager,
      asset,
      scale,
    );
  }

  late final _set_scalePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>, EntityId, ffi.Float)>>('set_scale');
  late final _set_scale = _set_scalePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, double)>();

  void move_camera_to_asset(
    ffi.Pointer<ffi.Void> viewer,
    int asset,
  ) {
    return _move_camera_to_asset(
      viewer,
      asset,
    );
  }

  late final _move_camera_to_assetPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'move_camera_to_asset');
  late final _move_camera_to_asset = _move_camera_to_assetPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void set_camera_exposure(
    ffi.Pointer<ffi.Void> viewer,
    double aperture,
    double shutterSpeed,
    double sensitivity,
  ) {
    return _set_camera_exposure(
      viewer,
      aperture,
      shutterSpeed,
      sensitivity,
    );
  }

  late final _set_camera_exposurePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float)>>('set_camera_exposure');
  late final _set_camera_exposure = _set_camera_exposurePtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, double, double, double)>();

  void set_camera_position(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
    double z,
  ) {
    return _set_camera_position(
      viewer,
      x,
      y,
      z,
    );
  }

  late final _set_camera_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float)>>('set_camera_position');
  late final _set_camera_position = _set_camera_positionPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, double, double, double)>();

  void set_camera_rotation(
    ffi.Pointer<ffi.Void> viewer,
    double rads,
    double x,
    double y,
    double z,
  ) {
    return _set_camera_rotation(
      viewer,
      rads,
      x,
      y,
      z,
    );
  }

  late final _set_camera_rotationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float)>>('set_camera_rotation');
  late final _set_camera_rotation = _set_camera_rotationPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, double, double, double, double)>();

  void set_camera_model_matrix(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Float> matrix,
  ) {
    return _set_camera_model_matrix(
      viewer,
      matrix,
    );
  }

  late final _set_camera_model_matrixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Float>)>>('set_camera_model_matrix');
  late final _set_camera_model_matrix = _set_camera_model_matrixPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Float>)>();

  void set_camera_focal_length(
    ffi.Pointer<ffi.Void> viewer,
    double focalLength,
  ) {
    return _set_camera_focal_length(
      viewer,
      focalLength,
    );
  }

  late final _set_camera_focal_lengthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float)>>(
      'set_camera_focal_length');
  late final _set_camera_focal_length = _set_camera_focal_lengthPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double)>();

  void set_camera_focus_distance(
    ffi.Pointer<ffi.Void> viewer,
    double focusDistance,
  ) {
    return _set_camera_focus_distance(
      viewer,
      focusDistance,
    );
  }

  late final _set_camera_focus_distancePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float)>>(
      'set_camera_focus_distance');
  late final _set_camera_focus_distance = _set_camera_focus_distancePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double)>();

  int hide_mesh(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
  ) {
    return _hide_mesh(
      assetManager,
      asset,
      meshName,
    );
  }

  late final _hide_meshPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('hide_mesh');
  late final _hide_mesh = _hide_meshPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  int reveal_mesh(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
  ) {
    return _reveal_mesh(
      assetManager,
      asset,
      meshName,
    );
  }

  late final _reveal_meshPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('reveal_mesh');
  late final _reveal_mesh = _reveal_meshPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void set_post_processing(
    ffi.Pointer<ffi.Void> viewer,
    bool enabled,
  ) {
    return _set_post_processing(
      viewer,
      enabled,
    );
  }

  late final _set_post_processingPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'set_post_processing');
  late final _set_post_processing = _set_post_processingPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();

  void pick(
    ffi.Pointer<ffi.Void> viewer,
    int x,
    int y,
    ffi.Pointer<EntityId> entityId,
  ) {
    return _pick(
      viewer,
      x,
      y,
      entityId,
    );
  }

  late final _pickPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int, ffi.Int,
              ffi.Pointer<EntityId>)>>('pick');
  late final _pick = _pickPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<EntityId>)>();

  ffi.Pointer<ffi.Char> get_name_for_entity(
    ffi.Pointer<ffi.Void> assetManager,
    int entityId,
  ) {
    return _get_name_for_entity(
      assetManager,
      entityId,
    );
  }

  late final _get_name_for_entityPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, EntityId)>>('get_name_for_entity');
  late final _get_name_for_entity = _get_name_for_entityPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();

  void ios_dummy() {
    return _ios_dummy();
  }

  late final _ios_dummyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('ios_dummy');
  late final _ios_dummy = _ios_dummyPtr.asFunction<void Function()>();

  ffi.Pointer<ffi.Void> create_filament_viewer_ffi(
    ffi.Pointer<ffi.Void> context,
    ffi.Pointer<ffi.Void> platform,
    ffi.Pointer<ffi.Char> uberArchivePath,
    ffi.Pointer<ResourceLoaderWrapper> loader,
    ffi.Pointer<
            ffi.NativeFunction<
                ffi.Void Function(ffi.Pointer<ffi.Void> renderCallbackOwner)>>
        renderCallback,
    ffi.Pointer<ffi.Void> renderCallbackOwner,
  ) {
    return _create_filament_viewer_ffi(
      context,
      platform,
      uberArchivePath,
      loader,
      renderCallback,
      renderCallbackOwner,
    );
  }

  late final _create_filament_viewer_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ResourceLoaderWrapper>,
              ffi.Pointer<
                  ffi.NativeFunction<
                      ffi.Void Function(
                          ffi.Pointer<ffi.Void> renderCallbackOwner)>>,
              ffi.Pointer<ffi.Void>)>>('create_filament_viewer_ffi');
  late final _create_filament_viewer_ffi =
      _create_filament_viewer_ffiPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ResourceLoaderWrapper>,
              ffi.Pointer<
                  ffi.NativeFunction<
                      ffi.Void Function(
                          ffi.Pointer<ffi.Void> renderCallbackOwner)>>,
              ffi.Pointer<ffi.Void>)>();

  void create_swap_chain_ffi(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Void> surface,
    int width,
    int height,
  ) {
    return _create_swap_chain_ffi(
      viewer,
      surface,
      width,
      height,
    );
  }

  late final _create_swap_chain_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Uint32, ffi.Uint32)>>('create_swap_chain_ffi');
  late final _create_swap_chain_ffi = _create_swap_chain_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int, int)>();

  void destroy_swap_chain_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _destroy_swap_chain_ffi(
      viewer,
    );
  }

  late final _destroy_swap_chain_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'destroy_swap_chain_ffi');
  late final _destroy_swap_chain_ffi = _destroy_swap_chain_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void create_render_target_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int nativeTextureId,
    int width,
    int height,
  ) {
    return _create_render_target_ffi(
      viewer,
      nativeTextureId,
      width,
      height,
    );
  }

  late final _create_render_target_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.IntPtr, ffi.Uint32,
              ffi.Uint32)>>('create_render_target_ffi');
  late final _create_render_target_ffi = _create_render_target_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, int)>();

  void destroy_filament_viewer_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _destroy_filament_viewer_ffi(
      viewer,
    );
  }

  late final _destroy_filament_viewer_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'destroy_filament_viewer_ffi');
  late final _destroy_filament_viewer_ffi = _destroy_filament_viewer_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void render_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _render_ffi(
      viewer,
    );
  }

  late final _render_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'render_ffi');
  late final _render_ffi =
      _render_ffiPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  FilamentRenderCallback make_render_callback_fn_pointer(
    FilamentRenderCallback arg0,
  ) {
    return _make_render_callback_fn_pointer(
      arg0,
    );
  }

  late final _make_render_callback_fn_pointerPtr = _lookup<
      ffi.NativeFunction<
          FilamentRenderCallback Function(
              FilamentRenderCallback)>>('make_render_callback_fn_pointer');
  late final _make_render_callback_fn_pointer =
      _make_render_callback_fn_pointerPtr.asFunction<
          FilamentRenderCallback Function(FilamentRenderCallback)>();

  void set_rendering_ffi(
    ffi.Pointer<ffi.Void> viewer,
    bool rendering,
  ) {
    return _set_rendering_ffi(
      viewer,
      rendering,
    );
  }

  late final _set_rendering_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'set_rendering_ffi');
  late final _set_rendering_ffi = _set_rendering_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();

  void set_frame_interval_ffi(
    double frameInterval,
  ) {
    return _set_frame_interval_ffi(
      frameInterval,
    );
  }

  late final _set_frame_interval_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Float)>>(
          'set_frame_interval_ffi');
  late final _set_frame_interval_ffi =
      _set_frame_interval_ffiPtr.asFunction<void Function(double)>();

  void update_viewport_and_camera_projection_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int width,
    int height,
    double scaleFactor,
  ) {
    return _update_viewport_and_camera_projection_ffi(
      viewer,
      width,
      height,
      scaleFactor,
    );
  }

  late final _update_viewport_and_camera_projection_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
              ffi.Float)>>('update_viewport_and_camera_projection_ffi');
  late final _update_viewport_and_camera_projection_ffi =
      _update_viewport_and_camera_projection_ffiPtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, double)>();

  void set_background_color_ffi(
    ffi.Pointer<ffi.Void> viewer,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _set_background_color_ffi(
      viewer,
      r,
      g,
      b,
      a,
    );
  }

  late final _set_background_color_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float)>>('set_background_color_ffi');
  late final _set_background_color_ffi =
      _set_background_color_ffiPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.Void>, double, double, double, double)>();

  void clear_background_image_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_background_image_ffi(
      viewer,
    );
  }

  late final _clear_background_image_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_background_image_ffi');
  late final _clear_background_image_ffi = _clear_background_image_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void set_background_image_ffi(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> path,
    bool fillHeight,
  ) {
    return _set_background_image_ffi(
      viewer,
      path,
      fillHeight,
    );
  }

  late final _set_background_image_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('set_background_image_ffi');
  late final _set_background_image_ffi =
      _set_background_image_ffiPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  void set_background_image_position_ffi(
    ffi.Pointer<ffi.Void> viewer,
    double x,
    double y,
    bool clamp,
  ) {
    return _set_background_image_position_ffi(
      viewer,
      x,
      y,
      clamp,
    );
  }

  late final _set_background_image_position_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float, ffi.Float,
              ffi.Bool)>>('set_background_image_position_ffi');
  late final _set_background_image_position_ffi =
      _set_background_image_position_ffiPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, double, double, bool)>();

  void set_tone_mapping_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int toneMapping,
  ) {
    return _set_tone_mapping_ffi(
      viewer,
      toneMapping,
    );
  }

  late final _set_tone_mapping_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'set_tone_mapping_ffi');
  late final _set_tone_mapping_ffi = _set_tone_mapping_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void set_bloom_ffi(
    ffi.Pointer<ffi.Void> viewer,
    double strength,
  ) {
    return _set_bloom_ffi(
      viewer,
      strength,
    );
  }

  late final _set_bloom_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Float)>>(
      'set_bloom_ffi');
  late final _set_bloom_ffi = _set_bloom_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, double)>();

  void load_skybox_ffi(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> skyboxPath,
  ) {
    return _load_skybox_ffi(
      viewer,
      skyboxPath,
    );
  }

  late final _load_skybox_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('load_skybox_ffi');
  late final _load_skybox_ffi = _load_skybox_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  void load_ibl_ffi(
    ffi.Pointer<ffi.Void> viewer,
    ffi.Pointer<ffi.Char> iblPath,
    double intensity,
  ) {
    return _load_ibl_ffi(
      viewer,
      iblPath,
      intensity,
    );
  }

  late final _load_ibl_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Float)>>('load_ibl_ffi');
  late final _load_ibl_ffi = _load_ibl_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, double)>();

  void remove_skybox_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _remove_skybox_ffi(
      viewer,
    );
  }

  late final _remove_skybox_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'remove_skybox_ffi');
  late final _remove_skybox_ffi =
      _remove_skybox_ffiPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void remove_ibl_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _remove_ibl_ffi(
      viewer,
    );
  }

  late final _remove_ibl_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'remove_ibl_ffi');
  late final _remove_ibl_ffi =
      _remove_ibl_ffiPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  int add_light_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int type,
    double colour,
    double intensity,
    double posX,
    double posY,
    double posZ,
    double dirX,
    double dirY,
    double dirZ,
    bool shadows,
  ) {
    return _add_light_ffi(
      viewer,
      type,
      colour,
      intensity,
      posX,
      posY,
      posZ,
      dirX,
      dirY,
      dirZ,
      shadows,
    );
  }

  late final _add_light_ffiPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(
              ffi.Pointer<ffi.Void>,
              ffi.Uint8,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Bool)>>('add_light_ffi');
  late final _add_light_ffi = _add_light_ffiPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, int, double, double, double, double,
          double, double, double, double, bool)>();

  void remove_light_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int entityId,
  ) {
    return _remove_light_ffi(
      viewer,
      entityId,
    );
  }

  late final _remove_light_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'remove_light_ffi');
  late final _remove_light_ffi = _remove_light_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void clear_lights_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_lights_ffi(
      viewer,
    );
  }

  late final _clear_lights_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_lights_ffi');
  late final _clear_lights_ffi =
      _clear_lights_ffiPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  int load_glb_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    ffi.Pointer<ffi.Char> assetPath,
    bool unlit,
  ) {
    return _load_glb_ffi(
      assetManager,
      assetPath,
      unlit,
    );
  }

  late final _load_glb_ffiPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('load_glb_ffi');
  late final _load_glb_ffi = _load_glb_ffiPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  int load_gltf_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    ffi.Pointer<ffi.Char> assetPath,
    ffi.Pointer<ffi.Char> relativePath,
  ) {
    return _load_gltf_ffi(
      assetManager,
      assetPath,
      relativePath,
    );
  }

  late final _load_gltf_ffiPtr = _lookup<
      ffi.NativeFunction<
          EntityId Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('load_gltf_ffi');
  late final _load_gltf_ffi = _load_gltf_ffiPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Char>)>();

  void remove_asset_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int asset,
  ) {
    return _remove_asset_ffi(
      viewer,
      asset,
    );
  }

  late final _remove_asset_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'remove_asset_ffi');
  late final _remove_asset_ffi = _remove_asset_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void clear_assets_ffi(
    ffi.Pointer<ffi.Void> viewer,
  ) {
    return _clear_assets_ffi(
      viewer,
    );
  }

  late final _clear_assets_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'clear_assets_ffi');
  late final _clear_assets_ffi =
      _clear_assets_ffiPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  bool set_camera_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int asset,
    ffi.Pointer<ffi.Char> nodeName,
  ) {
    return _set_camera_ffi(
      viewer,
      asset,
      nodeName,
    );
  }

  late final _set_camera_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('set_camera_ffi');
  late final _set_camera_ffi = _set_camera_ffiPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void apply_weights_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> weights,
    int count,
  ) {
    return _apply_weights_ffi(
      assetManager,
      asset,
      entityName,
      weights,
      count,
    );
  }

  late final _apply_weights_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Int)>>('apply_weights_ffi');
  late final _apply_weights_ffi = _apply_weights_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Float>, int)>();

  void set_morph_target_weights_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> morphData,
    int numWeights,
  ) {
    return _set_morph_target_weights_ffi(
      assetManager,
      asset,
      entityName,
      morphData,
      numWeights,
    );
  }

  late final _set_morph_target_weights_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Int)>>('set_morph_target_weights_ffi');
  late final _set_morph_target_weights_ffi =
      _set_morph_target_weights_ffiPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>, int)>();

  bool set_morph_animation_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> entityName,
    ffi.Pointer<ffi.Float> morphData,
    ffi.Pointer<ffi.Int> morphIndices,
    int numMorphTargets,
    int numFrames,
    double frameLengthInMs,
  ) {
    return _set_morph_animation_ffi(
      assetManager,
      asset,
      entityName,
      morphData,
      morphIndices,
      numMorphTargets,
      numFrames,
      frameLengthInMs,
    );
  }

  late final _set_morph_animation_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Int>,
              ffi.Int,
              ffi.Int,
              ffi.Float)>>('set_morph_animation_ffi');
  late final _set_morph_animation_ffi = _set_morph_animation_ffiPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Int>, int, int, double)>();

  void set_bone_animation_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Float> frameData,
    int numFrames,
    int numBones,
    ffi.Pointer<ffi.Pointer<ffi.Char>> boneNames,
    ffi.Pointer<ffi.Pointer<ffi.Char>> meshName,
    int numMeshTargets,
    double frameLengthInMs,
  ) {
    return _set_bone_animation_ffi(
      assetManager,
      asset,
      frameData,
      numFrames,
      numBones,
      boneNames,
      meshName,
      numMeshTargets,
      frameLengthInMs,
    );
  }

  late final _set_bone_animation_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Float>,
              ffi.Int,
              ffi.Int,
              ffi.Pointer<ffi.Pointer<ffi.Char>>,
              ffi.Pointer<ffi.Pointer<ffi.Char>>,
              ffi.Int,
              ffi.Float)>>('set_bone_animation_ffi');
  late final _set_bone_animation_ffi = _set_bone_animation_ffiPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>,
          int,
          ffi.Pointer<ffi.Float>,
          int,
          int,
          ffi.Pointer<ffi.Pointer<ffi.Char>>,
          ffi.Pointer<ffi.Pointer<ffi.Char>>,
          int,
          double)>();

  void play_animation_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int index,
    bool loop,
    bool reverse,
    bool replaceActive,
    double crossfade,
  ) {
    return _play_animation_ffi(
      assetManager,
      asset,
      index,
      loop,
      reverse,
      replaceActive,
      crossfade,
    );
  }

  late final _play_animation_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Int, ffi.Bool,
              ffi.Bool, ffi.Bool, ffi.Float)>>('play_animation_ffi');
  late final _play_animation_ffi = _play_animation_ffiPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.Void>, int, int, bool, bool, bool, double)>();

  void set_animation_frame_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int animationIndex,
    int animationFrame,
  ) {
    return _set_animation_frame_ffi(
      assetManager,
      asset,
      animationIndex,
      animationFrame,
    );
  }

  late final _set_animation_frame_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId, ffi.Int,
              ffi.Int)>>('set_animation_frame_ffi');
  late final _set_animation_frame_ffi = _set_animation_frame_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int, int)>();

  void stop_animation_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    int index,
  ) {
    return _stop_animation_ffi(
      assetManager,
      asset,
      index,
    );
  }

  late final _stop_animation_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>, EntityId, ffi.Int)>>('stop_animation_ffi');
  late final _stop_animation_ffi = _stop_animation_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int, int)>();

  int get_animation_count_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
  ) {
    return _get_animation_count_ffi(
      assetManager,
      asset,
    );
  }

  late final _get_animation_count_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId)>>(
      'get_animation_count_ffi');
  late final _get_animation_count_ffi = _get_animation_count_ffiPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();

  void get_animation_name_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> outPtr,
    int index,
  ) {
    return _get_animation_name_ffi(
      assetManager,
      asset,
      outPtr,
      index,
    );
  }

  late final _get_animation_name_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>, ffi.Int)>>('get_animation_name_ffi');
  late final _get_animation_name_ffi = _get_animation_name_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>, int)>();

  void get_morph_target_name_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
    ffi.Pointer<ffi.Char> outPtr,
    int index,
  ) {
    return _get_morph_target_name_ffi(
      assetManager,
      asset,
      meshName,
      outPtr,
      index,
    );
  }

  late final _get_morph_target_name_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              EntityId,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int)>>('get_morph_target_name_ffi');
  late final _get_morph_target_name_ffi =
      _get_morph_target_name_ffiPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, int)>();

  int get_morph_target_name_count_ffi(
    ffi.Pointer<ffi.Void> assetManager,
    int asset,
    ffi.Pointer<ffi.Char> meshName,
  ) {
    return _get_morph_target_name_count_ffi(
      assetManager,
      asset,
      meshName,
    );
  }

  late final _get_morph_target_name_count_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, EntityId,
              ffi.Pointer<ffi.Char>)>>('get_morph_target_name_count_ffi');
  late final _get_morph_target_name_count_ffi =
      _get_morph_target_name_count_ffiPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void set_post_processing_ffi(
    ffi.Pointer<ffi.Void> viewer,
    bool enabled,
  ) {
    return _set_post_processing_ffi(
      viewer,
      enabled,
    );
  }

  late final _set_post_processing_ffiPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'set_post_processing_ffi');
  late final _set_post_processing_ffi = _set_post_processing_ffiPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();

  void pick_ffi(
    ffi.Pointer<ffi.Void> viewer,
    int x,
    int y,
    ffi.Pointer<EntityId> entityId,
  ) {
    return _pick_ffi(
      viewer,
      x,
      y,
      entityId,
    );
  }

  late final _pick_ffiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int, ffi.Int,
              ffi.Pointer<EntityId>)>>('pick_ffi');
  late final _pick_ffi = _pick_ffiPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<EntityId>)>();

  void ios_dummy_ffi() {
    return _ios_dummy_ffi();
  }

  late final _ios_dummy_ffiPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('ios_dummy_ffi');
  late final _ios_dummy_ffi = _ios_dummy_ffiPtr.asFunction<void Function()>();
}

final class __mbstate_t extends ffi.Union {
  @ffi.Array.multi([128])
  external ffi.Array<ffi.Char> __mbstate8;

  @ffi.LongLong()
  external int _mbstateL;
}

final class __darwin_pthread_handler_rec extends ffi.Struct {
  external ffi
      .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>
      __routine;

  external ffi.Pointer<ffi.Void> __arg;

  external ffi.Pointer<__darwin_pthread_handler_rec> __next;
}

final class _opaque_pthread_attr_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([56])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_cond_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([40])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_condattr_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_mutex_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([56])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_mutexattr_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_once_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_rwlock_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([192])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_rwlockattr_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  @ffi.Array.multi([16])
  external ffi.Array<ffi.Char> __opaque;
}

final class _opaque_pthread_t extends ffi.Struct {
  @ffi.Long()
  external int __sig;

  external ffi.Pointer<__darwin_pthread_handler_rec> __cleanup_stack;

  @ffi.Array.multi([8176])
  external ffi.Array<ffi.Char> __opaque;
}

final class ResourceBuffer extends ffi.Struct {
  external ffi.Pointer<ffi.Void> data;

  @ffi.Int32()
  external int size;

  @ffi.Int32()
  external int id;
}

final class ResourceLoaderWrapper extends ffi.Struct {
  external LoadFilamentResource mLoadFilamentResource;

  external FreeFilamentResource mFreeFilamentResource;

  external LoadFilamentResourceFromOwner mLoadFilamentResourceFromOwner;

  external FreeFilamentResourceFromOwner mFreeFilamentResourceFromOwner;

  external ffi.Pointer<ffi.Void> mOwner;
}

typedef LoadFilamentResource = ffi.Pointer<
    ffi.NativeFunction<ResourceBuffer Function(ffi.Pointer<ffi.Char> uri)>>;
typedef FreeFilamentResource
    = ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ResourceBuffer)>>;
typedef LoadFilamentResourceFromOwner = ffi.Pointer<
    ffi.NativeFunction<
        ResourceBuffer Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Void>)>>;
typedef FreeFilamentResourceFromOwner = ffi.Pointer<
    ffi
    .NativeFunction<ffi.Void Function(ResourceBuffer, ffi.Pointer<ffi.Void>)>>;

/// This header replicates most of the methods in FlutterFilamentApi.h, and is only intended to be used to generate client FFI bindings.
/// The intention is that calling one of these methods will call its respective method in FlutterFilamentApi.h, but wrapped in some kind of thread runner to ensure thread safety.
typedef EntityId = ffi.Int32;
typedef FilamentRenderCallback = ffi.Pointer<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void> owner)>>;

const int __bool_true_false_are_defined = 1;

const int true1 = 1;

const int false1 = 0;

const int __DARWIN_ONLY_64_BIT_INO_T = 1;

const int __DARWIN_ONLY_UNIX_CONFORMANCE = 1;

const int __DARWIN_ONLY_VERS_1050 = 1;

const int __DARWIN_UNIX03 = 1;

const int __DARWIN_64_BIT_INO_T = 1;

const int __DARWIN_VERS_1050 = 1;

const int __DARWIN_NON_CANCELABLE = 0;

const String __DARWIN_SUF_EXTSN = '\$DARWIN_EXTSN';

const int __DARWIN_C_ANSI = 4096;

const int __DARWIN_C_FULL = 900000;

const int __DARWIN_C_LEVEL = 900000;

const int __STDC_WANT_LIB_EXT1__ = 1;

const int __DARWIN_NO_LONG_LONG = 0;

const int _DARWIN_FEATURE_64_BIT_INODE = 1;

const int _DARWIN_FEATURE_ONLY_64_BIT_INODE = 1;

const int _DARWIN_FEATURE_ONLY_VERS_1050 = 1;

const int _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE = 1;

const int _DARWIN_FEATURE_UNIX_CONFORMANCE = 3;

const int __has_ptrcheck = 0;

const int __DARWIN_NULL = 0;

const int __PTHREAD_SIZE__ = 8176;

const int __PTHREAD_ATTR_SIZE__ = 56;

const int __PTHREAD_MUTEXATTR_SIZE__ = 8;

const int __PTHREAD_MUTEX_SIZE__ = 56;

const int __PTHREAD_CONDATTR_SIZE__ = 8;

const int __PTHREAD_COND_SIZE__ = 40;

const int __PTHREAD_ONCE_SIZE__ = 8;

const int __PTHREAD_RWLOCK_SIZE__ = 192;

const int __PTHREAD_RWLOCKATTR_SIZE__ = 16;

const int __DARWIN_WCHAR_MAX = 2147483647;

const int __DARWIN_WCHAR_MIN = -2147483648;

const int __DARWIN_WEOF = -1;

const int _FORTIFY_SOURCE = 2;

const int NULL = 0;

const int USER_ADDR_NULL = 0;

const int __WORDSIZE = 64;

const int INT8_MAX = 127;

const int INT16_MAX = 32767;

const int INT32_MAX = 2147483647;

const int INT64_MAX = 9223372036854775807;

const int INT8_MIN = -128;

const int INT16_MIN = -32768;

const int INT32_MIN = -2147483648;

const int INT64_MIN = -9223372036854775808;

const int UINT8_MAX = 255;

const int UINT16_MAX = 65535;

const int UINT32_MAX = 4294967295;

const int UINT64_MAX = -1;

const int INT_LEAST8_MIN = -128;

const int INT_LEAST16_MIN = -32768;

const int INT_LEAST32_MIN = -2147483648;

const int INT_LEAST64_MIN = -9223372036854775808;

const int INT_LEAST8_MAX = 127;

const int INT_LEAST16_MAX = 32767;

const int INT_LEAST32_MAX = 2147483647;

const int INT_LEAST64_MAX = 9223372036854775807;

const int UINT_LEAST8_MAX = 255;

const int UINT_LEAST16_MAX = 65535;

const int UINT_LEAST32_MAX = 4294967295;

const int UINT_LEAST64_MAX = -1;

const int INT_FAST8_MIN = -128;

const int INT_FAST16_MIN = -32768;

const int INT_FAST32_MIN = -2147483648;

const int INT_FAST64_MIN = -9223372036854775808;

const int INT_FAST8_MAX = 127;

const int INT_FAST16_MAX = 32767;

const int INT_FAST32_MAX = 2147483647;

const int INT_FAST64_MAX = 9223372036854775807;

const int UINT_FAST8_MAX = 255;

const int UINT_FAST16_MAX = 65535;

const int UINT_FAST32_MAX = 4294967295;

const int UINT_FAST64_MAX = -1;

const int INTPTR_MAX = 9223372036854775807;

const int INTPTR_MIN = -9223372036854775808;

const int UINTPTR_MAX = -1;

const int INTMAX_MAX = 9223372036854775807;

const int UINTMAX_MAX = -1;

const int INTMAX_MIN = -9223372036854775808;

const int PTRDIFF_MIN = -9223372036854775808;

const int PTRDIFF_MAX = 9223372036854775807;

const int SIZE_MAX = -1;

const int RSIZE_MAX = 9223372036854775807;

const int WCHAR_MAX = 2147483647;

const int WCHAR_MIN = -2147483648;

const int WINT_MIN = -2147483648;

const int WINT_MAX = 2147483647;

const int SIG_ATOMIC_MIN = -2147483648;

const int SIG_ATOMIC_MAX = 2147483647;