// 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;
|
|
struct vec2 {
|
float32 x;
|
float32 y;
|
};
|
|
struct vec3 {
|
float32 x;
|
float32 y;
|
float32 z;
|
};
|
|
struct vec4 {
|
float32 x;
|
float32 y;
|
float32 z;
|
float32 w;
|
};
|
|
struct mat4 {
|
// Column major order.
|
array<float32>:16 matrix;
|
};
|
|
// TODO(MZ-238): use float32s instead of uint8.
|
struct ColorRgba {
|
uint8 red;
|
uint8 green;
|
uint8 blue;
|
uint8 alpha;
|
};
|
|
struct ColorRgb {
|
float32 red;
|
float32 green;
|
float32 blue;
|
};
|
|
struct Quaternion {
|
float32 x;
|
float32 y;
|
float32 z;
|
float32 w;
|
};
|
|
struct FactoredTransform {
|
vec3 translation;
|
vec3 scale;
|
// Point around which rotation and scaling occur.
|
vec3 anchor;
|
Quaternion rotation;
|
};
|
|
union Value {
|
float32 vector1;
|
vec2 vector2;
|
vec3 vector3;
|
vec4 vector4;
|
mat4 matrix4x4;
|
ColorRgba color_rgba;
|
ColorRgb color_rgb;
|
// Degrees of counter-clockwise rotation in the XY plane.
|
float32 degrees;
|
Quaternion quaternion;
|
FactoredTransform transform;
|
// ID of a value-producing resource (an animation or an expression).
|
// The type of this value matches the type produced by the named resource.
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct FloatValue {
|
float32 value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct Vector2Value {
|
vec2 value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct Vector3Value {
|
vec3 value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct Vector4Value {
|
vec4 value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct Matrix4Value {
|
mat4 value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct ColorRgbValue {
|
ColorRgb value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct ColorRgbaValue {
|
ColorRgba value;
|
uint32 variable_id;
|
};
|
|
// 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.
|
struct QuaternionValue {
|
Quaternion value;
|
uint32 variable_id;
|
};
|
|
enum ValueType {
|
kNone = 0;
|
kVector1 = 1;
|
kVector2 = 2;
|
kVector3 = 3;
|
kVector4 = 4;
|
kMatrix4 = 5;
|
kColorRgb = 6;
|
kColorRgba = 7;
|
kQuaternion = 8;
|
kFactoredTransform = 9;
|
};
|
|
// Describes how nodes interact with hit testings.
|
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;
|
};
|
|
// Rendering target metrics associated with a node.
|
// See also |MetricsEvent|.
|
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.
|
float32 scale_x;
|
float32 scale_y;
|
float32 scale_z;
|
};
|
|
// 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.
|
struct BoundingBox {
|
vec3 min;
|
vec3 max;
|
};
|
|
// Represents the properties for a View.
|
struct ViewProperties {
|
// The View's bounding box extents can be defined as:
|
// { bounding_box.min - inset_from_min, bounding_box.max + inset_from_max }
|
// Content contained within the View is clipped to this bounding box.
|
//
|
// TODO(SCN-819): should we just have a vec3 extent instead of a bounding box
|
// with a potentially non-zero min?
|
BoundingBox bounding_box;
|
|
// |insets_from_min| and |insets_from_max| specify the distances between the
|
// view's bounding box and that of its parent.
|
vec3 inset_from_min;
|
vec3 inset_from_max;
|
|
// 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.
|
bool focus_change = true;
|
|
// Whether the View allows geometrically underlying Views to receive input;
|
// default is true. When false, Scenic does not send input events to
|
// underlying Views.
|
bool downward_input = true;
|
};
|
|
// Represents the state of a View in Scenic.
|
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.
|
bool is_rendering;
|
};
|
