// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = no_optional_structs
// fidl_experiment = simple_empty_response_syntax
// fidl_experiment = unknown_interactions

#![allow(
    unused_parens, // one-element-tuple-case is not a tuple
    unused_mut, // not all args require mutation, but many do
    nonstandard_style, // auto-caps does its best, but is not always successful
)]
#![recursion_limit = "512"]

#[cfg(target_os = "fuchsia")]
#[allow(unused_imports)]
use fuchsia_zircon as zx;

#[allow(unused_imports)]
use {
    bitflags::bitflags,
    fidl::{
        client::QueryResponseFut,
        encoding::zerocopy,
        endpoints::{ControlHandle as _, Responder as _},
        fidl_bits, fidl_enum, fidl_struct, fidl_table, fidl_union,
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

const _FIDL_TRACE_BINDINGS_RUST: u32 = 6;

/// Maximum length for a resource label.
pub const LABEL_MAX_LENGTH: u32 = 32;

/// Reports metrics information.
/// This event type is only reported for node resources.
pub const METRICS_EVENT_MASK: u32 = 1;

pub const SIZE_CHANGE_HINT_EVENT_MASK: u32 = 2;

/// Describes how nodes interact with hit testings.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum HitTestBehavior {
    /// Apply hit testing to the node's content, its parts, and its children.
    KDefault = 0,
    /// Suppress hit testing of the node and everything it contains.
    KSuppress = 1,
}

impl HitTestBehavior {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::KDefault),
            1 => Some(Self::KSuppress),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: HitTestBehavior,
    prim_ty: u32,
    strict: true,
    min_member: KDefault,
}

/// Describes an exported resource that is to be imported by an
/// ImportResourceCmd.
///
/// NOTE: Currently just an enum of importable resource types, but may later be
/// expanded to express concepts like "meshes with a particular vertex format".
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ImportSpec {
    Node = 0,
}

impl ImportSpec {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Node),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: ImportSpec,
    prim_ty: u32,
    strict: true,
    min_member: Node,
}

/// Set a mesh's indices and vertices.
///
/// `mesh_id` refs the Mesh to be updated.
/// `index_buffer_id` refs a Buffer that contains the mesh indices.
/// `index_format` defines how the index buffer data is to be interpreted.
/// `index_offset` number of bytes from the start of the index Buffer.
/// `index_count` number of indices.
/// `vertex_buffer_id` refs a Buffer that contains the mesh vertices.
/// `vertex_format` defines how the vertex buffer data is to be interpreted.
/// `vertex_offset` number of bytes from the start of the vertex Buffer.
/// `vertex_count` number of vertices.
/// `bounding_box` must contain all vertices within the specified range.
///
/// The MeshVertexFormat defines which per-vertex attributes are provided by the
/// mesh, and the size of each attribute (and therefore the size of each vertex).
/// The attributes are ordered within the vertex in the same order that they
/// appear within the MeshVertexFormat struct.  For example, if the values are
/// kVector3, kNone and kVector2, then:
///   - each vertex has a position and UV-coordinates, but no surface normal.
///   - the 3D position occupies bytes 0-11 (3 dimensions * 4 bytes per float32).
///   - the UV coords occupy bytes 12-19, since no surface normal is provided.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum MeshIndexFormat {
    KUint16 = 1,
    KUint32 = 2,
}

impl MeshIndexFormat {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::KUint16),
            2 => Some(Self::KUint32),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: MeshIndexFormat,
    prim_ty: u32,
    strict: true,
    min_member: KUint16,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum RenderFrequency {
    WhenRequested = 0,
    Continuously = 1,
}

impl RenderFrequency {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::WhenRequested),
            1 => Some(Self::Continuously),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: RenderFrequency,
    prim_ty: u32,
    strict: true,
    min_member: WhenRequested,
}

/// Represents the shadow algorithm that the `Renderer` should use when lighting
/// the scene.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ShadowTechnique {
    /// No shadows.
    Unshadowed = 0,
    /// Default.  Screen-space, depth-buffer based shadows; SSDO-ish.
    ScreenSpace = 1,
    /// Basic shadow map.
    ShadowMap = 2,
    /// Moment shadow map (see http:///momentsingraphics.de).
    MomentShadowMap = 3,
    /// Stencil shadow volume.
    StencilShadowVolume = 4,
}

impl ShadowTechnique {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Unshadowed),
            1 => Some(Self::ScreenSpace),
            2 => Some(Self::ShadowMap),
            3 => Some(Self::MomentShadowMap),
            4 => Some(Self::StencilShadowVolume),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: ShadowTechnique,
    prim_ty: u32,
    strict: true,
    min_member: Unshadowed,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ValueType {
    KNone = 0,
    KVector1 = 1,
    KVector2 = 2,
    KVector3 = 3,
    KVector4 = 4,
    KMatrix4 = 5,
    KColorRgb = 6,
    KColorRgba = 7,
    KQuaternion = 8,
    KFactoredTransform = 9,
}

impl ValueType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::KNone),
            1 => Some(Self::KVector1),
            2 => Some(Self::KVector2),
            3 => Some(Self::KVector3),
            4 => Some(Self::KVector4),
            5 => Some(Self::KMatrix4),
            6 => Some(Self::KColorRgb),
            7 => Some(Self::KColorRgba),
            8 => Some(Self::KQuaternion),
            9 => Some(Self::KFactoredTransform),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

fidl_enum! {
    name: ValueType,
    prim_ty: u32,
    strict: true,
    min_member: KNone,
}

/// Commands that are used to modify the state of a `Session`.
#[derive(Debug, PartialEq)]
pub enum Command {
    CreateResource(CreateResourceCmd),
    ReleaseResource(ReleaseResourceCmd),
    ExportResource(ExportResourceCmdDeprecated),
    ImportResource(ImportResourceCmdDeprecated),
    /// Tagging commands.
    SetTag(SetTagCmd),
    /// Grouping commands.
    Detach(DetachCmd),
    /// Spatial commands.
    SetTranslation(SetTranslationCmd),
    SetScale(SetScaleCmd),
    SetRotation(SetRotationCmd),
    SetAnchor(SetAnchorCmd),
    SetSize(SetSizeCmd),
    SetOpacity(SetOpacityCmd),
    SendSizeChangeHintHack(SendSizeChangeHintCmdHack),
    /// Node-specific commands.
    AddChild(AddChildCmd),
    /// re-parenting?
    AddPart(AddPartCmd),
    DetachChildren(DetachChildrenCmd),
    SetShape(SetShapeCmd),
    SetMaterial(SetMaterialCmd),
    SetClip(SetClipCmd),
    SetHitTestBehavior(SetHitTestBehaviorCmd),
    SetViewProperties(SetViewPropertiesCmd),
    TakeSnapshotCmd(TakeSnapshotCmdDeprecated),
    /// Camera and lighting commands.
    SetCamera(SetCameraCmd),
    SetCameraTransform(SetCameraTransformCmd),
    SetCameraProjection(SetCameraProjectionCmd),
    SetStereoCameraProjection(SetStereoCameraProjectionCmd),
    SetCameraPoseBuffer(SetCameraPoseBufferCmd),
    SetLightColor(SetLightColorCmd),
    SetLightDirection(SetLightDirectionCmd),
    AddLight(AddLightCmd),
    DetachLight(DetachLightCmd),
    DetachLights(DetachLightsCmd),
    SetTexture(SetTextureCmd),
    SetColor(SetColorCmd),
    /// Mesh commands.
    BindMeshBuffers(BindMeshBuffersCmd),
    /// Layer and renderer commands.
    AddLayer(AddLayerCmd),
    RemoveLayer(RemoveLayerCmd),
    RemoveAllLayers(RemoveAllLayersCmd),
    SetLayerStack(SetLayerStackCmd),
    SetRenderer(SetRendererCmd),
    SetRendererParam(SetRendererParamCmd),
    /// Events.
    SetEventMask(SetEventMaskCmd),
    /// Diagnostic commands.
    SetLabel(SetLabelCmd),
    /// Debugging commands.
    SetDisableClipping(SetDisableClippingCmd),
    SetImportFocus(SetImportFocusCmdDeprecated),
    SetClipPlanes(SetClipPlanesCmd),
    SetPointLightPosition(SetPointLightPositionCmd),
    SetPointLightFalloff(SetPointLightFalloffCmd),
    Scene_AddAmbientLight(SceneAddAmbientLightCmd),
    Scene_AddDirectionalLight(SceneAddDirectionalLightCmd),
    Scene_AddPointLight(SceneAddPointLightCmd),
    SetDisplayColorConversion(SetDisplayColorConversionCmdHack),
    SetDisplayRotation(SetDisplayRotationCmdHack),
    SetEnableViewDebugBounds(SetEnableDebugViewBoundsCmd),
    SetViewHolderBoundsColor(SetViewHolderBoundsColorCmd),
    SetCameraClipSpaceTransform(SetCameraClipSpaceTransformCmd),
    SetDisplayMinimumRgb(SetDisplayMinimumRgbCmdHack),
    SetSemanticVisibility(SetSemanticVisibilityCmd),
}

impl Command {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::CreateResource(_) => 1,
            Self::ReleaseResource(_) => 2,
            Self::ExportResource(_) => 3,
            Self::ImportResource(_) => 4,
            Self::SetTag(_) => 5,
            Self::Detach(_) => 6,
            Self::SetTranslation(_) => 7,
            Self::SetScale(_) => 8,
            Self::SetRotation(_) => 9,
            Self::SetAnchor(_) => 10,
            Self::SetSize(_) => 11,
            Self::SetOpacity(_) => 12,
            Self::SendSizeChangeHintHack(_) => 13,
            Self::AddChild(_) => 14,
            Self::AddPart(_) => 15,
            Self::DetachChildren(_) => 16,
            Self::SetShape(_) => 17,
            Self::SetMaterial(_) => 18,
            Self::SetClip(_) => 19,
            Self::SetHitTestBehavior(_) => 20,
            Self::SetViewProperties(_) => 21,
            Self::TakeSnapshotCmd(_) => 22,
            Self::SetCamera(_) => 23,
            Self::SetCameraTransform(_) => 24,
            Self::SetCameraProjection(_) => 25,
            Self::SetStereoCameraProjection(_) => 26,
            Self::SetCameraPoseBuffer(_) => 27,
            Self::SetLightColor(_) => 28,
            Self::SetLightDirection(_) => 29,
            Self::AddLight(_) => 30,
            Self::DetachLight(_) => 31,
            Self::DetachLights(_) => 32,
            Self::SetTexture(_) => 33,
            Self::SetColor(_) => 34,
            Self::BindMeshBuffers(_) => 35,
            Self::AddLayer(_) => 36,
            Self::RemoveLayer(_) => 37,
            Self::RemoveAllLayers(_) => 38,
            Self::SetLayerStack(_) => 39,
            Self::SetRenderer(_) => 40,
            Self::SetRendererParam(_) => 41,
            Self::SetEventMask(_) => 42,
            Self::SetLabel(_) => 43,
            Self::SetDisableClipping(_) => 44,
            Self::SetImportFocus(_) => 45,
            Self::SetClipPlanes(_) => 46,
            Self::SetPointLightPosition(_) => 47,
            Self::SetPointLightFalloff(_) => 48,
            Self::Scene_AddAmbientLight(_) => 49,
            Self::Scene_AddDirectionalLight(_) => 50,
            Self::Scene_AddPointLight(_) => 51,
            Self::SetDisplayColorConversion(_) => 52,
            Self::SetDisplayRotation(_) => 53,
            Self::SetEnableViewDebugBounds(_) => 54,
            Self::SetViewHolderBoundsColor(_) => 55,
            Self::SetCameraClipSpaceTransform(_) => 56,
            Self::SetDisplayMinimumRgb(_) => 57,
            Self::SetSemanticVisibility(_) => 58,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for Command {}

fidl_union! {
    name: Command,
    resource: true,
    members: [
        CreateResource {
            ty: CreateResourceCmd,
            resource: true,
            ordinal: 1,
        },
        ReleaseResource {
            ty: ReleaseResourceCmd,
            ordinal: 2,
        },
        ExportResource {
            ty: ExportResourceCmdDeprecated,
            resource: true,
            ordinal: 3,
        },
        ImportResource {
            ty: ImportResourceCmdDeprecated,
            resource: true,
            ordinal: 4,
        },
        SetTag {
            ty: SetTagCmd,
            ordinal: 5,
        },
        Detach {
            ty: DetachCmd,
            ordinal: 6,
        },
        SetTranslation {
            ty: SetTranslationCmd,
            ordinal: 7,
        },
        SetScale {
            ty: SetScaleCmd,
            ordinal: 8,
        },
        SetRotation {
            ty: SetRotationCmd,
            ordinal: 9,
        },
        SetAnchor {
            ty: SetAnchorCmd,
            ordinal: 10,
        },
        SetSize {
            ty: SetSizeCmd,
            ordinal: 11,
        },
        SetOpacity {
            ty: SetOpacityCmd,
            ordinal: 12,
        },
        SendSizeChangeHintHack {
            ty: SendSizeChangeHintCmdHack,
            ordinal: 13,
        },
        AddChild {
            ty: AddChildCmd,
            ordinal: 14,
        },
        AddPart {
            ty: AddPartCmd,
            ordinal: 15,
        },
        DetachChildren {
            ty: DetachChildrenCmd,
            ordinal: 16,
        },
        SetShape {
            ty: SetShapeCmd,
            ordinal: 17,
        },
        SetMaterial {
            ty: SetMaterialCmd,
            ordinal: 18,
        },
        SetClip {
            ty: SetClipCmd,
            ordinal: 19,
        },
        SetHitTestBehavior {
            ty: SetHitTestBehaviorCmd,
            ordinal: 20,
        },
        SetViewProperties {
            ty: SetViewPropertiesCmd,
            ordinal: 21,
        },
        TakeSnapshotCmd {
            ty: TakeSnapshotCmdDeprecated,
            resource: true,
            ordinal: 22,
        },
        SetCamera {
            ty: SetCameraCmd,
            ordinal: 23,
        },
        SetCameraTransform {
            ty: SetCameraTransformCmd,
            ordinal: 24,
        },
        SetCameraProjection {
            ty: SetCameraProjectionCmd,
            ordinal: 25,
        },
        SetStereoCameraProjection {
            ty: SetStereoCameraProjectionCmd,
            ordinal: 26,
        },
        SetCameraPoseBuffer {
            ty: SetCameraPoseBufferCmd,
            ordinal: 27,
        },
        SetLightColor {
            ty: SetLightColorCmd,
            ordinal: 28,
        },
        SetLightDirection {
            ty: SetLightDirectionCmd,
            ordinal: 29,
        },
        AddLight {
            ty: AddLightCmd,
            ordinal: 30,
        },
        DetachLight {
            ty: DetachLightCmd,
            ordinal: 31,
        },
        DetachLights {
            ty: DetachLightsCmd,
            ordinal: 32,
        },
        SetTexture {
            ty: SetTextureCmd,
            ordinal: 33,
        },
        SetColor {
            ty: SetColorCmd,
            ordinal: 34,
        },
        BindMeshBuffers {
            ty: BindMeshBuffersCmd,
            ordinal: 35,
        },
        AddLayer {
            ty: AddLayerCmd,
            ordinal: 36,
        },
        RemoveLayer {
            ty: RemoveLayerCmd,
            ordinal: 37,
        },
        RemoveAllLayers {
            ty: RemoveAllLayersCmd,
            ordinal: 38,
        },
        SetLayerStack {
            ty: SetLayerStackCmd,
            ordinal: 39,
        },
        SetRenderer {
            ty: SetRendererCmd,
            ordinal: 40,
        },
        SetRendererParam {
            ty: SetRendererParamCmd,
            ordinal: 41,
        },
        SetEventMask {
            ty: SetEventMaskCmd,
            ordinal: 42,
        },
        SetLabel {
            ty: SetLabelCmd,
            ordinal: 43,
        },
        SetDisableClipping {
            ty: SetDisableClippingCmd,
            ordinal: 44,
        },
        SetImportFocus {
            ty: SetImportFocusCmdDeprecated,
            ordinal: 45,
        },
        SetClipPlanes {
            ty: SetClipPlanesCmd,
            ordinal: 46,
        },
        SetPointLightPosition {
            ty: SetPointLightPositionCmd,
            ordinal: 47,
        },
        SetPointLightFalloff {
            ty: SetPointLightFalloffCmd,
            ordinal: 48,
        },
        Scene_AddAmbientLight {
            ty: SceneAddAmbientLightCmd,
            ordinal: 49,
        },
        Scene_AddDirectionalLight {
            ty: SceneAddDirectionalLightCmd,
            ordinal: 50,
        },
        Scene_AddPointLight {
            ty: SceneAddPointLightCmd,
            ordinal: 51,
        },
        SetDisplayColorConversion {
            ty: SetDisplayColorConversionCmdHack,
            ordinal: 52,
        },
        SetDisplayRotation {
            ty: SetDisplayRotationCmdHack,
            ordinal: 53,
        },
        SetEnableViewDebugBounds {
            ty: SetEnableDebugViewBoundsCmd,
            ordinal: 54,
        },
        SetViewHolderBoundsColor {
            ty: SetViewHolderBoundsColorCmd,
            ordinal: 55,
        },
        SetCameraClipSpaceTransform {
            ty: SetCameraClipSpaceTransformCmd,
            ordinal: 56,
        },
        SetDisplayMinimumRgb {
            ty: SetDisplayMinimumRgbCmdHack,
            ordinal: 57,
        },
        SetSemanticVisibility {
            ty: SetSemanticVisibilityCmd,
            ordinal: 58,
        },
    ],
}

/// These are all of the types of events which can be reported by a `Session`.
/// Use `SetEventMaskCmd` to enable event delivery for a resource.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub enum Event {
    /// Events which are controlled by a mask.
    Metrics(MetricsEvent),
    SizeChangeHint(SizeChangeHintEvent),
    /// Events which are always delivered, regardless of mask.
    ImportUnbound(ImportUnboundEvent),
    ViewConnected(ViewConnectedEvent),
    ViewDisconnected(ViewDisconnectedEvent),
    ViewHolderDisconnected(ViewHolderDisconnectedEvent),
    ViewAttachedToScene(ViewAttachedToSceneEvent),
    ViewDetachedFromScene(ViewDetachedFromSceneEvent),
    ViewPropertiesChanged(ViewPropertiesChangedEvent),
    ViewStateChanged(ViewStateChangedEvent),
    ViewHolderConnected(ViewHolderConnectedEvent),
}

impl Event {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Metrics(_) => 1,
            Self::SizeChangeHint(_) => 2,
            Self::ImportUnbound(_) => 3,
            Self::ViewConnected(_) => 4,
            Self::ViewDisconnected(_) => 5,
            Self::ViewHolderDisconnected(_) => 6,
            Self::ViewAttachedToScene(_) => 7,
            Self::ViewDetachedFromScene(_) => 8,
            Self::ViewPropertiesChanged(_) => 9,
            Self::ViewStateChanged(_) => 10,
            Self::ViewHolderConnected(_) => 11,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for Event {}

fidl_union! {
    name: Event,
    members: [
        Metrics {
            ty: MetricsEvent,
            ordinal: 1,
        },
        SizeChangeHint {
            ty: SizeChangeHintEvent,
            ordinal: 2,
        },
        ImportUnbound {
            ty: ImportUnboundEvent,
            ordinal: 3,
        },
        ViewConnected {
            ty: ViewConnectedEvent,
            ordinal: 4,
        },
        ViewDisconnected {
            ty: ViewDisconnectedEvent,
            ordinal: 5,
        },
        ViewHolderDisconnected {
            ty: ViewHolderDisconnectedEvent,
            ordinal: 6,
        },
        ViewAttachedToScene {
            ty: ViewAttachedToSceneEvent,
            ordinal: 7,
        },
        ViewDetachedFromScene {
            ty: ViewDetachedFromSceneEvent,
            ordinal: 8,
        },
        ViewPropertiesChanged {
            ty: ViewPropertiesChangedEvent,
            ordinal: 9,
        },
        ViewStateChanged {
            ty: ViewStateChangedEvent,
            ordinal: 10,
        },
        ViewHolderConnected {
            ty: ViewHolderConnectedEvent,
            ordinal: 11,
        },
    ],
}

/// These are all of the types of parameters that can be set to configure a
/// `Renderer`.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum RendererParam {
    ShadowTechnique(ShadowTechnique),
    Reserved(RenderFrequency),
    EnableDebugging(bool),
}

impl RendererParam {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::ShadowTechnique(_) => 1,
            Self::Reserved(_) => 2,
            Self::EnableDebugging(_) => 3,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for RendererParam {}

fidl_union! {
    name: RendererParam,
    members: [
        ShadowTechnique {
            ty: ShadowTechnique,
            ordinal: 1,
        },
        Reserved {
            ty: RenderFrequency,
            ordinal: 2,
        },
        EnableDebugging {
            ty: bool,
            ordinal: 3,
        },
    ],
}

/// These are all of the types of resources that can be created within a
/// `Session`. Add new fields only to the bottom of the list.
#[derive(Debug, PartialEq)]
pub enum ResourceArgs {
    Memory(MemoryArgs),
    Image(ImageArgs),
    Buffer(BufferArgs),
    View(ViewArgs),
    ViewHolder(ViewHolderArgs),
    Rectangle(RectangleArgs),
    RoundedRectangle(RoundedRectangleArgs),
    Circle(CircleArgs),
    Mesh(MeshArgs),
    ShapeNode(ShapeNodeArgs),
    ClipNode(ClipNodeArgs),
    EntityNode(EntityNodeArgs),
    OpacityNode(OpacityNodeArgsHack),
    Material(MaterialArgs),
    Compositor(CompositorArgs),
    DisplayCompositor(DisplayCompositorArgs),
    LayerStack(LayerStackArgs),
    Layer(LayerArgs),
    Scene(SceneArgs),
    Camera(CameraArgs),
    StereoCamera(StereoCameraArgs),
    Renderer(RendererArgs),
    AmbientLight(AmbientLightArgs),
    DirectionalLight(DirectionalLightArgs),
    Variable(VariableArgs),
    PointLight(PointLightArgs),
    View3(ViewArgs3),
    ImagePipe2(ImagePipe2Args),
    Image2(ImageArgs2),
    Image3(ImageArgs3),
}

impl ResourceArgs {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Memory(_) => 1,
            Self::Image(_) => 2,
            Self::Buffer(_) => 4,
            Self::View(_) => 5,
            Self::ViewHolder(_) => 6,
            Self::Rectangle(_) => 7,
            Self::RoundedRectangle(_) => 8,
            Self::Circle(_) => 9,
            Self::Mesh(_) => 10,
            Self::ShapeNode(_) => 11,
            Self::ClipNode(_) => 12,
            Self::EntityNode(_) => 13,
            Self::OpacityNode(_) => 14,
            Self::Material(_) => 15,
            Self::Compositor(_) => 16,
            Self::DisplayCompositor(_) => 17,
            Self::LayerStack(_) => 19,
            Self::Layer(_) => 20,
            Self::Scene(_) => 21,
            Self::Camera(_) => 22,
            Self::StereoCamera(_) => 23,
            Self::Renderer(_) => 24,
            Self::AmbientLight(_) => 25,
            Self::DirectionalLight(_) => 26,
            Self::Variable(_) => 27,
            Self::PointLight(_) => 28,
            Self::View3(_) => 31,
            Self::ImagePipe2(_) => 32,
            Self::Image2(_) => 33,
            Self::Image3(_) => 34,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for ResourceArgs {}

fidl_union! {
    name: ResourceArgs,
    resource: true,
    members: [
        Memory {
            ty: MemoryArgs,
            resource: true,
            ordinal: 1,
        },
        Image {
            ty: ImageArgs,
            ordinal: 2,
        },
        Buffer {
            ty: BufferArgs,
            ordinal: 4,
        },
        View {
            ty: ViewArgs,
            resource: true,
            ordinal: 5,
        },
        ViewHolder {
            ty: ViewHolderArgs,
            resource: true,
            ordinal: 6,
        },
        Rectangle {
            ty: RectangleArgs,
            ordinal: 7,
        },
        RoundedRectangle {
            ty: RoundedRectangleArgs,
            ordinal: 8,
        },
        Circle {
            ty: CircleArgs,
            ordinal: 9,
        },
        Mesh {
            ty: MeshArgs,
            ordinal: 10,
        },
        ShapeNode {
            ty: ShapeNodeArgs,
            ordinal: 11,
        },
        ClipNode {
            ty: ClipNodeArgs,
            ordinal: 12,
        },
        EntityNode {
            ty: EntityNodeArgs,
            ordinal: 13,
        },
        OpacityNode {
            ty: OpacityNodeArgsHack,
            ordinal: 14,
        },
        Material {
            ty: MaterialArgs,
            ordinal: 15,
        },
        Compositor {
            ty: CompositorArgs,
            ordinal: 16,
        },
        DisplayCompositor {
            ty: DisplayCompositorArgs,
            ordinal: 17,
        },
        LayerStack {
            ty: LayerStackArgs,
            ordinal: 19,
        },
        Layer {
            ty: LayerArgs,
            ordinal: 20,
        },
        Scene {
            ty: SceneArgs,
            ordinal: 21,
        },
        Camera {
            ty: CameraArgs,
            ordinal: 22,
        },
        StereoCamera {
            ty: StereoCameraArgs,
            ordinal: 23,
        },
        Renderer {
            ty: RendererArgs,
            ordinal: 24,
        },
        AmbientLight {
            ty: AmbientLightArgs,
            ordinal: 25,
        },
        DirectionalLight {
            ty: DirectionalLightArgs,
            ordinal: 26,
        },
        Variable {
            ty: VariableArgs,
            ordinal: 27,
        },
        PointLight {
            ty: PointLightArgs,
            ordinal: 28,
        },
        View3 {
            ty: ViewArgs3,
            resource: true,
            ordinal: 31,
        },
        ImagePipe2 {
            ty: ImagePipe2Args,
            resource: true,
            ordinal: 32,
        },
        Image2 {
            ty: ImageArgs2,
            ordinal: 33,
        },
        Image3 {
            ty: ImageArgs3,
            resource: true,
            ordinal: 34,
        },
    ],
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub enum Value {
    Vector1(f32),
    Vector2(Vec2),
    Vector3(Vec3),
    Vector4(Vec4),
    Matrix4x4(Mat4),
    ColorRgba(ColorRgba),
    ColorRgb(ColorRgb),
    /// Degrees of counter-clockwise rotation in the XY plane.
    Degrees(f32),
    Quaternion(Quaternion),
    Transform(FactoredTransform),
    /// ID of a value-producing resource (an animation or an expression).
    /// The type of this value matches the type produced by the named resource.
    VariableId(u32),
}

impl Value {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Vector1(_) => 1,
            Self::Vector2(_) => 2,
            Self::Vector3(_) => 3,
            Self::Vector4(_) => 4,
            Self::Matrix4x4(_) => 5,
            Self::ColorRgba(_) => 6,
            Self::ColorRgb(_) => 7,
            Self::Degrees(_) => 8,
            Self::Quaternion(_) => 9,
            Self::Transform(_) => 10,
            Self::VariableId(_) => 11,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for Value {}

fidl_union! {
    name: Value,
    members: [
        Vector1 {
            ty: f32,
            ordinal: 1,
        },
        Vector2 {
            ty: Vec2,
            ordinal: 2,
        },
        Vector3 {
            ty: Vec3,
            ordinal: 3,
        },
        Vector4 {
            ty: Vec4,
            ordinal: 4,
        },
        Matrix4x4 {
            ty: Mat4,
            ordinal: 5,
        },
        ColorRgba {
            ty: ColorRgba,
            ordinal: 6,
        },
        ColorRgb {
            ty: ColorRgb,
            ordinal: 7,
        },
        Degrees {
            ty: f32,
            ordinal: 8,
        },
        Quaternion {
            ty: Quaternion,
            ordinal: 9,
        },
        Transform {
            ty: FactoredTransform,
            ordinal: 10,
        },
        VariableId {
            ty: u32,
            ordinal: 11,
        },
    ],
}

/// Add a node as a child to another node.
///
/// Constraints:
/// - `id` refs a Node with the has_children characteristic.
/// - `child_id` refs any Node.
///
/// Discussion:
/// The child node is first removed from its existing parent, as if DetachCmd
/// was applied first.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct AddChildCmd {
    pub node_id: u32,
    pub child_id: u32,
}

impl fidl::encoding::TopLevel for AddChildCmd {}

fidl_struct! {
    copy: true,
    name: AddChildCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        child_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Add a layer to a layer stack.
/// Constraints:
/// - `layer_stack_id` refs a `LayerStack`.
/// - `layer_id` refs a `Layer`.
/// - The layer must not already belong to a different stack; it must first be
///   detached.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct AddLayerCmd {
    pub layer_stack_id: u32,
    pub layer_id: u32,
}

impl fidl::encoding::TopLevel for AddLayerCmd {}

fidl_struct! {
    copy: true,
    name: AddLayerCmd,
    members: [
        layer_stack_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        layer_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// DEPRECATED
/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct AddLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::encoding::TopLevel for AddLightCmd {}

fidl_struct! {
    copy: true,
    name: AddLightCmd,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        light_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Add a node as a part of another node.  The implications of being a part
/// rather than a child differ based on the type of the part.  However, one
/// implication is constant: removing all of a node's children (e.g. via
/// DetachChildrenCmd) does not affect its parts.  This is similar to the
/// "shadow DOM" in a web browser: the controls of a <video> element are
/// implemented as using the shadow DOM, and do no show up amongst the children
/// of that element.
///
/// Constraints:
/// - `id` refs a Node with the has_parts characteristic.
/// - `part_id` refs any Node.
///
/// Discussion:
/// The part node is first removed from its existing parent, as if DetachCmd
/// was applied first.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct AddPartCmd {
    pub node_id: u32,
    pub part_id: u32,
}

impl fidl::encoding::TopLevel for AddPartCmd {}

fidl_struct! {
    copy: true,
    name: AddPartCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        part_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// An AmbientLight is a Light that is is assumed to be everywhere in the scene,
/// in all directions.
///
/// Supported commands:
/// - SetLightColor
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct AmbientLightArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for AmbientLightArgs {}

fidl_struct! {
    copy: true,
    name: AmbientLightArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct BindMeshBuffersCmd {
    pub mesh_id: u32,
    pub index_buffer_id: u32,
    pub index_format: MeshIndexFormat,
    pub index_offset: u64,
    pub index_count: u32,
    pub vertex_buffer_id: u32,
    pub vertex_format: MeshVertexFormat,
    pub vertex_offset: u64,
    pub vertex_count: u32,
    pub bounding_box: BoundingBox,
}

impl fidl::encoding::TopLevel for BindMeshBuffersCmd {}

fidl_struct! {
    name: BindMeshBuffersCmd,
    members: [
        mesh_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        index_buffer_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        index_format {
            ty: MeshIndexFormat,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        index_offset {
            ty: u64,
            index: 3,
            typevar: T3,
            offset_v1: 16,
            offset_v2: 16,
        },
        index_count {
            ty: u32,
            index: 4,
            typevar: T4,
            offset_v1: 24,
            offset_v2: 24,
        },
        vertex_buffer_id {
            ty: u32,
            index: 5,
            typevar: T5,
            offset_v1: 28,
            offset_v2: 28,
        },
        vertex_format {
            ty: MeshVertexFormat,
            index: 6,
            typevar: T6,
            offset_v1: 32,
            offset_v2: 32,
        },
        vertex_offset {
            ty: u64,
            index: 7,
            typevar: T7,
            offset_v1: 48,
            offset_v2: 48,
        },
        vertex_count {
            ty: u32,
            index: 8,
            typevar: T8,
            offset_v1: 56,
            offset_v2: 56,
        },
        bounding_box {
            ty: BoundingBox,
            index: 9,
            typevar: T9,
            offset_v1: 60,
            offset_v2: 60,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 40,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 80,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 40,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 80,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 88,
    size_v2: 88,
    align_v1: 8,
    align_v2: 8,
}

/// Represents an axis-aligned bounding box.
///
/// If any of the dimensions has a negative extent (e.g. max.x < min.x) then the
/// bounding box is treated as empty. It is valid for a client to define an
/// empty bounding box.
///
/// An "empty bounding box" is one that does not admit a point inhabitant.
/// Note that a zero-volume, zero-area bounding box (e.g., a point like
/// (0,0,0)-(0,0,0), or a line like (0,0,0)-(1,0,0)) is thus not empty.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct BoundingBox {
    pub min: Vec3,
    pub max: Vec3,
}

impl fidl::encoding::TopLevel for BoundingBox {}

fidl_struct! {
    name: BoundingBox,
    members: [
        min {
            ty: Vec3,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        max {
            ty: Vec3,
            index: 1,
            typevar: T1,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 4,
    align_v2: 4,
}

/// A buffer mapped to a range of `Memory`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct BufferArgs {
    pub memory_id: u32,
    pub memory_offset: u32,
    pub num_bytes: u32,
}

impl fidl::encoding::TopLevel for BufferArgs {}

fidl_struct! {
    copy: true,
    name: BufferArgs,
    members: [
        memory_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        memory_offset {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        num_bytes {
            ty: u32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// A Camera is used to render a Scene from a particular viewpoint.  This is
/// achieved by setting a Renderer to use the camera.
///
/// The following commands may be applied to a Camera:
/// - SetCameraTransform
/// - SetCameraProjection
/// - SetCameraPoseBuffer
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct CameraArgs {
    /// The scene that the camera is viewing.
    pub scene_id: u32,
}

impl fidl::encoding::TopLevel for CameraArgs {}

fidl_struct! {
    copy: true,
    name: CameraArgs,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct CircleArgs {
    pub radius: Value,
}

impl fidl::encoding::TopLevel for CircleArgs {}

fidl_struct! {
    name: CircleArgs,
    members: [
        radius {
            ty: Value,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 24,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

/// Characteristics:
/// - has_parent
/// - is_clip
/// - has_parts
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ClipNodeArgs {
    pub unused: u32,
}

impl fidl::encoding::TopLevel for ClipNodeArgs {}

fidl_struct! {
    copy: true,
    name: ClipNodeArgs,
    members: [
        unused {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct ColorRgb {
    pub red: f32,
    pub green: f32,
    pub blue: f32,
}

impl fidl::encoding::TopLevel for ColorRgb {}

fidl_struct! {
    name: ColorRgb,
    members: [
        red {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        green {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        blue {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a ColorRgb, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct ColorRgbValue {
    pub value: ColorRgb,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for ColorRgbValue {}

fidl_struct! {
    name: ColorRgbValue,
    members: [
        value {
            ty: ColorRgb,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// sRGB color space and nonlinear transfer function.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ColorRgba {
    pub red: u8,
    pub green: u8,
    pub blue: u8,
    pub alpha: u8,
}

impl fidl::encoding::TopLevel for ColorRgba {}

fidl_struct! {
    copy: true,
    name: ColorRgba,
    members: [
        red {
            ty: u8,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        green {
            ty: u8,
            index: 1,
            typevar: T1,
            offset_v1: 1,
            offset_v2: 1,
        },
        blue {
            ty: u8,
            index: 2,
            typevar: T2,
            offset_v1: 2,
            offset_v2: 2,
        },
        alpha {
            ty: u8,
            index: 3,
            typevar: T3,
            offset_v1: 3,
            offset_v2: 3,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 1,
    align_v2: 1,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a ColorRgba, and `value` is ignored.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ColorRgbaValue {
    pub value: ColorRgba,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for ColorRgbaValue {}

fidl_struct! {
    copy: true,
    name: ColorRgbaValue,
    members: [
        value {
            ty: ColorRgba,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// A Compositor draws its `LayerStack` into a framebuffer provided by its
/// attached `Display`, if any.  If no display is attached, nothing is rendered.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct CompositorArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for CompositorArgs {}

fidl_struct! {
    copy: true,
    name: CompositorArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Instructs the compositor to create the specified `Resource`, and to register
/// it in a table so that it can be referenced by subsequent commands.
#[derive(Debug, PartialEq)]
pub struct CreateResourceCmd {
    /// An ID that is currently not used within the session.
    pub id: u32,
    pub resource: ResourceArgs,
}

impl fidl::encoding::TopLevel for CreateResourceCmd {}

fidl_struct! {
    name: CreateResourceCmd,
    resource: true,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        resource {
            ty: ResourceArgs,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 32,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Detaches all of a node's children (but not its parts).
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DetachChildrenCmd {
    pub node_id: u32,
}

impl fidl::encoding::TopLevel for DetachChildrenCmd {}

fidl_struct! {
    copy: true,
    name: DetachChildrenCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Detaches a parentable object from its parent (e.g. a node from a parent node,
/// or a layer from a layer stack).  It is illegal to apply this command to a
/// non-parentable object.  No-op if the target object currently has no parent.
///
/// Constraints:
/// - `id` refs a parentable object
///
/// Discussion:
/// For nodes, this command will detach a node from its parent, regardless of
/// whether it is a part or a child of its parent.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DetachCmd {
    pub id: u32,
}

impl fidl::encoding::TopLevel for DetachCmd {}

fidl_struct! {
    copy: true,
    name: DetachCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Detach the light specified by `light_id` from the scene that it is attached
/// to, if any.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DetachLightCmd {
    pub light_id: u32,
}

impl fidl::encoding::TopLevel for DetachLightCmd {}

fidl_struct! {
    copy: true,
    name: DetachLightCmd,
    members: [
        light_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Detach all lights from the scene specified by `scene_id`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DetachLightsCmd {
    pub scene_id: u32,
}

impl fidl::encoding::TopLevel for DetachLightsCmd {}

fidl_struct! {
    copy: true,
    name: DetachLightsCmd,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// A DirectionalLight is a Light that is emitted from a point at infinity.
///
/// Although the light is directional, the light has some amount of angular
/// dispersion (i.e., the light is not fully columnated). For simplicity, we
/// assume the dispersion of the light source is symmetric about the light's
/// primary direction.
///
/// Supported commands:
/// - SetLightColor
/// - SetLightDirection
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DirectionalLightArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for DirectionalLightArgs {}

fidl_struct! {
    copy: true,
    name: DirectionalLightArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// A DisplayCompositor draws its attached `LayerStack` into an image that is
/// presented on a display.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DisplayCompositorArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for DisplayCompositorArgs {}

fidl_struct! {
    copy: true,
    name: DisplayCompositorArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Provides information about a display.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct DisplayInfo {
    /// The size of the display, in physical pixels.
    pub width_in_px: u32,
    pub height_in_px: u32,
}

impl fidl::encoding::TopLevel for DisplayInfo {}

fidl_struct! {
    copy: true,
    name: DisplayInfo,
    members: [
        width_in_px {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        height_in_px {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Characteristics:
/// - has_transform
/// - has_children
/// - has_parent
/// - has_parts
/// - has_clip
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct EntityNodeArgs {
    pub unused: u32,
}

impl fidl::encoding::TopLevel for EntityNodeArgs {}

fidl_struct! {
    copy: true,
    name: EntityNodeArgs,
    members: [
        unused {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Create an external reference to the specified resource, which can then be
/// imported into another Session by passing a handle to `token`'s peer to
/// ImportResourceCmd; see that comment for more details.
///
/// The importing client is typically in a different process than the exporter.
/// No specific mechanism is provided for transferring a token from an exporter
/// to an importer; collaborators may choose any out-of-band API they wish to do
/// so.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ExportResourceCmdDeprecated {
    pub id: u32,
    pub token: fidl::EventPair,
}

impl fidl::encoding::TopLevel for ExportResourceCmdDeprecated {}

fidl_struct! {
    name: ExportResourceCmdDeprecated,
    resource: true,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        token {
            ty: fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Token that uniquely identifies a root point for a subgraph in the global
/// scene graph. Each `ExportToken` has exactly one corresponding `ImportToken`.
///
/// A Scenic client can have its contents referenced from another client by
/// creating a typed resource using this token.  The other client must also
/// create a correspondingly typed resource using the corresponding
/// `ImportToken`.
///
/// The exact nature of the inter-client reference depends on the specific
/// resources created from the tokens.  For example, creating a `View`
/// resource from this token allows everything attached to the `View` to be
/// embedded in another clients `ViewHolder`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ExportToken {
    pub value: fidl::EventPair,
}

impl fidl::encoding::TopLevel for ExportToken {}

fidl_struct! {
    name: ExportToken,
    resource: true,
    members: [
        value {
            ty: fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct FactoredTransform {
    pub translation: Vec3,
    pub scale: Vec3,
    /// Point around which rotation and scaling occur.
    pub anchor: Vec3,
    pub rotation: Quaternion,
}

impl fidl::encoding::TopLevel for FactoredTransform {}

fidl_struct! {
    name: FactoredTransform,
    members: [
        translation {
            ty: Vec3,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        scale {
            ty: Vec3,
            index: 1,
            typevar: T1,
            offset_v1: 12,
            offset_v2: 12,
        },
        anchor {
            ty: Vec3,
            index: 2,
            typevar: T2,
            offset_v1: 24,
            offset_v2: 24,
        },
        rotation {
            ty: Quaternion,
            index: 3,
            typevar: T3,
            offset_v1: 36,
            offset_v2: 36,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 52,
    size_v2: 52,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a float32, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct FloatValue {
    pub value: f32,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for FloatValue {}

fidl_struct! {
    name: FloatValue,
    members: [
        value {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// An image mapped to a range of a `Memory` resource.
#[derive(Debug, Clone, PartialEq)]
pub struct ImageArgs {
    pub info: fidl_fuchsia_images::ImageInfo,
    pub memory_id: u32,
    pub memory_offset: u32,
}

impl fidl::encoding::TopLevel for ImageArgs {}

fidl_struct! {
    name: ImageArgs,
    members: [
        info {
            ty: fidl_fuchsia_images::ImageInfo,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        memory_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 32,
            offset_v2: 32,
        },
        memory_offset {
            ty: u32,
            index: 2,
            typevar: T2,
            offset_v1: 36,
            offset_v2: 36,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 40,
    size_v2: 40,
    align_v1: 4,
    align_v2: 4,
}

/// An image mapped to a range of a `Memory` resource.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ImageArgs2 {
    pub width: u32,
    pub height: u32,
    /// The id of a `BufferCollection`. Before creating this resource, the
    /// buffer collection should be registered on the same `Session` with
    /// `RegisterBufferCollection` and it should have its contraints set.
    /// Once the buffers are allocated successfully (e.g. after calling
    /// `WaitForBuffersAllocated`), the collection's id can be used to create
    /// the image resource.
    pub buffer_collection_id: u32,
    /// The index of the VMO from the `BufferCollection` that backs this image.
    pub buffer_collection_index: u32,
}

impl fidl::encoding::TopLevel for ImageArgs2 {}

fidl_struct! {
    copy: true,
    name: ImageArgs2,
    members: [
        width {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        height {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        buffer_collection_id {
            ty: u32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        buffer_collection_index {
            ty: u32,
            index: 3,
            typevar: T3,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// An image that is backed by a `BufferCollection` registered with `Allocator`.
#[derive(Debug, PartialEq)]
pub struct ImageArgs3 {
    pub width: u32,
    pub height: u32,
    /// Image creation requires an allocated `BufferCollection` registered with Allocator.
    /// `import_token` should be the other end of a BufferCollectionExportToken that is
    /// successfully registered. All clients of the specified BufferCollection must have set
    /// their constraints and buffers should be allocated before calling.
    pub import_token: fidl_fuchsia_ui_composition::BufferCollectionImportToken,
    /// The index of the VMO from the `BufferCollection` that backs this image.
    pub buffer_collection_index: u32,
}

impl fidl::encoding::TopLevel for ImageArgs3 {}

fidl_struct! {
    name: ImageArgs3,
    resource: true,
    members: [
        width {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        height {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        import_token {
            ty: fidl_fuchsia_ui_composition::BufferCollectionImportToken,
            resource: true,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        buffer_collection_index {
            ty: u32,
            index: 3,
            typevar: T3,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// `ImagePipe2` is a `Resource` that can be used as a `Texture` for a `Material`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ImagePipe2Args {
    pub image_pipe_request: fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
}

impl fidl::encoding::TopLevel for ImagePipe2Args {}

fidl_struct! {
    name: ImagePipe2Args,
    resource: true,
    members: [
        image_pipe_request {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Import a resource that was exported via ExportResourceCmd().  `token` is
/// a handle to the eventpair peer that was used to export the resource, and
/// `spec` describes the type of the imported resource, and the commands which
/// can legally be applied to it.  Afterward, `id` can be used to refer to the
/// resource in an Command, similarly (but not identically: see below) to a
/// resource that was created in the session.  For example, you can add children
/// to an imported EntityNode via AddChildCmd.
///
/// However, note that the importer does not gain full access to the imported
/// resource, but rather to an attenuated subset of its capabilities.  For
/// example, you cannot use a DetachCmd to detach an imported EntityNode from
/// its parent.
///
/// Unlike ExportResourceCmd, there is no configurable timeout.  There is an
/// expectation that the exported resource will become available in a short
/// amount of time.  TODO: this needs elaboration... e.g. we might notify via the
/// SessionListener when we know that the link will never be made (e.g. if the
/// peer of the import token is destroyed).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ImportResourceCmdDeprecated {
    pub id: u32,
    pub token: fidl::EventPair,
    pub spec: ImportSpec,
}

impl fidl::encoding::TopLevel for ImportResourceCmdDeprecated {}

fidl_struct! {
    name: ImportResourceCmdDeprecated,
    resource: true,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        token {
            ty: fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        spec {
            ty: ImportSpec,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Token that uniquely identifies an attachment point for a subgraph in the
/// global scene graph.  Each `ImportToken` has exactly one corresponding
/// `ExportToken`.
///
/// A Scenic client can reference contents from another client by creating a
/// typed resource using this token.  The other client must also create a
/// correspondingly typed resource using the corresponding `ExportToken`.
///
/// The exact nature of the inter-client reference depends on the specific
/// resources created from the tokens.  For example, creating a `ViewHolder`
/// resource from this token allows a client to embed another client's `View`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ImportToken {
    pub value: fidl::EventPair,
}

impl fidl::encoding::TopLevel for ImportToken {}

fidl_struct! {
    name: ImportToken,
    resource: true,
    members: [
        value {
            ty: fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered when the imported resource with the given ID is no longer bound to
/// its host resource, or if the imported resource can not be bound because
/// the host resource is not available.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ImportUnboundEvent {
    pub resource_id: u32,
}

impl fidl::encoding::TopLevel for ImportUnboundEvent {}

fidl_struct! {
    copy: true,
    name: ImportUnboundEvent,
    members: [
        resource_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// A Layer is a 2-dimensional image that is drawn by a Compositor.  The
/// contents of each Layer in a Layerstack are independent of each other.
/// A layer is not drawn unless it has a camera, texture, or color.
///
/// Supported commands:
/// - Detach
/// - SetCamera
/// - SetColor
/// - SetTexture
/// - SetSize (depth must be zero)
/// - SetSize
/// - SetTranslation (z component determines the relative Z-ordering of layers)
/// - SetRotation (must rotate around Z-axis)
/// - SetScale
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct LayerArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for LayerArgs {}

fidl_struct! {
    copy: true,
    name: LayerArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// A LayerStack is a stack of layers that are attached to a Compositor, which
/// draws them in order of increasing Z-order (or rather, presents the illusion
/// of drawing them in that order: it may apply any optimizations that don't
/// affect the output).
///
/// Supported commands:
/// - AddLayer
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct LayerStackArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for LayerStackArgs {}

fidl_struct! {
    copy: true,
    name: LayerStackArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Simple texture-mapped material.
///
/// Supported commands:
/// - SetTextureCmd: sets the texture, or it can be left as zero (no texture).
///   The texture can be an Image or ImagePipe2.
/// - SetColorCmd: sets the color.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct MaterialArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for MaterialArgs {}

fidl_struct! {
    copy: true,
    name: MaterialArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec4, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Matrix4Value {
    pub value: Mat4,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for Matrix4Value {}

fidl_struct! {
    name: Matrix4Value,
    members: [
        value {
            ty: Mat4,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 64,
            offset_v2: 64,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 68,
    size_v2: 68,
    align_v1: 4,
    align_v2: 4,
}

/// `Memory` is a `Resource` that wraps a client-provided Zircon vmo to register
/// it with Scenic.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct MemoryArgs {
    /// The VMO which backs this memory.
    pub vmo: fidl::Vmo,
    /// The amount of memory from `vmo` that should be utilized.
    pub allocation_size: u64,
    /// The type of memory stored in the VMO, namely whether it's GPU memory or
    /// host memory.
    pub memory_type: fidl_fuchsia_images::MemoryType,
}

impl fidl::encoding::TopLevel for MemoryArgs {}

fidl_struct! {
    name: MemoryArgs,
    resource: true,
    members: [
        vmo {
            ty: fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        allocation_size {
            ty: u64,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
        memory_type {
            ty: fidl_fuchsia_images::MemoryType,
            index: 2,
            typevar: T2,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// A Mesh cannot be rendered until it has been bound to vertex/index buffers;
/// see BindMeshBuffersCmd.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct MeshArgs;

impl fidl::encoding::TopLevel for MeshArgs {}

fidl_struct! {
    empty: true,
    name: MeshArgs,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct MeshVertexFormat {
    /// kVector2 or kVector3.
    pub position_type: ValueType,
    /// kVector2 or kVector3 (must match position_type), or kNone.
    pub normal_type: ValueType,
    /// kVector2 or kNone.
    pub tex_coord_type: ValueType,
}

impl fidl::encoding::TopLevel for MeshVertexFormat {}

fidl_struct! {
    name: MeshVertexFormat,
    members: [
        position_type {
            ty: ValueType,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        normal_type {
            ty: ValueType,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        tex_coord_type {
            ty: ValueType,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Rendering target metrics associated with a node.
/// See also `MetricsEvent`.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Metrics {
    /// The ratio between the size of one logical pixel within the node's local
    /// coordinate system and the size of one physical pixel of the rendering
    /// target.
    ///
    /// This scale factors change in relation to the resolution of the rendering
    /// target and the scale transformations applied by containing nodes.
    /// They are always strictly positive and non-zero.
    ///
    /// For example, suppose the rendering target is a high resolution display
    /// with a device pixel ratio of 2.0 meaning that each logical pixel
    /// within the model corresponds to two physical pixels of the display.
    /// Assuming no scale transformations affect the node, then its metrics event
    /// will report a scale factor of 2.0.
    ///
    /// Building on this example, if instead the node's parent applies a
    /// scale transformation of 0.25 to the node, then the node's metrics event
    /// will report a scale factor of 0.5 indicating that the node should render
    /// its content at a reduced resolution and level of detail since a smaller
    /// area of physical pixels (half the size in each dimension) will be rendered.
    pub scale_x: f32,
    pub scale_y: f32,
    pub scale_z: f32,
}

impl fidl::encoding::TopLevel for Metrics {}

fidl_struct! {
    name: Metrics,
    members: [
        scale_x {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        scale_y {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        scale_z {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Provides rendering target metrics information about the specified node.
///
/// This event is delivered when the following conditions are true:
/// - The node is a descendant of a `Scene`.
/// - The node has `kMetricsEventMask` set to an enabled state.
/// - The node's metrics have changed since they were last delivered, or since
///   `kMetricsEventMask` transitioned from a disabled state to an enabled state.
///
/// Subscribe to this event to receive information about the scale factors you
/// should apply when generating textures for your nodes.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct MetricsEvent {
    pub node_id: u32,
    pub metrics: Metrics,
}

impl fidl::encoding::TopLevel for MetricsEvent {}

fidl_struct! {
    name: MetricsEvent,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        metrics {
            ty: Metrics,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// Characteristics:
/// - has_transform
/// - has_parent
/// - has_children
/// - has_parts
/// - has_opacity
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct OpacityNodeArgsHack {
    pub unused: u32,
}

impl fidl::encoding::TopLevel for OpacityNodeArgsHack {}

fidl_struct! {
    copy: true,
    name: OpacityNodeArgsHack,
    members: [
        unused {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Oriented plane described by a normal vector and a distance
/// from the origin along that vector.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Plane3 {
    pub dir: Vec3,
    pub dist: f32,
}

impl fidl::encoding::TopLevel for Plane3 {}

fidl_struct! {
    name: Plane3,
    members: [
        dir {
            ty: Vec3,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        dist {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// A PointLight is a Light that emits light in all directions.  By default, the
/// intensity of the light falls off according to the physically based
/// "inverse-square law" (see Wikipedia), although it can be adjusted to other
/// values for artistic effect.
///
/// Supported commands:
/// - SetLightColor
/// - SetPointLightPosition
/// - SetPointLightFalloff
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct PointLightArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for PointLightArgs {}

fidl_struct! {
    copy: true,
    name: PointLightArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PoseBufferProviderSetPoseBufferRequest {
    pub buffer: fidl::Vmo,
    pub num_entries: u32,
    pub base_time: i64,
    pub time_interval: u64,
}

impl fidl::encoding::TopLevel for PoseBufferProviderSetPoseBufferRequest {}

fidl_struct! {
    name: PoseBufferProviderSetPoseBufferRequest,
    resource: true,
    members: [
        buffer {
            ty: fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        num_entries {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        base_time {
            ty: i64,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        time_interval {
            ty: u64,
            index: 3,
            typevar: T3,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Quaternion {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

impl fidl::encoding::TopLevel for Quaternion {}

fidl_struct! {
    name: Quaternion,
    members: [
        x {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        y {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        z {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        w {
            ty: f32,
            index: 3,
            typevar: T3,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a Quaternion, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct QuaternionValue {
    pub value: Quaternion,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for QuaternionValue {}

fidl_struct! {
    name: QuaternionValue,
    members: [
        value {
            ty: Quaternion,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Rectangle centered at (0,0).
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct RectangleArgs {
    pub width: Value,
    pub height: Value,
}

impl fidl::encoding::TopLevel for RectangleArgs {}

fidl_struct! {
    name: RectangleArgs,
    members: [
        width {
            ty: Value,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        height {
            ty: Value,
            index: 1,
            typevar: T1,
            offset_v1: 24,
            offset_v2: 16,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 48,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

/// Releases the client's reference to the resource; it is then illegal to use
/// the ID in subsequent Commands.  Other references to the resource may exist,
/// so releasing the resource does not result in its immediate destruction; it is
/// only destroyed once the last reference is released.  For example, the
/// resource may be required to render an in-progress frame, or it may be
/// referred to by another resource).  However, the ID will be immediately
/// unregistered, and may be reused to create a new resource.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ReleaseResourceCmd {
    /// ID of the resource to be dereferenced.
    pub id: u32,
}

impl fidl::encoding::TopLevel for ReleaseResourceCmd {}

fidl_struct! {
    copy: true,
    name: ReleaseResourceCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Remove all layers from a layer stack.
/// Constraints
/// - `layer_stack_id` refs a `LayerStack`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct RemoveAllLayersCmd {
    pub layer_stack_id: u32,
}

impl fidl::encoding::TopLevel for RemoveAllLayersCmd {}

fidl_struct! {
    copy: true,
    name: RemoveAllLayersCmd,
    members: [
        layer_stack_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Remove a layer from a layer stack.
/// Constraints:
/// - `layer_stack_id` refs a `LayerStack`.
/// - `layer_id` refs a `Layer`.
/// - The layer must belong to this stack.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct RemoveLayerCmd {
    pub layer_stack_id: u32,
    pub layer_id: u32,
}

impl fidl::encoding::TopLevel for RemoveLayerCmd {}

fidl_struct! {
    copy: true,
    name: RemoveLayerCmd,
    members: [
        layer_stack_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        layer_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// A Renderer renders a Scene via a Camera.
///
/// Supported commands:
/// - SetCamera
/// - SetRendererParam
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct RendererArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for RendererArgs {}

fidl_struct! {
    copy: true,
    name: RendererArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// RoundedRectangle centered at (0,0).  Legal parameter values must satisfy the
/// constraint that the flat sides of the rectangle have non-negative length.
/// In other words, the following constraints must hold:
///   - top_left_radius + top_right_radius <= width
///   - bottom_left_radius + bottom_right_radius <= width
///   - top_left_radius + bottom_left_radius <= height
///   - top_right_radius + bottom_right_radius <= height
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct RoundedRectangleArgs {
    pub width: Value,
    pub height: Value,
    pub top_left_radius: Value,
    pub top_right_radius: Value,
    pub bottom_right_radius: Value,
    pub bottom_left_radius: Value,
}

impl fidl::encoding::TopLevel for RoundedRectangleArgs {}

fidl_struct! {
    name: RoundedRectangleArgs,
    members: [
        width {
            ty: Value,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        height {
            ty: Value,
            index: 1,
            typevar: T1,
            offset_v1: 24,
            offset_v2: 16,
        },
        top_left_radius {
            ty: Value,
            index: 2,
            typevar: T2,
            offset_v1: 48,
            offset_v2: 32,
        },
        top_right_radius {
            ty: Value,
            index: 3,
            typevar: T3,
            offset_v1: 72,
            offset_v2: 48,
        },
        bottom_right_radius {
            ty: Value,
            index: 4,
            typevar: T4,
            offset_v1: 96,
            offset_v2: 64,
        },
        bottom_left_radius {
            ty: Value,
            index: 5,
            typevar: T5,
            offset_v1: 120,
            offset_v2: 80,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 144,
    size_v2: 96,
    align_v1: 8,
    align_v2: 8,
}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SceneAddAmbientLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::encoding::TopLevel for SceneAddAmbientLightCmd {}

fidl_struct! {
    copy: true,
    name: SceneAddAmbientLightCmd,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        light_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SceneAddDirectionalLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::encoding::TopLevel for SceneAddDirectionalLightCmd {}

fidl_struct! {
    copy: true,
    name: SceneAddDirectionalLightCmd,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        light_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SceneAddPointLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::encoding::TopLevel for SceneAddPointLightCmd {}

fidl_struct! {
    copy: true,
    name: SceneAddPointLightCmd,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        light_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// A Scene is the root of a scene-graph, and defines the rendering environment
/// (lighting, etc.) for the tree of nodes beneath it.
///
/// Supported commands:
/// - Add/RemoveLight
/// - AddChild
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SceneArgs {
    pub dummy: u32,
}

impl fidl::encoding::TopLevel for SceneArgs {}

fidl_struct! {
    copy: true,
    name: SceneArgs,
    members: [
        dummy {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Sends a hint about a pending size change to the given node and all nodes
/// below. This is generally sent before an animation.
///
/// `width_change_factor` and `height_change_factor` is how much bigger or smaller
/// the item is expected to be in the near future. This one number encapsulate
/// both changes in scale, as well as changes to layout width and height.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SendSizeChangeHintCmdHack {
    pub node_id: u32,
    pub width_change_factor: f32,
    pub height_change_factor: f32,
}

impl fidl::encoding::TopLevel for SendSizeChangeHintCmdHack {}

fidl_struct! {
    name: SendSizeChangeHintCmdHack,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        width_change_factor {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        height_change_factor {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a Resource's (typically a Node's) anchor point.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetAnchorCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::encoding::TopLevel for SetAnchorCmd {}

fidl_struct! {
    name: SetAnchorCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a camera's 2D clip-space transform.
///
/// Constraints:
/// - `camera_id` refs a `Camera`.
/// - `translation` is the desired translation, in Vulkan NDC.
/// - `scale` is the scale factor to apply on the x/y plane before translation.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetCameraClipSpaceTransformCmd {
    pub camera_id: u32,
    pub translation: Vec2,
    pub scale: f32,
}

impl fidl::encoding::TopLevel for SetCameraClipSpaceTransformCmd {}

fidl_struct! {
    name: SetCameraClipSpaceTransformCmd,
    members: [
        camera_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        translation {
            ty: Vec2,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        scale {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a renderer's camera.
///
/// Constraints:
/// - `renderer_id` refs a `Renderer`.
/// - `camera_id` refs a `Camera`, or stops rendering by passing zero.
/// - `matrix` is a value or variable of type kMatrix4x4.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetCameraCmd {
    pub renderer_id: u32,
    pub camera_id: u32,
}

impl fidl::encoding::TopLevel for SetCameraCmd {}

fidl_struct! {
    copy: true,
    name: SetCameraCmd,
    members: [
        renderer_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        camera_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the "pose buffer" for the camera identified by `camera_id`.
/// This operation can be applied to both Cameras and StereoCameras.
///
/// This will override any position and rotation set for the camera and will
/// make it take its position and rotation from the pose buffer each frame
/// based on the presentation time for that frame.
///
/// A pose buffer represents a ring buffer of poses for a fixed number of time
/// points in the future. Each entry in the buffer identified by `buffer_id` is
/// a quaternion and a position layed out as follows:
///
/// struct Pose {
///   // Quaternion
///   float32 a;
///   float32 b;
///   float32 c;
///   float32 d;
///
///   // Position
///   float32 x;
///   float32 y;
///   float32 z;
///
///   // Reserved/Padding
///   byte[4] reserved;
/// }
///
/// The buffer can be thought of as a packed array of `num_entries` Pose structs
/// and is required to be at least num_entries * sizeof(Pose) bytes.
///
/// The quaternions and positions are specified in the space of the camera's
/// parent node.
///
/// `base_time` is a base time point expressed in nanoseconds in the
/// `CLOCK_MONOTONIC` timebase and `time_interval` is the time in nanoseconds
/// between entries in the buffer. `base_time` must be in the past.
///
/// For a given point in time `t` expressed in nanoseconds in the
/// `CLOCK_MONOTONIC` timebase the index of the corresponding pose in
/// the pose buffer can be computed as follows:
///
/// index(t) = ((t - base_time) / time_interval) % num_entries
///
/// poses[index(t)] is valid for t over the time interval (t - time_interval, t]
/// and should be expected to updated continuously without synchronization
/// for the duration of that interval. If a single pose value is needed for
/// multiple non-atomic operations a value should be latched and stored outside
/// the pose buffer.
///
/// Because the poses are not protected by any synchronization primitives it is
/// possible that when a pose is latched it will be only partially updated, and
/// the pose being read will contain some components from the pose before it is
/// updated and some components from the updated pose. The safety of using these
/// "torn" poses relies on two things:
///
/// 1) Sequential poses written to poses[index(t)] are very similar to each
/// other numerically, so that if some components are taken from the first and
/// some are taken from another the result is numerically similar to both
///
/// 2) The space of positions and quaternions is locally flat at the scale of
/// changes between sequential updates, which guarantees that two poses which
/// are numerically similar also represent semantically similar poses (i.e.
/// there are no discontinuities which will cause a small numerical change in
/// the position or quaterninon to cause a large change in the encoded pose)
/// For positions this is guaranteed because Scenic uses a Euclidean 3-space
/// which is globally flat and for quaternions this is guaranteed because
/// quaternions encode rotation as points on a unit 4-sphere, and spheres are
/// locally flat. For more details on the encoding of rotations in quaterions
/// see https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
///
/// This commanderation is intended for late latching camera pose to support
/// low-latency motion-tracked rendering.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(C)]
pub struct SetCameraPoseBufferCmd {
    pub camera_id: u32,
    pub buffer_id: u32,
    pub num_entries: u32,
    pub base_time: i64,
    pub time_interval: u64,
}

impl fidl::encoding::TopLevel for SetCameraPoseBufferCmd {}

fidl_struct! {
    copy: true,
    name: SetCameraPoseBufferCmd,
    members: [
        camera_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        buffer_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        num_entries {
            ty: u32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        base_time {
            ty: i64,
            index: 3,
            typevar: T3,
            offset_v1: 16,
            offset_v2: 16,
        },
        time_interval {
            ty: u64,
            index: 4,
            typevar: T4,
            offset_v1: 24,
            offset_v2: 24,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

/// Sets a camera's projection matrix.
/// This operation cannot be applied to a StereoCamera.
///
/// Constraints:
/// - `camera_id` refs a `Camera` that is not a `StereoCamera`.
/// - `fovy` is the Y-axis field of view, in radians.
///
/// NOTE: A default orthographic projection is specified by setting `fovy` to
/// zero.  In this case, the camera transform is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetCameraProjectionCmd {
    pub camera_id: u32,
    pub fovy: FloatValue,
}

impl fidl::encoding::TopLevel for SetCameraProjectionCmd {}

fidl_struct! {
    name: SetCameraProjectionCmd,
    members: [
        camera_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        fovy {
            ty: FloatValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a camera's view matrix.
/// This operation can be applied to both Cameras and StereoCameras.
///
/// Constraints:
/// - `camera_id` refs a `Camera`.
/// - `eye_position` is the position of the eye.
/// - `eye_look_at` is the point is the scene the that eye is pointed at.
/// - `eye_up` defines the camera's "up" vector.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetCameraTransformCmd {
    pub camera_id: u32,
    pub eye_position: Vector3Value,
    pub eye_look_at: Vector3Value,
    pub eye_up: Vector3Value,
}

impl fidl::encoding::TopLevel for SetCameraTransformCmd {}

fidl_struct! {
    name: SetCameraTransformCmd,
    members: [
        camera_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        eye_position {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        eye_look_at {
            ty: Vector3Value,
            index: 2,
            typevar: T2,
            offset_v1: 20,
            offset_v2: 20,
        },
        eye_up {
            ty: Vector3Value,
            index: 3,
            typevar: T3,
            offset_v1: 36,
            offset_v2: 36,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 52,
    size_v2: 52,
    align_v1: 4,
    align_v2: 4,
}

/// Sets/clears a node's clip.  DEPRECATED: use SetClipPlanesCmd.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_clip characteristic.
/// - `clip_id` a `Node` with the is_clip characteristic, or nothing.  If the
///   referenced node is not rooted, then it will have no effect (since its
///   full world-transform cannot be determined).
/// - `clip_to_self` If false, children are only clipped to the region specified
///   by `clip_id`.  If true, children are additionally clipped to the node's
///   shape (as determined by its ShapeNode parts).
///
/// Discussion:
/// If a node has a clip, it will be applied to both the parts and the children
/// of the node.  Under some circumstances (TBD), a clip will not be applicable
/// to a node; in such cases it will be as though no clip has been specified for
/// the node.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetClipCmd {
    pub node_id: u32,
    pub clip_id: u32,
    pub clip_to_self: bool,
}

impl fidl::encoding::TopLevel for SetClipCmd {}

fidl_struct! {
    name: SetClipCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        clip_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        clip_to_self {
            ty: bool,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 8,
            mask: 0xffffff00u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 8,
            mask: 0xffffff00u32,
        },
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the list of clip planes that apply to a Node and all of its children.  Replaces
/// the list set by any previous SetClipPlanesCmd.
///
/// - `node_id` refs a `Node` with the has_clip characteristic.
/// - `clip_planes` is the new list of oriented clip planes.
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct SetClipPlanesCmd {
    pub node_id: u32,
    pub clip_planes: Vec<Plane3>,
}

impl fidl::encoding::TopLevel for SetClipPlanesCmd {}

fidl_struct! {
    name: SetClipPlanesCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        clip_planes {
            ty: fidl::encoding::UnboundedVector<Plane3>,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Sets a material's color.
///
/// Constraints:
/// - `material_id` refs a `Material`.
///
/// If a texture is set on the material, then the value sampled from the texture
/// is multiplied by the color.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetColorCmd {
    pub material_id: u32,
    pub color: ColorRgbaValue,
}

impl fidl::encoding::TopLevel for SetColorCmd {}

fidl_struct! {
    copy: true,
    name: SetColorCmd,
    members: [
        material_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        color {
            ty: ColorRgbaValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Set whether clipping should be disabled for the specified renderer.  For a
/// newly-created renderer, clipping will NOT be disabled (i.e. it will be
/// enabled).
///
/// NOTE: this disables visual clipping only; objects are still clipped for the
/// purposes of hit-testing.
///
/// `renderer_id` refs the target renderer.
/// `disable_clipping` specifies whether the clipping should be disabled.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetDisableClippingCmd {
    pub renderer_id: u32,
    pub disable_clipping: bool,
}

impl fidl::encoding::TopLevel for SetDisableClippingCmd {}

fidl_struct! {
    name: SetDisableClippingCmd,
    members: [
        renderer_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        disable_clipping {
            ty: bool,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Set the color conversion applied to the compositor's display.
/// The conversion is applied to to each pixel according to the formula:
///
/// (matrix * (pixel + preoffsets)) + postoffsets
///
/// where pixel is a column vector consisting of the pixel's 3 components.
///
/// `matrix` is passed in row-major order. Clients will be responsible
/// for passing default values, when needed.
/// Default values are not currently supported in fidl.
/// Default Values:
///   preoffsets = [0 0 0]
///   matrix = [1 0 0 0 1 0 0 0 1]
///   postoffsets = [0 0 0]
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetDisplayColorConversionCmdHack {
    pub compositor_id: u32,
    pub preoffsets: [f32; 3],
    pub matrix: [f32; 9],
    pub postoffsets: [f32; 3],
}

impl fidl::encoding::TopLevel for SetDisplayColorConversionCmdHack {}

fidl_struct! {
    name: SetDisplayColorConversionCmdHack,
    members: [
        compositor_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        preoffsets {
            ty: fidl::encoding::Array<f32, 3>,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        matrix {
            ty: fidl::encoding::Array<f32, 9>,
            index: 2,
            typevar: T2,
            offset_v1: 16,
            offset_v2: 16,
        },
        postoffsets {
            ty: fidl::encoding::Array<f32, 3>,
            index: 3,
            typevar: T3,
            offset_v1: 52,
            offset_v2: 52,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 64,
    size_v2: 64,
    align_v1: 4,
    align_v2: 4,
}

#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetDisplayMinimumRgbCmdHack {
    pub min_value: u8,
}

impl fidl::encoding::TopLevel for SetDisplayMinimumRgbCmdHack {}

fidl_struct! {
    copy: true,
    name: SetDisplayMinimumRgbCmdHack,
    members: [
        min_value {
            ty: u8,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 1,
    size_v2: 1,
    align_v1: 1,
    align_v2: 1,
}

/// Depending on the device, the display might be rotated
/// with respect to what the lower level device controller
/// considers the physical orientation of pixels. The
/// compositors and layers must be in alignment with the
/// underlying physical orientation which means that for
/// certain operations like screenshotting, they cannot
/// provide results with the accurate orientation unless
/// they have information about how the higher-level display
/// is orienting the screen. The only legal values for the
/// rotation are 0, 90, 180, and 270, which are each
///  applied counterclockwise.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetDisplayRotationCmdHack {
    pub compositor_id: u32,
    pub rotation_degrees: u32,
}

impl fidl::encoding::TopLevel for SetDisplayRotationCmdHack {}

fidl_struct! {
    copy: true,
    name: SetDisplayRotationCmdHack,
    members: [
        compositor_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        rotation_degrees {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetEnableDebugViewBoundsCmd {
    pub view_id: u32,
    pub enable: bool,
}

impl fidl::encoding::TopLevel for SetEnableDebugViewBoundsCmd {}

fidl_struct! {
    name: SetEnableDebugViewBoundsCmd,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        enable {
            ty: bool,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets which events a resource should deliver to the session listener.
/// This command replaces any prior event mask for the resource.
///
/// The initial event mask for a resource is zero, meaning no events are
/// reported.
///
/// Constraints:
/// - `resource_id` is a valid resource id
/// - `event_mask` is zero or a combination of `k*EventMask` bits OR'ed together.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetEventMaskCmd {
    pub id: u32,
    pub event_mask: u32,
}

impl fidl::encoding::TopLevel for SetEventMaskCmd {}

fidl_struct! {
    copy: true,
    name: SetEventMaskCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        event_mask {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a node's hit test behavior.
///
/// Discussion:
/// By default, hit testing is performed on the node's content, its parts,
/// and its children.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetHitTestBehaviorCmd {
    pub node_id: u32,
    pub hit_test_behavior: HitTestBehavior,
}

impl fidl::encoding::TopLevel for SetHitTestBehaviorCmd {}

fidl_struct! {
    name: SetHitTestBehaviorCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        hit_test_behavior {
            ty: HitTestBehavior,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetImportFocusCmdDeprecated;

impl fidl::encoding::TopLevel for SetImportFocusCmdDeprecated {}

fidl_struct! {
    empty: true,
    name: SetImportFocusCmdDeprecated,
}

/// Sets/clears a label to help developers identify the purpose of the resource
/// when using diagnostic tools.
///
/// The label serves no functional purpose in the scene graph.  It exists only
/// to help developers understand its structure.  The scene manager may truncate
/// or discard labels at will.
///
/// Constraints:
/// - The label's maximum length is `kLabelMaxLength` characters.
/// - Setting the label to an empty string clears it.
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetLabelCmd {
    pub id: u32,
    pub label: String,
}

impl fidl::encoding::TopLevel for SetLabelCmd {}

fidl_struct! {
    name: SetLabelCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        label {
            ty: fidl::encoding::UnboundedString,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Set a compositor's layer stack, replacing the current stack (if any).
/// Constraints:
/// - `compositor_id` refs a `DisplayCompositor`.
/// - `layer_stack_id` refs a `LayerStack`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetLayerStackCmd {
    pub compositor_id: u32,
    pub layer_stack_id: u32,
}

impl fidl::encoding::TopLevel for SetLayerStackCmd {}

fidl_struct! {
    copy: true,
    name: SetLayerStackCmd,
    members: [
        compositor_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        layer_stack_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the color of the Light identified by `light_id`.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetLightColorCmd {
    pub light_id: u32,
    pub color: ColorRgbValue,
}

impl fidl::encoding::TopLevel for SetLightColorCmd {}

fidl_struct! {
    name: SetLightColorCmd,
    members: [
        light_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        color {
            ty: ColorRgbValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the direction of the DirectionalLight identified by `light_id`.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetLightDirectionCmd {
    pub light_id: u32,
    pub direction: Vector3Value,
}

impl fidl::encoding::TopLevel for SetLightDirectionCmd {}

fidl_struct! {
    name: SetLightDirectionCmd,
    members: [
        light_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        direction {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Sets/clears a node's material.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_material characteristic.
/// - `material_id` refs a `Material`, or nothing.
/// - if this command causes the target to have both a `Shape` and a `Material`,
///   then these must be compatible with each other (see README.md regarding
///   "Shape/Material Compatibility").
///
/// Discussion:
/// In order to be painted, a node requires both a `Shape` and a `Material`.
/// Without a material, a node can still participate in hit-testing and clipping.
/// Without a shape, a node cannot do any of the above.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetMaterialCmd {
    pub node_id: u32,
    pub material_id: u32,
}

impl fidl::encoding::TopLevel for SetMaterialCmd {}

fidl_struct! {
    copy: true,
    name: SetMaterialCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        material_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a node's opacity.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_opacity characteristic.
/// - `opacity` is in the range [0, 1].
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetOpacityCmd {
    pub node_id: u32,
    pub opacity: f32,
}

impl fidl::encoding::TopLevel for SetOpacityCmd {}

fidl_struct! {
    name: SetOpacityCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        opacity {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the falloff factor of the PointLight identified by `light_id`.
/// A value of 1.0 corresponds to the physically-based "inverse-square law"
/// (see Wikipedia).  Other values can be used for artistic effect, e.g. a
/// value of 0.0 means that the radiance of a surface is not dependant on
/// its distance from the light.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetPointLightFalloffCmd {
    pub light_id: u32,
    pub falloff: FloatValue,
}

impl fidl::encoding::TopLevel for SetPointLightFalloffCmd {}

fidl_struct! {
    name: SetPointLightFalloffCmd,
    members: [
        light_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        falloff {
            ty: FloatValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the position of the PointLight identified by `light_id`.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetPointLightPositionCmd {
    pub light_id: u32,
    pub position: Vector3Value,
}

impl fidl::encoding::TopLevel for SetPointLightPositionCmd {}

fidl_struct! {
    name: SetPointLightPositionCmd,
    members: [
        light_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        position {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Set a layer's renderer, replacing the current renderer (if any).
/// Constraints:
/// - `layer_id` refs a `Layer`.
/// - `renderer_id` refs a `Renderer`.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetRendererCmd {
    pub layer_id: u32,
    pub renderer_id: u32,
}

impl fidl::encoding::TopLevel for SetRendererCmd {}

fidl_struct! {
    copy: true,
    name: SetRendererCmd,
    members: [
        layer_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        renderer_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a parameter that affects how a renderer renders a scene.
///
/// `renderer_id` refs the Renderer that is being modified.
/// `param` describes the parameter that should be set, and to what.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetRendererParamCmd {
    pub renderer_id: u32,
    pub param: RendererParam,
}

impl fidl::encoding::TopLevel for SetRendererParamCmd {}

fidl_struct! {
    name: SetRendererParamCmd,
    members: [
        renderer_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        param {
            ty: RendererParam,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 32,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Sets a Resource's (typically a Node's) rotation.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
///
/// Discussion:
/// Quaternions represent any rotation in a 3D coordinate system. Consisting of
/// [a,b,c,d], [a] represents the amount of rotation that should be applied and
/// [b,c,d] represents the vector around which the rotation is applied. This
/// conforms to the semantics of glm::quat.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetRotationCmd {
    pub id: u32,
    pub value: QuaternionValue,
}

impl fidl::encoding::TopLevel for SetRotationCmd {}

fidl_struct! {
    name: SetRotationCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: QuaternionValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a Resource's (typically a Node's) scale.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetScaleCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::encoding::TopLevel for SetScaleCmd {}

fidl_struct! {
    name: SetScaleCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a node's semantic visibility.
///
/// Discussion:
/// By default, all nodes are semantically visible. Semantically invisible nodes and their children
/// are ignored by hit tests performed for accessibility.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SetSemanticVisibilityCmd {
    pub node_id: u32,
    pub visible: bool,
}

impl fidl::encoding::TopLevel for SetSemanticVisibilityCmd {}

fidl_struct! {
    name: SetSemanticVisibilityCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        visible {
            ty: bool,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets/clears a node's shape.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_shape characteristic.
/// - `shape_id` refs a `Shape`, or nothing.
/// - if this command causes the target to have both a `Shape` and a `Material`,
///   then these must be compatible with each other (see README.md regarding
///   "Shape/Material Compatibility").
///
/// Discussion:
/// In order to be painted, a node requires both a `Shape` and a `Material`.
/// Without a material, a node can still participate in hit-testing and clipping.
/// Without a shape, a node cannot do any of the above.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetShapeCmd {
    pub node_id: u32,
    pub shape_id: u32,
}

impl fidl::encoding::TopLevel for SetShapeCmd {}

fidl_struct! {
    copy: true,
    name: SetShapeCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        shape_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets an object's size.
///
/// Constraints:
/// - `id` refs a resizeable object.
/// - some objects that support this command may have additional constraints
///   (e.g. in some cases `depth` must be zero).
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetSizeCmd {
    pub id: u32,
    pub value: Vector2Value,
}

impl fidl::encoding::TopLevel for SetSizeCmd {}

fidl_struct! {
    name: SetSizeCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: Vector2Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a StereoCamera's projection matrices.
/// This operation can only be applied to a StereoCamera.
///
/// Constraints:
/// - `camera_id` refs a `StereoCamera`.
/// - `left_projection` is the projection matrix for the left eye.
/// - `right_projection` is the projection matrix for the right eye.
///
/// These projection matrices may also contain a transform in camera space for
/// their eye if needed.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetStereoCameraProjectionCmd {
    pub camera_id: u32,
    pub left_projection: Matrix4Value,
    pub right_projection: Matrix4Value,
}

impl fidl::encoding::TopLevel for SetStereoCameraProjectionCmd {}

fidl_struct! {
    name: SetStereoCameraProjectionCmd,
    members: [
        camera_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        left_projection {
            ty: Matrix4Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        right_projection {
            ty: Matrix4Value,
            index: 2,
            typevar: T2,
            offset_v1: 72,
            offset_v2: 72,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 140,
    size_v2: 140,
    align_v1: 4,
    align_v2: 4,
}

/// Sets/clears a node's tag value.
///
/// A session can apply a tag value to any node to which it has access, including
/// imported nodes.  These tags are private to the session and cannot be read
/// or modified by other sessions.  When multiple sessions import the same node,
/// each session will only observe its own tag values.
///
/// Hit test results for a session only include nodes which the session has
/// tagged with a non-zero value.  Therefore a session can use tag values to
/// associate nodes with their functional purpose when picked.
///
/// Constraints:
/// - `node_id` refs a `Node`.
/// - `tag_value` is the tag value to assign, or 0 to remove the tag.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetTagCmd {
    pub node_id: u32,
    pub tag_value: u32,
}

impl fidl::encoding::TopLevel for SetTagCmd {}

fidl_struct! {
    copy: true,
    name: SetTagCmd,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        tag_value {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets/clears a material's texture.
///
/// Constraints:
/// - `material_id` refs a `Material`.
/// - `texture_id` refs a `Image`, `ImagePipe2`, or nothing.
///
/// If no texture is provided (i.e. `texture_id` is zero), a solid color is used.
/// If a texture is provided, then the value sampled from the texture is
/// multiplied by the color.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct SetTextureCmd {
    pub material_id: u32,
    pub texture_id: u32,
}

impl fidl::encoding::TopLevel for SetTextureCmd {}

fidl_struct! {
    copy: true,
    name: SetTextureCmd,
    members: [
        material_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        texture_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Sets a Resource's (typically a Node's) translation.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetTranslationCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::encoding::TopLevel for SetTranslationCmd {}

fidl_struct! {
    name: SetTranslationCmd,
    members: [
        id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: Vector3Value,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetViewHolderBoundsColorCmd {
    pub view_holder_id: u32,
    pub color: ColorRgbValue,
}

impl fidl::encoding::TopLevel for SetViewHolderBoundsColorCmd {}

fidl_struct! {
    name: SetViewHolderBoundsColorCmd,
    members: [
        view_holder_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        color {
            ty: ColorRgbValue,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Sets the properties for a ViewHolder's attached View.
///
/// Constraints:
/// - `view_holder_id` refs a `ViewHolder`.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SetViewPropertiesCmd {
    pub view_holder_id: u32,
    pub properties: ViewProperties,
}

impl fidl::encoding::TopLevel for SetViewPropertiesCmd {}

fidl_struct! {
    name: SetViewPropertiesCmd,
    members: [
        view_holder_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        properties {
            ty: ViewProperties,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 56,
    size_v2: 56,
    align_v1: 4,
    align_v2: 4,
}

/// Characteristics:
/// - has_parent
/// - has_shape
/// - has_material
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ShapeNodeArgs {
    pub unused: u32,
}

impl fidl::encoding::TopLevel for ShapeNodeArgs {}

fidl_struct! {
    copy: true,
    name: ShapeNodeArgs,
    members: [
        unused {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered in response to a size change hint from a parent node
/// (SendSizeChangeHintCmd).
///
/// This event is delivered when the following conditions are true:
/// - The node has `kSizeChangeEventMask` set to an enabled state.
/// - A parent node has sent a SendSizeChangeHintCmd.
///
/// Subscribe to this event to receive information about how large textures you
/// will need in the near future for your nodes. The canonical use case is to
/// pre-allocate memory to avoid repeated re-allocations.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct SizeChangeHintEvent {
    pub node_id: u32,
    pub width_change_factor: f32,
    pub height_change_factor: f32,
}

impl fidl::encoding::TopLevel for SizeChangeHintEvent {}

fidl_struct! {
    name: SizeChangeHintEvent,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        width_change_factor {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        height_change_factor {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, PartialEq)]
pub struct SnapshotCallbackDeprecatedOnDataRequest {
    pub data: fidl_fuchsia_mem::Buffer,
}

impl fidl::encoding::TopLevel for SnapshotCallbackDeprecatedOnDataRequest {}

fidl_struct! {
    name: SnapshotCallbackDeprecatedOnDataRequest,
    resource: true,
    members: [
        data {
            ty: fidl_fuchsia_mem::Buffer,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

/// A StereoCamera is a Camera that renders the scene in side-by-side stereo.
///
/// Any command which can be applied to a Camera can also be applied to a
/// StereoCamera.
/// Additional supported commands:
/// - SetStereoCameraProjection
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct StereoCameraArgs {
    /// The scene that the camera is viewing.
    pub scene_id: u32,
}

impl fidl::encoding::TopLevel for StereoCameraArgs {}

fidl_struct! {
    copy: true,
    name: StereoCameraArgs,
    members: [
        scene_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct TakeSnapshotCmdDeprecated {
    pub node_id: u32,
    pub callback: fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
}

impl fidl::encoding::TopLevel for TakeSnapshotCmdDeprecated {}

fidl_struct! {
    name: TakeSnapshotCmdDeprecated,
    resource: true,
    members: [
        node_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        callback {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

/// Describes a typed, client-modifiable value.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct VariableArgs {
    pub type_: ValueType,
    pub initial_value: Value,
}

impl fidl::encoding::TopLevel for VariableArgs {}

fidl_struct! {
    name: VariableArgs,
    members: [
        type_ {
            ty: ValueType,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        initial_value {
            ty: Value,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 32,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec2, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vector2Value {
    pub value: Vec2,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for Vector2Value {}

fidl_struct! {
    name: Vector2Value,
    members: [
        value {
            ty: Vec2,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec3, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vector3Value {
    pub value: Vec3,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for Vector3Value {}

fidl_struct! {
    name: Vector3Value,
    members: [
        value {
            ty: Vec3,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec4, and `value` is ignored.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vector4Value {
    pub value: Vec4,
    pub variable_id: u32,
}

impl fidl::encoding::TopLevel for Vector4Value {}

fidl_struct! {
    name: Vector4Value,
    members: [
        value {
            ty: Vec4,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        variable_id {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 20,
    size_v2: 20,
    align_v1: 4,
    align_v2: 4,
}

/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
/// attached to the `View` as children, and these Nodes will have the `View`s'
/// coordinate transform applied to their own, in addition to being clipped to
/// the `View`s' bounding box.
/// See `ViewProperties`.
///
/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
///
/// Usually the `View` and its associated `ViewHolder` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
#[derive(Debug, PartialEq)]
pub struct ViewArgs {
    pub token: fidl_fuchsia_ui_views::ViewToken,
    pub debug_name: Option<String>,
}

impl fidl::encoding::TopLevel for ViewArgs {}

fidl_struct! {
    name: ViewArgs,
    resource: true,
    members: [
        token {
            ty: fidl_fuchsia_ui_views::ViewToken,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        debug_name {
            ty: fidl::encoding::Optional<fidl::encoding::UnboundedString>,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
/// attached to the `View` as children, and these Nodes will have the `View`s'
/// coordinate transform applied to their own, in addition to being clipped to
/// the `View`s' bounding box.
/// See `ViewProperties`.
///
/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
///
/// Usually the `View` and its associated `ViewHolder` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
///
/// Clients self-identify their `View` with a `ViewRef`, which is a stable
/// identifier that may be cloned and passed to other components in a
/// feed-forward style. It is accompanied by a `ViewRefControl`, which Scenic
/// uses to signal `View` destruction across the system; the `ViewRefControl`
/// must be unique - do not clone it.
#[derive(Debug, PartialEq)]
pub struct ViewArgs3 {
    pub token: fidl_fuchsia_ui_views::ViewToken,
    /// `control_ref.reference` must have default eventpair rights (i.e., with
    /// signaling), minus ZX_RIGHT_DUPLICATE.
    pub control_ref: fidl_fuchsia_ui_views::ViewRefControl,
    /// `view_ref.reference` must have basic rights (i.e., no signaling).
    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
    pub debug_name: Option<String>,
}

impl fidl::encoding::TopLevel for ViewArgs3 {}

fidl_struct! {
    name: ViewArgs3,
    resource: true,
    members: [
        token {
            ty: fidl_fuchsia_ui_views::ViewToken,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        control_ref {
            ty: fidl_fuchsia_ui_views::ViewRefControl,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        view_ref {
            ty: fidl_fuchsia_ui_views::ViewRef,
            resource: true,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        debug_name {
            ty: fidl::encoding::Optional<fidl::encoding::UnboundedString>,
            index: 3,
            typevar: T3,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

/// Delivered to a View's Session when the parent ViewHolder for the given View
/// becomes a part of a Scene.
///
/// A ViewHolder is considered to be part of a Scene if there is an unbroken
/// chain of parent-child relationships between the Scene node and the
/// ViewHolder node.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct ViewAttachedToSceneEvent {
    pub view_id: u32,
    pub properties: ViewProperties,
}

impl fidl::encoding::TopLevel for ViewAttachedToSceneEvent {}

fidl_struct! {
    name: ViewAttachedToSceneEvent,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        properties {
            ty: ViewProperties,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 56,
    size_v2: 56,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered to a ViewHolder's Session when its peer View is connected.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ViewConnectedEvent {
    pub view_holder_id: u32,
}

impl fidl::encoding::TopLevel for ViewConnectedEvent {}

fidl_struct! {
    copy: true,
    name: ViewConnectedEvent,
    members: [
        view_holder_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered to a View's Session when the parent ViewHolder for the given View
/// is no longer part of a scene.
///
/// This can happen if the ViewHolder is detached directly from the scene, or
/// if one of its parent nodes is.
///
/// A ViewHolder is considered to be part of a Scene if there is an unbroken
/// chain of parent-child relationships between the Scene node and the
/// ViewHolder node.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ViewDetachedFromSceneEvent {
    pub view_id: u32,
}

impl fidl::encoding::TopLevel for ViewDetachedFromSceneEvent {}

fidl_struct! {
    copy: true,
    name: ViewDetachedFromSceneEvent,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered to a ViewHolder's Session when its peer View is disconnected or
/// destroyed.
///
/// If the View is destroyed before the connection is established, then this
/// event will be delivered immediately when the ViewHolder attempts to connect.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ViewDisconnectedEvent {
    pub view_holder_id: u32,
}

impl fidl::encoding::TopLevel for ViewDisconnectedEvent {}

fidl_struct! {
    copy: true,
    name: ViewDisconnectedEvent,
    members: [
        view_holder_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Represents an attachment point for a subgraph within a larger scene graph.
/// The `ViewHolder` can be attached to a Node as a child, and the contents of
/// the linked `View` will become a child of the Node as well.
///
/// Each `ViewHolder` is linked to a paired `View` via a shared token pair.
///
/// Usually the `ViewHolder` and its associated `View` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
#[derive(Debug, PartialEq)]
pub struct ViewHolderArgs {
    pub token: fidl_fuchsia_ui_views::ViewHolderToken,
    pub debug_name: Option<String>,
}

impl fidl::encoding::TopLevel for ViewHolderArgs {}

fidl_struct! {
    name: ViewHolderArgs,
    resource: true,
    members: [
        token {
            ty: fidl_fuchsia_ui_views::ViewHolderToken,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        debug_name {
            ty: fidl::encoding::Optional<fidl::encoding::UnboundedString>,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// Delivered to a View's Session when its peer ViewHolder is connected.
///
/// If the ViewHolder is destroyed before the connection is established, then
/// this event will not be delivered.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ViewHolderConnectedEvent {
    pub view_id: u32,
}

impl fidl::encoding::TopLevel for ViewHolderConnectedEvent {}

fidl_struct! {
    copy: true,
    name: ViewHolderConnectedEvent,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered to a View's Session when its peer ViewHolder is disconnected or
/// destroyed.
///
/// If the ViewHolder is destroyed before the connection is established, then
/// this event will be delivered immediately when the View attempts to connect.
#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ViewHolderDisconnectedEvent {
    pub view_id: u32,
}

impl fidl::encoding::TopLevel for ViewHolderDisconnectedEvent {}

fidl_struct! {
    copy: true,
    name: ViewHolderDisconnectedEvent,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

/// Represents the properties for a View.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct ViewProperties {
    /// The View's bounding box extents can be defined as:
    ///    { bounding_box.min, bounding_box.max }
    /// Content contained within the View is clipped to this bounding box.
    pub bounding_box: BoundingBox,
    /// `insets_from_min` and `insets_from_max` specify the distances between the
    /// view's bounding box and that of its parent.
    ///
    /// These properties are not strictly enforced by Scenic, but only used
    /// as hints for clients and other components that receives ViewProperties:
    ///
    /// View clients can assume that anything drawn outside of
    ///    { bounding_box.min + inset_from_min, bounding_box.max - inset_from_max }
    /// may be obscured by an ancestor view. The reason for obscuring, and the rules
    /// surrounding it, is specific to each product.
    pub inset_from_min: Vec3,
    pub inset_from_max: Vec3,
    /// Whether the View can receive a focus event; default is true.  When
    /// false, and this View is eligible to receive a focus event, no
    /// focus/unfocus event is actually sent to any View.
    pub focus_change: bool,
    /// Whether the View allows geometrically underlying Views to receive input;
    /// default is true. When false, Scenic does not send input events to
    /// underlying Views.
    pub downward_input: bool,
}

impl fidl::encoding::TopLevel for ViewProperties {}

fidl_struct! {
    name: ViewProperties,
    members: [
        bounding_box {
            ty: BoundingBox,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        inset_from_min {
            ty: Vec3,
            index: 1,
            typevar: T1,
            offset_v1: 24,
            offset_v2: 24,
        },
        inset_from_max {
            ty: Vec3,
            index: 2,
            typevar: T2,
            offset_v1: 36,
            offset_v2: 36,
        },
        focus_change {
            ty: bool,
            index: 3,
            typevar: T3,
            offset_v1: 48,
            offset_v2: 48,
        },
        downward_input {
            ty: bool,
            index: 4,
            typevar: T4,
            offset_v1: 49,
            offset_v2: 49,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 48,
            mask: 0xffff0000u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 48,
            mask: 0xffff0000u32,
        },
    ],
    size_v1: 52,
    size_v2: 52,
    align_v1: 4,
    align_v2: 4,
}

/// Delivered when the parent ViewHolder for the given View makes a change to
/// the View's properties.
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct ViewPropertiesChangedEvent {
    pub view_id: u32,
    pub properties: ViewProperties,
}

impl fidl::encoding::TopLevel for ViewPropertiesChangedEvent {}

fidl_struct! {
    name: ViewPropertiesChangedEvent,
    members: [
        view_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        properties {
            ty: ViewProperties,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 56,
    size_v2: 56,
    align_v1: 4,
    align_v2: 4,
}

/// Represents the state of a View in Scenic.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ViewState {
    /// Whether the View is rendering. Default is false. Delivered to the View's
    /// corresponding ViewHolder after the View's first frame render request.
    pub is_rendering: bool,
}

impl fidl::encoding::TopLevel for ViewState {}

fidl_struct! {
    name: ViewState,
    members: [
        is_rendering {
            ty: bool,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 1,
    size_v2: 1,
    align_v1: 1,
    align_v2: 1,
}

/// Delivered to a ViewHolder's Session when its peer View's state has changed.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ViewStateChangedEvent {
    pub view_holder_id: u32,
    pub state: ViewState,
}

impl fidl::encoding::TopLevel for ViewStateChangedEvent {}

fidl_struct! {
    name: ViewStateChangedEvent,
    members: [
        view_holder_id {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        state {
            ty: ViewState,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    padding_v2: [
        {
            ty: u32,
            offset: 4,
            mask: 0xffffff00u32,
        },
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Mat4 {
    /// Column major order.
    pub matrix: [f32; 16],
}

impl fidl::encoding::TopLevel for Mat4 {}

fidl_struct! {
    name: Mat4,
    members: [
        matrix {
            ty: fidl::encoding::Array<f32, 16>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 64,
    size_v2: 64,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

impl fidl::encoding::TopLevel for Vec2 {}

fidl_struct! {
    name: Vec2,
    members: [
        x {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        y {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl fidl::encoding::TopLevel for Vec3 {}

fidl_struct! {
    name: Vec3,
    members: [
        x {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        y {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        z {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Vec4 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

impl fidl::encoding::TopLevel for Vec4 {}

fidl_struct! {
    name: Vec4,
    members: [
        x {
            ty: f32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        y {
            ty: f32,
            index: 1,
            typevar: T1,
            offset_v1: 4,
            offset_v2: 4,
        },
        z {
            ty: f32,
            index: 2,
            typevar: T2,
            offset_v1: 8,
            offset_v2: 8,
        },
        w {
            ty: f32,
            index: 3,
            typevar: T3,
            offset_v1: 12,
            offset_v2: 12,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PoseBufferProviderMarker;

impl fidl::endpoints::ProtocolMarker for PoseBufferProviderMarker {
    type Proxy = PoseBufferProviderProxy;
    type RequestStream = PoseBufferProviderRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.ui.gfx.PoseBufferProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PoseBufferProviderMarker {}

pub trait PoseBufferProviderProxyInterface: Send + Sync {
    fn r#set_pose_buffer(
        &self,
        buffer: fidl::Vmo,
        num_entries: u32,
        base_time: i64,
        time_interval: u64,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PoseBufferProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl PoseBufferProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <PoseBufferProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::Time,
    ) -> Result<PoseBufferProviderEvent, fidl::Error> {
        PoseBufferProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Sets the PoseBuffer and the parameters PoseBufferProvider will use to fill that PoseBuffer.
    /// Setting this when it is already set will replace the previously set parameters with the new
    /// parameters, which will release the provider's reference to the buffer.
    pub fn r#set_pose_buffer(
        &self,
        mut buffer: fidl::Vmo,
        mut num_entries: u32,
        mut base_time: i64,
        mut time_interval: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PoseBufferProviderSetPoseBufferRequest, false>(
            (buffer, num_entries, base_time, time_interval),
            0x548d6530be1ba6e8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct PoseBufferProviderProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for PoseBufferProviderProxy {
    type Protocol = PoseBufferProviderMarker;

    fn from_channel(inner: fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl PoseBufferProviderProxy {
    /// Create a new Proxy for PoseBufferProvider
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PoseBufferProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the PoseBufferProvider protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PoseBufferProviderEventStream {
        PoseBufferProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Sets the PoseBuffer and the parameters PoseBufferProvider will use to fill that PoseBuffer.
    /// Setting this when it is already set will replace the previously set parameters with the new
    /// parameters, which will release the provider's reference to the buffer.
    pub fn r#set_pose_buffer(
        &self,
        mut buffer: fidl::Vmo,
        mut num_entries: u32,
        mut base_time: i64,
        mut time_interval: u64,
    ) -> Result<(), fidl::Error> {
        PoseBufferProviderProxyInterface::r#set_pose_buffer(
            self,
            buffer,
            num_entries,
            base_time,
            time_interval,
        )
    }
}

impl PoseBufferProviderProxyInterface for PoseBufferProviderProxy {
    fn r#set_pose_buffer(
        &self,
        mut buffer: fidl::Vmo,
        mut num_entries: u32,
        mut base_time: i64,
        mut time_interval: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PoseBufferProviderSetPoseBufferRequest, false>(
            (buffer, num_entries, base_time, time_interval),
            0x548d6530be1ba6e8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct PoseBufferProviderEventStream {
    event_receiver: fidl::client::EventReceiver,
}

impl std::marker::Unpin for PoseBufferProviderEventStream {}

impl futures::stream::FusedStream for PoseBufferProviderEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for PoseBufferProviderEventStream {
    type Item = Result<PoseBufferProviderEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(PoseBufferProviderEvent::decode(buf)))
    }
}

#[derive(Debug)]
pub enum PoseBufferProviderEvent {}

impl PoseBufferProviderEvent {
    /// Decodes a message buffer as a [`PoseBufferProviderEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<PoseBufferProviderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <PoseBufferProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for PoseBufferProvider
pub struct PoseBufferProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

impl std::marker::Unpin for PoseBufferProviderRequestStream {}

impl futures::stream::FusedStream for PoseBufferProviderRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for PoseBufferProviderRequestStream {
    type Protocol = PoseBufferProviderMarker;
    type ControlHandle = PoseBufferProviderControlHandle;

    fn from_channel(channel: fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        PoseBufferProviderControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
        (self.inner, self.is_terminated)
    }

    fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for PoseBufferProviderRequestStream {
    type Item = Result<PoseBufferProviderRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PoseBufferProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|bytes, handles| {
            match this.inner.channel().read_etc(cx, bytes, handles) {
                std::task::Poll::Ready(Ok(())) => {}
                std::task::Poll::Pending => return std::task::Poll::Pending,
                std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                    this.is_terminated = true;
                    return std::task::Poll::Ready(None);
                }
                std::task::Poll::Ready(Err(e)) => {
                    return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x548d6530be1ba6e8 => {
                    let mut req = fidl::new_empty!(PoseBufferProviderSetPoseBufferRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.ui.gfx/PoseBufferProviderSetPoseBufferRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<PoseBufferProviderSetPoseBufferRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        PoseBufferProviderControlHandle { inner: this.inner.clone() };

                    Ok(PoseBufferProviderRequest::SetPoseBuffer {
                        buffer: req.buffer,
                        num_entries: req.num_entries,
                        base_time: req.base_time,
                        time_interval: req.time_interval,

                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <PoseBufferProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// A minimal fidl interface to allow sourcing the contents of a PoseBuffer from another service.
#[derive(Debug)]
pub enum PoseBufferProviderRequest {
    /// Sets the PoseBuffer and the parameters PoseBufferProvider will use to fill that PoseBuffer.
    /// Setting this when it is already set will replace the previously set parameters with the new
    /// parameters, which will release the provider's reference to the buffer.
    SetPoseBuffer {
        buffer: fidl::Vmo,
        num_entries: u32,
        base_time: i64,
        time_interval: u64,
        control_handle: PoseBufferProviderControlHandle,
    },
}

impl PoseBufferProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pose_buffer(
        self,
    ) -> Option<(fidl::Vmo, u32, i64, u64, PoseBufferProviderControlHandle)> {
        if let PoseBufferProviderRequest::SetPoseBuffer {
            buffer,
            num_entries,
            base_time,
            time_interval,
            control_handle,
        } = self
        {
            Some((buffer, num_entries, base_time, time_interval, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PoseBufferProviderRequest::SetPoseBuffer { .. } => "set_pose_buffer",
        }
    }
}

#[derive(Debug, Clone)]
pub struct PoseBufferProviderControlHandle {
    inner: std::sync::Arc<fidl::ServeInner>,
}

impl fidl::endpoints::ControlHandle for PoseBufferProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl PoseBufferProviderControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SnapshotCallbackDeprecatedMarker;

impl fidl::endpoints::ProtocolMarker for SnapshotCallbackDeprecatedMarker {
    type Proxy = SnapshotCallbackDeprecatedProxy;
    type RequestStream = SnapshotCallbackDeprecatedRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) SnapshotCallbackDeprecated";
}

pub trait SnapshotCallbackDeprecatedProxyInterface: Send + Sync {
    fn r#on_data(&self, data: &mut fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SnapshotCallbackDeprecatedSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl SnapshotCallbackDeprecatedSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::Time,
    ) -> Result<SnapshotCallbackDeprecatedEvent, fidl::Error> {
        SnapshotCallbackDeprecatedEvent::decode(self.client.wait_for_event(deadline)?)
    }
    pub fn r#on_data(&self, mut data: &mut fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest, false>(
            (data,),
            0x11d1a93b419b7d9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct SnapshotCallbackDeprecatedProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for SnapshotCallbackDeprecatedProxy {
    type Protocol = SnapshotCallbackDeprecatedMarker;

    fn from_channel(inner: fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl SnapshotCallbackDeprecatedProxy {
    /// Create a new Proxy for SnapshotCallbackDeprecated
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the SnapshotCallbackDeprecated protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> SnapshotCallbackDeprecatedEventStream {
        SnapshotCallbackDeprecatedEventStream { event_receiver: self.client.take_event_receiver() }
    }
    pub fn r#on_data(&self, mut data: &mut fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        SnapshotCallbackDeprecatedProxyInterface::r#on_data(self, data)
    }
}

impl SnapshotCallbackDeprecatedProxyInterface for SnapshotCallbackDeprecatedProxy {
    fn r#on_data(&self, mut data: &mut fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest, false>(
            (data,),
            0x11d1a93b419b7d9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct SnapshotCallbackDeprecatedEventStream {
    event_receiver: fidl::client::EventReceiver,
}

impl std::marker::Unpin for SnapshotCallbackDeprecatedEventStream {}

impl futures::stream::FusedStream for SnapshotCallbackDeprecatedEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for SnapshotCallbackDeprecatedEventStream {
    type Item = Result<SnapshotCallbackDeprecatedEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(SnapshotCallbackDeprecatedEvent::decode(buf)))
    }
}

#[derive(Debug)]
pub enum SnapshotCallbackDeprecatedEvent {}

impl SnapshotCallbackDeprecatedEvent {
    /// Decodes a message buffer as a [`SnapshotCallbackDeprecatedEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(
        mut buf: fidl::MessageBufEtc,
    ) -> Result<SnapshotCallbackDeprecatedEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            })
        }
    }
}

/// A Stream of incoming requests for SnapshotCallbackDeprecated
pub struct SnapshotCallbackDeprecatedRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

impl std::marker::Unpin for SnapshotCallbackDeprecatedRequestStream {}

impl futures::stream::FusedStream for SnapshotCallbackDeprecatedRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for SnapshotCallbackDeprecatedRequestStream {
    type Protocol = SnapshotCallbackDeprecatedMarker;
    type ControlHandle = SnapshotCallbackDeprecatedControlHandle;

    fn from_channel(channel: fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        SnapshotCallbackDeprecatedControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
        (self.inner, self.is_terminated)
    }

    fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for SnapshotCallbackDeprecatedRequestStream {
    type Item = Result<SnapshotCallbackDeprecatedRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled SnapshotCallbackDeprecatedRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|bytes, handles| {
            match this.inner.channel().read_etc(cx, bytes, handles) {
                std::task::Poll::Ready(Ok(())) => {}
                std::task::Poll::Pending => return std::task::Poll::Pending,
                std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                    this.is_terminated = true;
                    return std::task::Poll::Ready(None);
                }
                std::task::Poll::Ready(Err(e)) => {
                    return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x11d1a93b419b7d9f => {
                    let mut req = fidl::new_empty!(SnapshotCallbackDeprecatedOnDataRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.ui.gfx/SnapshotCallbackDEPRECATEDOnDataRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW) {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<SnapshotCallbackDeprecatedOnDataRequest>(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = SnapshotCallbackDeprecatedControlHandle {
                        inner: this.inner.clone(),
                    };

                    Ok(SnapshotCallbackDeprecatedRequest::OnData {data: req.data,

                            control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
#[derive(Debug)]
pub enum SnapshotCallbackDeprecatedRequest {
    OnData {
        data: fidl_fuchsia_mem::Buffer,
        control_handle: SnapshotCallbackDeprecatedControlHandle,
    },
}

impl SnapshotCallbackDeprecatedRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_data(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, SnapshotCallbackDeprecatedControlHandle)> {
        if let SnapshotCallbackDeprecatedRequest::OnData { data, control_handle } = self {
            Some((data, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SnapshotCallbackDeprecatedRequest::OnData { .. } => "on_data",
        }
    }
}

#[derive(Debug, Clone)]
pub struct SnapshotCallbackDeprecatedControlHandle {
    inner: std::sync::Arc<fidl::ServeInner>,
}

impl fidl::endpoints::ControlHandle for SnapshotCallbackDeprecatedControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl SnapshotCallbackDeprecatedControlHandle {}