// 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;
|
|
// Commands that are used to modify the state of a |Session|.
|
// TODO(SCN-237): reorder Command definitions to match the order in this union.
|
union Command {
|
CreateResourceCmd create_resource;
|
ReleaseResourceCmd release_resource;
|
ExportResourceCmd export_resource;
|
ImportResourceCmd import_resource;
|
|
// Tagging commands.
|
SetTagCmd set_tag;
|
|
// Grouping commands.
|
DetachCmd detach;
|
|
// Spatial commands.
|
SetTranslationCmd set_translation;
|
SetScaleCmd set_scale;
|
SetRotationCmd set_rotation;
|
SetAnchorCmd set_anchor;
|
SetSizeCmd set_size;
|
SetOpacityCmd set_opacity;
|
|
SendSizeChangeHintCmdHACK send_size_change_hint_hack;
|
|
// Node-specific commands.
|
AddChildCmd add_child; // TODO: Should we require a DetachCmd before
|
// re-parenting?
|
AddPartCmd add_part;
|
DetachChildrenCmd detach_children;
|
SetShapeCmd set_shape;
|
SetMaterialCmd set_material;
|
SetClipCmd set_clip;
|
SetHitTestBehaviorCmd set_hit_test_behavior;
|
SetViewPropertiesCmd set_view_properties;
|
TakeSnapshotCmdHACK take_snapshot_cmd;
|
|
// Camera and lighting commands.
|
SetCameraCmd set_camera;
|
SetCameraTransformCmd set_camera_transform;
|
SetCameraProjectionCmd set_camera_projection;
|
SetStereoCameraProjectionCmd set_stereo_camera_projection;
|
SetCameraPoseBufferCmd set_camera_pose_buffer;
|
SetLightColorCmd set_light_color;
|
SetLightDirectionCmd set_light_direction;
|
AddLightCmd add_light;
|
DetachLightCmd detach_light;
|
DetachLightsCmd detach_lights;
|
|
SetTextureCmd set_texture;
|
SetColorCmd set_color;
|
|
// Mesh commands.
|
BindMeshBuffersCmd bind_mesh_buffers;
|
|
// Layer and renderer commands.
|
AddLayerCmd add_layer;
|
RemoveLayerCmd remove_layer;
|
RemoveAllLayersCmd remove_all_layers;
|
SetLayerStackCmd set_layer_stack;
|
SetRendererCmd set_renderer;
|
SetRendererParamCmd set_renderer_param;
|
|
// Events.
|
SetEventMaskCmd set_event_mask;
|
|
// Diagnostic commands.
|
SetLabelCmd set_label;
|
|
// Debugging commands.
|
SetDisableClippingCmd set_disable_clipping;
|
|
// TODO(SCN-1026): Remove this.
|
SetImportFocusCmd set_import_focus;
|
};
|
|
// Instructs the compositor to create the specified |Resource|, and to register
|
// it in a table so that it can be referenced by subsequent commands.
|
struct CreateResourceCmd {
|
// An ID that is currently not used within the session.
|
uint32 id;
|
ResourceArgs resource;
|
};
|
|
// 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.
|
struct ReleaseResourceCmd {
|
// ID of the resource to be dereferenced.
|
uint32 id;
|
};
|
|
// 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.
|
struct ExportResourceCmd {
|
uint32 id;
|
handle<eventpair> token;
|
};
|
|
// 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).
|
struct ImportResourceCmd {
|
uint32 id;
|
handle<eventpair> token;
|
ImportSpec spec;
|
};
|
|
// Maximum length for a resource label.
|
const uint32 kLabelMaxLength = 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.
|
struct SetLabelCmd {
|
uint32 id;
|
string label;
|
};
|
|
// 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.
|
struct AddChildCmd {
|
uint32 node_id;
|
uint32 child_id;
|
};
|
|
// 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.
|
struct AddPartCmd {
|
uint32 node_id;
|
uint32 part_id;
|
};
|
|
interface SnapshotCallbackHACK {
|
1: OnData(fuchsia.mem.Buffer data);
|
};
|
|
struct TakeSnapshotCmdHACK {
|
uint32 node_id;
|
SnapshotCallbackHACK callback;
|
};
|
|
// 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.
|
struct DetachCmd {
|
uint32 id;
|
};
|
|
// Detaches all of a node's children (but not its parts).
|
struct DetachChildrenCmd {
|
uint32 node_id;
|
};
|
|
// 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.
|
struct SetTagCmd {
|
uint32 node_id;
|
uint32 tag_value;
|
};
|
|
// Sets a Resource's (typically a Node's) translation.
|
//
|
// Constraints:
|
// - |id| refs a Resource with the has_transform characteristic.
|
struct SetTranslationCmd {
|
uint32 id;
|
Vector3Value value;
|
};
|
|
// Sets a Resource's (typically a Node's) scale.
|
//
|
// Constraints:
|
// - |id| refs a Resource with the has_transform characteristic.
|
struct SetScaleCmd {
|
uint32 id;
|
Vector3Value value;
|
};
|
|
// Sets a Resource's (typically a Node's) rotation.
|
//
|
// Constraints:
|
// - |id| refs a Resource with the has_transform characteristic.
|
struct SetRotationCmd {
|
uint32 id;
|
QuaternionValue value;
|
};
|
|
// Sets a Resource's (typically a Node's) anchor point.
|
//
|
// Constraints:
|
// - |id| refs a Resource with the has_transform characteristic.
|
struct SetAnchorCmd {
|
uint32 id;
|
Vector3Value value;
|
};
|
|
// 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).
|
struct SetSizeCmd {
|
uint32 id;
|
Vector2Value value;
|
};
|
|
// 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.
|
struct SendSizeChangeHintCmdHACK {
|
uint32 node_id;
|
float32 width_change_factor;
|
float32 height_change_factor;
|
};
|
|
// Sets a node's opacity.
|
//
|
// Constraints:
|
// - |node_id| refs a |Node| with the has_opacity characteristic.
|
// - |opacity| is in the range [0, 1].
|
struct SetOpacityCmd {
|
uint32 node_id;
|
float32 opacity;
|
};
|
|
// 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").
|
// TODO: add "Shape/Material Compatibility section"
|
//
|
// 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.
|
struct SetShapeCmd {
|
uint32 node_id;
|
uint32 shape_id;
|
};
|
|
// 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").
|
// TODO: add "Shape/Material Compatibility section"
|
//
|
// 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.
|
struct SetMaterialCmd {
|
uint32 node_id;
|
uint32 material_id;
|
};
|
|
// Sets/clears a node's clip.
|
//
|
// 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).
|
struct SetClipCmd {
|
uint32 node_id;
|
uint32 clip_id;
|
bool clip_to_self;
|
};
|
|
// Sets a node's hit test behavior.
|
//
|
// Discussion:
|
// By default, hit testing is performed on the node's content, its parts,
|
// and its children.
|
struct SetHitTestBehaviorCmd {
|
uint32 node_id;
|
HitTestBehavior hit_test_behavior;
|
};
|
|
// Sets the properties for a ViewHolder's attached View.
|
//
|
// Constraints:
|
// - |view_holder_id| refs a |ViewHolder|.
|
struct SetViewPropertiesCmd {
|
uint32 view_holder_id;
|
ViewProperties properties;
|
};
|
|
// 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.
|
struct SetCameraCmd {
|
uint32 renderer_id;
|
uint32 camera_id;
|
};
|
|
// 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.
|
struct SetCameraTransformCmd {
|
uint32 camera_id;
|
Vector3Value eye_position;
|
Vector3Value eye_look_at;
|
Vector3Value eye_up;
|
};
|
|
// 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.
|
struct SetCameraProjectionCmd {
|
uint32 camera_id;
|
FloatValue fovy; // 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.
|
struct SetStereoCameraProjectionCmd {
|
uint32 camera_id;
|
Matrix4Value left_projection;
|
Matrix4Value right_projection;
|
};
|
|
// 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.
|
struct SetCameraPoseBufferCmd {
|
uint32 camera_id;
|
uint32 buffer_id;
|
uint32 num_entries;
|
int64 base_time;
|
uint64 time_interval;
|
};
|
|
// Sets the color of the Light identified by |light_id|.
|
struct SetLightColorCmd {
|
uint32 light_id;
|
ColorRgbValue color;
|
};
|
|
// Sets the direction of the DirectionalLight identified by |light_id|.
|
struct SetLightDirectionCmd {
|
uint32 light_id;
|
Vector3Value direction;
|
};
|
|
// Adds the light specified by |light_id| specified by |light_id| to the scene
|
// identified by |scene_id|.
|
struct AddLightCmd {
|
uint32 scene_id;
|
uint32 light_id;
|
};
|
|
// Detach the light specified by |light_id| from the scene that it is attached
|
// to, if any.
|
struct DetachLightCmd {
|
uint32 light_id;
|
};
|
|
// Detach all lights from the scene specified by |scene_id|.
|
struct DetachLightsCmd {
|
uint32 scene_id;
|
};
|
|
// Sets/clears a material's texture.
|
//
|
// Constraints:
|
// - |material_id| refs a |Material|.
|
// - |texture_id| refs a |Image|, |ImagePipe|, 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.
|
struct SetTextureCmd {
|
uint32 material_id;
|
uint32 texture_id; // 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.
|
struct SetColorCmd {
|
uint32 material_id;
|
ColorRgbaValue color;
|
};
|
|
// 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.
|
enum MeshIndexFormat {
|
// TODO(SCN-275): only kUint32 is currently supported.
|
kUint16 = 1;
|
kUint32 = 2;
|
};
|
|
struct MeshVertexFormat {
|
// kVector2 or kVector3.
|
ValueType position_type;
|
// kVector2 or kVector3 (must match position_type), or kNone.
|
ValueType normal_type;
|
// kVector2 or kNone.
|
ValueType tex_coord_type;
|
};
|
|
struct BindMeshBuffersCmd {
|
uint32 mesh_id;
|
uint32 index_buffer_id;
|
MeshIndexFormat index_format;
|
uint64 index_offset;
|
uint32 index_count;
|
uint32 vertex_buffer_id;
|
MeshVertexFormat vertex_format;
|
uint64 vertex_offset;
|
uint32 vertex_count;
|
BoundingBox bounding_box;
|
};
|
|
// 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.
|
struct AddLayerCmd {
|
uint32 layer_stack_id;
|
uint32 layer_id;
|
};
|
|
// 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.
|
struct RemoveLayerCmd {
|
uint32 layer_stack_id;
|
uint32 layer_id;
|
};
|
|
// Remove all layers from a layer stack.
|
// Constraints
|
// - |layer_stack_id| refs a |LayerStack|.
|
struct RemoveAllLayersCmd {
|
uint32 layer_stack_id;
|
};
|
|
// Set a compositor's layer stack, replacing the current stack (if any).
|
// Constraints:
|
// - |compositor_id| refs a |DisplayCompositor| or |ImagePipeCompositor|.
|
// - |layer_stack_id| refs a |LayerStack|.
|
struct SetLayerStackCmd {
|
uint32 compositor_id;
|
uint32 layer_stack_id;
|
};
|
|
// Set a layer's renderer, replacing the current renderer (if any).
|
// Constraints:
|
// - |layer_id| refs a |Layer|.
|
// - |renderer_id| refs a |Renderer|.
|
struct SetRendererCmd {
|
uint32 layer_id;
|
uint32 renderer_id;
|
};
|
|
// 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.
|
struct SetRendererParamCmd {
|
uint32 renderer_id;
|
RendererParam param;
|
};
|
|
// 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.
|
struct SetEventMaskCmd {
|
uint32 id;
|
uint32 event_mask;
|
};
|
|
// 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.
|
struct SetDisableClippingCmd {
|
uint32 renderer_id;
|
bool disable_clipping;
|
};
|
|
// TODO(SCN-1026): Remove this.
|
struct SetImportFocusCmd {
|
uint32 id;
|
bool focusable;
|
};
|
