blob: 20675acd545286cc5de34bee0df02525d41b4f6e [file] [log] [blame]
// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
library fuchsia.ui.gfx;
using fuchsia.mem;
using zx;
/// Commands that are used to modify the state of a `Session`.
type Command = strict resource union {
1: create_resource CreateResourceCmd;
2: release_resource ReleaseResourceCmd;
3: export_resource ExportResourceCmdDeprecated;
4: import_resource ImportResourceCmdDeprecated;
/// Tagging commands.
5: set_tag SetTagCmd;
/// Grouping commands.
6: detach DetachCmd;
/// Spatial commands.
7: set_translation SetTranslationCmd;
8: set_scale SetScaleCmd;
9: set_rotation SetRotationCmd;
10: set_anchor SetAnchorCmd;
11: set_size SetSizeCmd;
12: set_opacity SetOpacityCmd;
13: send_size_change_hint_hack SendSizeChangeHintCmdHACK;
/// Node-specific commands.
14: add_child AddChildCmd; // TODO: Should we require a DetachCmd before
/// re-parenting?
15: add_part AddPartCmd;
16: detach_children DetachChildrenCmd;
17: set_shape SetShapeCmd;
18: set_material SetMaterialCmd;
19: set_clip SetClipCmd;
20: set_hit_test_behavior SetHitTestBehaviorCmd;
21: set_view_properties SetViewPropertiesCmd;
22: take_snapshot_cmd TakeSnapshotCmdDEPRECATED;
/// Camera and lighting commands.
23: set_camera SetCameraCmd;
24: set_camera_transform SetCameraTransformCmd;
25: set_camera_projection SetCameraProjectionCmd;
26: set_stereo_camera_projection SetStereoCameraProjectionCmd;
27: set_camera_pose_buffer SetCameraPoseBufferCmd;
28: set_light_color SetLightColorCmd;
29: set_light_direction SetLightDirectionCmd;
30: add_light AddLightCmd;
31: detach_light DetachLightCmd;
32: detach_lights DetachLightsCmd;
33: set_texture SetTextureCmd;
34: set_color SetColorCmd;
/// Mesh commands.
35: bind_mesh_buffers BindMeshBuffersCmd;
/// Layer and renderer commands.
36: add_layer AddLayerCmd;
37: remove_layer RemoveLayerCmd;
38: remove_all_layers RemoveAllLayersCmd;
39: set_layer_stack SetLayerStackCmd;
40: set_renderer SetRendererCmd;
41: set_renderer_param SetRendererParamCmd;
/// Events.
42: set_event_mask SetEventMaskCmd;
/// Diagnostic commands.
43: set_label SetLabelCmd;
/// Debugging commands.
44: set_disable_clipping SetDisableClippingCmd;
// TODO(fxbug.dev/24238): Remove this.
45: set_import_focus SetImportFocusCmdDEPRECATED;
// TODO(fxbug.dev/24428): Move these where they belong. They're added to the end of
// the struct temporarily until we transition to xunions.
46: set_clip_planes SetClipPlanesCmd;
47: set_point_light_position SetPointLightPositionCmd;
48: set_point_light_falloff SetPointLightFalloffCmd;
49: scene__add_ambient_light SceneAddAmbientLightCmd;
50: scene__add_directional_light SceneAddDirectionalLightCmd;
51: scene__add_point_light SceneAddPointLightCmd;
52: set_display_color_conversion SetDisplayColorConversionCmdHACK;
53: set_display_rotation SetDisplayRotationCmdHACK;
54: set_enable_view_debug_bounds SetEnableDebugViewBoundsCmd;
55: set_view_holder_bounds_color SetViewHolderBoundsColorCmd;
56: set_camera_clip_space_transform SetCameraClipSpaceTransformCmd;
57: set_display_minimum_rgb SetDisplayMinimumRgbCmdHACK;
58: set_semantic_visibility SetSemanticVisibilityCmd;
};
/// Instructs the compositor to create the specified `Resource`, and to register
/// it in a table so that it can be referenced by subsequent commands.
type CreateResourceCmd = resource struct {
/// An ID that is currently not used within the session.
id uint32;
resource ResourceArgs;
};
/// 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.
type ReleaseResourceCmd = struct {
/// ID of the resource to be dereferenced.
id uint32;
};
/// 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.
type ExportResourceCmdDeprecated = resource struct {
id uint32;
token zx.handle:EVENTPAIR;
};
/// 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).
///
// TODO: describe how the imported resource behaves if the exported resource
// isn't yet available, or becomes unavailable (e.g. an imported Material might
// act as a plain white texture).
type ImportResourceCmdDeprecated = resource struct {
id uint32;
token zx.handle:EVENTPAIR;
spec ImportSpec;
};
/// 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.
type SetTagCmd = struct {
node_id uint32;
tag_value uint32;
};
/// 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.
type DetachCmd = struct {
id uint32;
};
/// Sets a Resource's (typically a Node's) translation.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
type SetTranslationCmd = struct {
id uint32;
value Vector3Value;
};
/// Sets a Resource's (typically a Node's) scale.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
type SetScaleCmd = struct {
id uint32;
value Vector3Value;
};
/// 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.
type SetRotationCmd = struct {
id uint32;
value QuaternionValue;
};
/// Sets a Resource's (typically a Node's) anchor point.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
type SetAnchorCmd = struct {
id uint32;
value Vector3Value;
};
/// 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).
type SetSizeCmd = struct {
id uint32;
value Vector2Value;
};
/// Sets a node's opacity.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_opacity characteristic.
/// - `opacity` is in the range [0, 1].
type SetOpacityCmd = struct {
node_id uint32;
opacity float32;
};
/// 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.
type SendSizeChangeHintCmdHACK = struct {
node_id uint32;
width_change_factor float32;
height_change_factor float32;
};
/// 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.
type AddChildCmd = struct {
node_id uint32;
child_id uint32;
};
/// 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.
type AddPartCmd = struct {
node_id uint32;
part_id uint32;
};
/// Detaches all of a node's children (but not its parts).
type DetachChildrenCmd = struct {
node_id uint32;
};
// TODO: add "Shape/Material Compatibility section"
/// 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.
type SetShapeCmd = struct {
node_id uint32;
shape_id uint32;
};
// TODO: add "Shape/Material Compatibility section"
/// 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.
type SetMaterialCmd = struct {
node_id uint32;
material_id uint32;
};
/// 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.
// TODO: elaborate on the circumstances under which a clip is inapplicable.
// For example, consider a 3D space that looks through a portal into a 2D space
// that uses a clip for a circular reveal. It would not be meaningful to clip
// objects on the outside (i.e. in the 3D space).
type SetClipCmd = struct {
node_id uint32;
clip_id uint32;
clip_to_self bool;
};
/// Sets a node's hit test behavior.
///
/// Discussion:
/// By default, hit testing is performed on the node's content, its parts,
/// and its children.
type SetHitTestBehaviorCmd = struct {
node_id uint32;
hit_test_behavior HitTestBehavior;
};
/// 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.
type SetSemanticVisibilityCmd = struct {
node_id uint32;
visible bool = true;
};
/// Sets the properties for a ViewHolder's attached View.
///
/// Constraints:
/// - `view_holder_id` refs a `ViewHolder`.
type SetViewPropertiesCmd = struct {
view_holder_id uint32;
properties ViewProperties;
};
protocol SnapshotCallbackDEPRECATED {
OnData(resource struct {
data fuchsia.mem.Buffer;
});
};
type TakeSnapshotCmdDEPRECATED = resource struct {
node_id uint32;
callback client_end:SnapshotCallbackDEPRECATED;
};
/// 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.
type SetCameraCmd = struct {
renderer_id uint32;
camera_id uint32;
};
/// 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.
type SetCameraTransformCmd = struct {
camera_id uint32;
eye_position Vector3Value;
eye_look_at Vector3Value;
eye_up Vector3Value;
};
/// 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.
type SetCameraProjectionCmd = struct {
camera_id uint32;
fovy FloatValue; // Y-axis field of view, in radians.
};
/// 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.
type SetStereoCameraProjectionCmd = struct {
camera_id uint32;
left_projection Matrix4Value;
right_projection Matrix4Value;
};
/// 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.
type SetCameraClipSpaceTransformCmd = struct {
camera_id uint32;
translation vec2;
scale float32;
};
/// 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.
type SetCameraPoseBufferCmd = struct {
camera_id uint32;
buffer_id uint32;
num_entries uint32;
base_time int64;
time_interval uint64;
};
/// Sets the color of the Light identified by `light_id`.
type SetLightColorCmd = struct {
light_id uint32;
color ColorRgbValue;
};
/// Sets the direction of the DirectionalLight identified by `light_id`.
type SetLightDirectionCmd = struct {
light_id uint32;
direction Vector3Value;
};
/// DEPRECATED
/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
type AddLightCmd = struct {
scene_id uint32;
light_id uint32;
};
/// Detach the light specified by `light_id` from the scene that it is attached
/// to, if any.
type DetachLightCmd = struct {
light_id uint32;
};
/// Detach all lights from the scene specified by `scene_id`.
type DetachLightsCmd = struct {
scene_id uint32;
};
/// 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.
type SetTextureCmd = struct {
material_id uint32;
texture_id uint32; // Refers to an Image resource. May be zero (no texture).
};
/// 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.
type SetColorCmd = struct {
material_id uint32;
color ColorRgbaValue;
};
/// 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.
type MeshIndexFormat = strict enum {
// TODO(fxbug.dev/23519): only kUint32 is currently supported.
kUint16 = 1;
kUint32 = 2;
};
type MeshVertexFormat = struct {
/// kVector2 or kVector3.
position_type ValueType;
/// kVector2 or kVector3 (must match position_type), or kNone.
normal_type ValueType;
/// kVector2 or kNone.
tex_coord_type ValueType;
};
type BindMeshBuffersCmd = struct {
mesh_id uint32;
index_buffer_id uint32;
index_format MeshIndexFormat;
index_offset uint64;
index_count uint32;
vertex_buffer_id uint32;
vertex_format MeshVertexFormat;
vertex_offset uint64;
vertex_count uint32;
bounding_box BoundingBox;
};
/// 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.
type AddLayerCmd = struct {
layer_stack_id uint32;
layer_id uint32;
};
/// 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.
type RemoveLayerCmd = struct {
layer_stack_id uint32;
layer_id uint32;
};
/// Remove all layers from a layer stack.
/// Constraints
/// - `layer_stack_id` refs a `LayerStack`.
type RemoveAllLayersCmd = struct {
layer_stack_id uint32;
};
/// Set a compositor's layer stack, replacing the current stack (if any).
/// Constraints:
/// - `compositor_id` refs a `DisplayCompositor`.
/// - `layer_stack_id` refs a `LayerStack`.
type SetLayerStackCmd = struct {
compositor_id uint32;
layer_stack_id uint32;
};
/// Set a layer's renderer, replacing the current renderer (if any).
/// Constraints:
/// - `layer_id` refs a `Layer`.
/// - `renderer_id` refs a `Renderer`.
type SetRendererCmd = struct {
layer_id uint32;
renderer_id uint32;
};
/// 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.
type SetRendererParamCmd = struct {
renderer_id uint32;
param RendererParam;
};
/// 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.
type SetEventMaskCmd = struct {
id uint32;
event_mask uint32;
};
/// Maximum length for a resource label.
const kLabelMaxLength uint32 = 32;
/// 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.
type SetLabelCmd = struct {
id uint32;
label string;
};
/// 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.
type SetDisableClippingCmd = struct {
renderer_id uint32;
disable_clipping bool;
};
// TODO(fxbug.dev/24238): Remove this.
type SetImportFocusCmdDEPRECATED = struct {};
/// 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.
type SetClipPlanesCmd = struct {
node_id uint32;
clip_planes vector<Plane3>;
};
/// Sets the position of the PointLight identified by `light_id`.
type SetPointLightPositionCmd = struct {
light_id uint32;
position Vector3Value;
};
/// 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.
///
// TODO(fxbug.dev/23755): need to formalize the units of light intensity and distance used
// to compute fall-off. Currently the unit is pips; consequently a falloff of 1.0
// causes light to attenuate far too rapidly. Meters would be more appropriate.
type SetPointLightFalloffCmd = struct {
light_id uint32;
falloff FloatValue;
};
/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
type SceneAddAmbientLightCmd = struct {
scene_id uint32;
light_id uint32;
};
/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
type SceneAddDirectionalLightCmd = struct {
scene_id uint32;
light_id uint32;
};
/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
type SceneAddPointLightCmd = struct {
scene_id uint32;
light_id uint32;
};
/// 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]
type SetDisplayColorConversionCmdHACK = struct {
compositor_id uint32;
preoffsets array<float32, 3>;
matrix array<float32, 9>;
postoffsets array<float32, 3>;
};
/// 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.
type SetDisplayRotationCmdHACK = struct {
compositor_id uint32;
rotation_degrees uint32;
};
// Enable (or disable) debug wireframe rendering for the specified
// view and its immediately embedded views (i.e. any view whose
// nearest ancestor view is this one).
type SetEnableDebugViewBoundsCmd = struct {
view_id uint32;
enable bool;
};
// This command determines the color to be set on a view holders
// debug wireframe bounding box.
type SetViewHolderBoundsColorCmd = struct {
view_holder_id uint32;
color ColorRgbValue;
};
// This command sets the minimum RGB value for all displays, which
// all pixel values are clamped to.
type SetDisplayMinimumRgbCmdHACK = struct {
min_value uint8;
};