261 lines
7.6 KiB
Plaintext
261 lines
7.6 KiB
Plaintext
// 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.images;
|
|
|
|
// These are all of the types of resources that can be created within a
|
|
// |Session|.
|
|
union ResourceArgs {
|
|
// Memory resources.
|
|
MemoryArgs memory;
|
|
ImageArgs image;
|
|
ImagePipeArgs image_pipe;
|
|
BufferArgs buffer;
|
|
|
|
// Views.
|
|
ViewArgs view;
|
|
ViewHolderArgs view_holder;
|
|
|
|
// Shapes (see shapes.fidl).
|
|
RectangleArgs rectangle;
|
|
RoundedRectangleArgs rounded_rectangle;
|
|
CircleArgs circle;
|
|
MeshArgs mesh;
|
|
|
|
// Nodes (see nodes.fidl).
|
|
ShapeNodeArgs shape_node;
|
|
ClipNodeArgs clip_node;
|
|
EntityNodeArgs entity_node;
|
|
OpacityNodeArgs opacity_node;
|
|
|
|
// Materials.
|
|
MaterialArgs material;
|
|
|
|
// Layers.
|
|
CompositorArgs compositor;
|
|
DisplayCompositorArgs display_compositor;
|
|
ImagePipeCompositorArgs image_pipe_compositor;
|
|
LayerStackArgs layer_stack;
|
|
LayerArgs layer;
|
|
|
|
// Scene representation and display.
|
|
SceneArgs scene;
|
|
CameraArgs camera;
|
|
StereoCameraArgs stereo_camera;
|
|
RendererArgs renderer;
|
|
|
|
// Lighting.
|
|
AmbientLightArgs ambient_light;
|
|
DirectionalLightArgs directional_light;
|
|
|
|
// A value that can be used in place of a constant value.
|
|
VariableArgs variable;
|
|
};
|
|
|
|
struct ImagePipeArgs {
|
|
request<fuchsia.images.ImagePipe> image_pipe_request;
|
|
};
|
|
|
|
// |Memory| is a |Resource| that wraps a client-provided Zircon vmo to register
|
|
// it with Scenic.
|
|
// TODO: specify resizing behavior. Who can resize? Client/Scenic/both/none?
|
|
struct MemoryArgs {
|
|
// The VMO which backs this memory.
|
|
handle<vmo> vmo;
|
|
|
|
// The amount of memory from |vmo| that should be utilized.
|
|
uint64 allocation_size;
|
|
|
|
// The type of memory stored in the VMO, namely whether it's GPU memory or
|
|
// host memory.
|
|
fuchsia.images.MemoryType memory_type;
|
|
};
|
|
|
|
// An image mapped to a range of a |Memory| resource.
|
|
// TODO: more precise and extensive docs.
|
|
struct ImageArgs {
|
|
fuchsia.images.ImageInfo info;
|
|
|
|
uint32 memory_id; // id of a |Memory| resource
|
|
uint32 memory_offset; // byte offset of image within |Memory| resource
|
|
};
|
|
|
|
// A buffer mapped to a range of |Memory|.
|
|
struct BufferArgs {
|
|
uint32 memory_id; // id of a |Memory| resource
|
|
uint32 memory_offset; // byte offset of buffer within |Memory| resource
|
|
uint32 num_bytes;
|
|
};
|
|
|
|
// Represents a transform space which serves as a container for Nodes. The
|
|
// Nodes will have the Views' coordinate transform applied to their own, in
|
|
// addition to being clipped to the Views' bounding box.
|
|
// See |ViewProperties|.
|
|
//
|
|
// Each View is linked to a paired ViewHolder via a shared token.
|
|
//
|
|
// Usually the View and its associated ViewHolder exist in separate processes,
|
|
// allowing a distributed scene graph to be constructed.
|
|
struct ViewArgs {
|
|
handle<eventpair> token;
|
|
string? debug_name;
|
|
};
|
|
|
|
// Represents a proxy for a View which can be added to a scene graph in order
|
|
// to embed the View within it.
|
|
//
|
|
// Each ViewHolder is linked to a paired View via a shared token.
|
|
//
|
|
// Usually the ViewHolder and its associated View exist in separate processes,
|
|
// allowing a distributed scene graph to be constructed.
|
|
struct ViewHolderArgs {
|
|
handle<eventpair> token;
|
|
string? debug_name;
|
|
};
|
|
|
|
// A Compositor draws its |LayerStack| into a framebuffer provided by its
|
|
// attached |Display|, if any. If no display is attached, nothing is rendered.
|
|
// TODO(SCN-452): there is currently no way to create/attach a display.
|
|
struct CompositorArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// A DisplayCompositor draws its attached |LayerStack| into an image that is
|
|
// presented on a display.
|
|
struct DisplayCompositorArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// An ImagePipeCompositor draws its attached |LayerStack| into an image that is
|
|
// presented on an image-pipe.
|
|
struct ImagePipeCompositorArgs {
|
|
fuchsia.images.ImagePipe target;
|
|
};
|
|
|
|
// 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
|
|
struct LayerStackArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// 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
|
|
//
|
|
// A layer is not drawn unless it has a camera, texture, or color.
|
|
struct LayerArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// A Scene is the root of a scene-graph, and defines the rendering environment
|
|
// (lighting, etc.) for the tree of nodes beneath it. The following commands
|
|
// may be applied to a Scene (public/fidl/fuchsia.ui.gfx/commands.fidl):
|
|
// - Add/RemoveLight
|
|
// - AddChild
|
|
struct SceneArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// 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 operations
|
|
// may be applied to a Camera (see ops.fidl):
|
|
// - SetCameraTransform
|
|
// - SetCameraProjection
|
|
// - SetCameraPoseBuffer
|
|
struct CameraArgs {
|
|
// The scene that the camera is viewing.
|
|
uint32 scene_id;
|
|
};
|
|
|
|
// A StereoCamera is a Camera that renders the scene in side-by-side stereo.
|
|
// The following operations may be applied to a StereoCamera but not a Camera:
|
|
// - SetStereoCameraProjection
|
|
// Additionally, any operation which can be applied to a Camera can also be
|
|
// applied to a StereoCamera.
|
|
struct StereoCameraArgs {
|
|
// The scene that the camera is viewing.
|
|
uint32 scene_id;
|
|
};
|
|
|
|
// A Renderer renders a Scene via a Camera. The following operations may be
|
|
// applied to a Renderer (see ops.fidl):
|
|
// - SetCamera
|
|
// - SetRendererParam
|
|
struct RendererArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// An AmbientLight is a Light that is is assumed to be everywhere in the scene,
|
|
// in all directions.
|
|
//
|
|
// The following commands may be applied to an AmbientLight
|
|
// (public/fidl/fuchsia.ui.gfx/commands.fidl):
|
|
// - SetLightColor
|
|
struct AmbientLightArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// 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.
|
|
//
|
|
// The following commands may be applied to a DirectionalLight
|
|
// (public/fidl/fuchsia.ui.gfx/commands.fidl):
|
|
// - SetLightColor
|
|
// - SetDirection
|
|
struct DirectionalLightArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
// Simple texture-mapped material.
|
|
//
|
|
// Commands that can be performed later:
|
|
// SetTextureCmd will set the texture, or it can be left as zero (no
|
|
// texture).
|
|
// The texture can be an Image or ImagePipe.
|
|
// SetColorCmd will set the color.
|
|
struct MaterialArgs {
|
|
// TODO(SCN-694): Clean up dummy args.
|
|
uint32 dummy = 0;
|
|
};
|
|
|
|
struct VariableArgs {
|
|
ValueType type;
|
|
Value initial_value; // Must match type. Must not be a variable_id.
|
|
};
|
|
|
|
// 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".
|
|
enum ImportSpec {
|
|
NODE = 0;
|
|
};
|