An interactable component with a composable feature set.

Used to handle general interaction.

Used to set a cooldown when interacted.

Used to set a cooldown per agent when interacted.

Used to set an interaction duration.

Used to set a limit of times to interact.

Camera body settings, e.g. sensor/film settings, shutter speed, etc

Represents the physical body, lens of the camera and other cinematographic qualities, such as sensor size, aspect ratio lock/constraint, focal length, focus distance, post-process settings, etc.

Responsible for selecting a camera and blending when the active camera changes. Also allows global settings to be shared between different cameras (such as post process settings) and modifications to the final blended camera state, such as camera shakes

Camera lens settings

Modifier stack for camera state.

Base class for objects that can modify camera state.

Controls how a camera mode transitions to another

Configurable blend between two camera modes

Instantly snap to target mode

Linear blend between camera modes

Camera mode blend that uses the smoothstep function to blend between the two camera modes

Camera mode blend that uses the smootherstep function to blend between the two camera modes

Configurable blend between two camera modes

Simple orthographic camera.

Simple perspective camera.

Camera that is physically based, determining its view properties in a manner more consistent with a physical camera

A modifier of skeletons, used to animate meshes using skeletal animation

Skeletons are collections of bones & sets/chains

An easing function combined with a relative time window

A capsule_light_component emits light in all directions into the scene from a capsule shaped source with a specified radius and length. A radius and length of 0 makes it a point light. You can use these to simulate any kind of light sources that emit in all directions and need an elongated source shape, such as a long light bulb.

A directional_light_component simulates light that is being emitted from a source that is infinitely far away. This means that all shadows cast by this light will be parallel, making this the ideal choice for simulating sunlight.

Base class for light components in the SceneGraph.

Dependencies:

• transform_component on the entity positions the light.

Examples of components implementing light_component:

• directional_light_component
• capsule_light_component
• sphere_light_component
• rect_light_component
• spot_light_component

Used to render a mesh at the location of this entity. A mesh is a set of polygons that can be used to represent shapes in the world such as:

• foliage and terrain decorations
• movers (for example, doors and lifts)
• procedurally created buildings

Dependencies:

• transform_component on the entity positions the mesh.

Used to spawn a particle_system at the location of this entity. The particle_system will simulate while the particle_system_component is in the scene.

Dependencies:

• transform_component on the entity positions the particle_system.

A rect_light_component emits light into the scene from a rectangular plane with a specified width and height. You can use these to simulate any kind of light sources that have rectangular areas, such as televisions or monitor screens, overhead lighting fixtures, or wall sconces.

A sphere_light_component emits light in all directions into the scene from a spherical source shape with a specified radius. A radius of 0 makes it a point light. You can use these to simulate any kind of light sources that emit in all directions, such as a light bulb.

A spot_light_component emits light from a single point in a cone shape. The shape of the light is defined by two cones: the InnerConeAngleDegrees and OuterConeAngleDegrees. Within the InnerConeAngleDegrees the light achieves full brightness. As you go from the extent of the inner radius to the extents of the OuterConeAngleDegrees a falloff takes place, creating a penumbra, or softening around the spot_light_component's disc of illumination. The Radius of the light defines the length of the cones. More simply, this will work like a flash light or stage can light.

A range with a minimum and maximum value. For a value to fall inside of this range, the min value must be less than or equal to the max value.

Every volume has a collision channel as part of its collision_profile. It is used to determine how two volumes interact. See collision_profile.

A collision profile determines how a volume interacts with other volumes for Overlap queries, Sweep queries, and physics simulation. When two volumes are being tested to see how they interact, the algorithm looks like this: GetInteraction(A:collision_profile, B:collision_profile):collision_interaction = InteractionA = B.GetChannelInteraction(A.Channel) InteractionB = A.GetChannelInteraction(B.Channel) return Min(InteractionA, InteractionB)

The results of an overlap query. See entity.FindOverlapHits(). We will get one overlap_hit for each intersection of any volume in SourceVolumes with any other volume.

The results of a sweep query. See entity.FindSweepHits(). We will get one sweep_hit for each intersection of any volume in SourceVolumes with any other volume.

Collision Volumes represent the collision shapes of meshes. They can be detected by Overlap and Sweep queries and generate collisions in the physics simulation.

Base class for collision_volumes that consist of a single volume with a single collision_profile and collision_material for the whole volume. This covers most volume types used in queries and physics, except compound types like a mesh. A query will always return an element rather than a general volume. For example when colliding with a mesh, the element will be a collision_triangle, which is a collision_element and has a single material, rather than a collision_triangle_mesh, which is not an element and has a material palette.

A collision capsule aligned along the Z axis.

A collision sphere.

A collision point.

An axis-aligned collision box.

Base class for authoring logic and data in the SceneGraph. Using components you can author re-usable building blocks of logic and data which can then be added to entities in the scene.

Components are a very low level building block which can be used in many ways. For example:

• Exposing engine level concepts like mesh or sound
• Adding gameplay capabilities like damage or interaction
• Storing an inventory for a character in the game

As components are generic there is no specific way that they must be used. It is up to the needs of your experience if you use one big game component or if you break up logic into many small components.

Classes deriving from component must also specify <final_super> to be added to entities. This ensures the class will always derive directly from component. Further subclassing of the initial derived component is allowed and does not require specifying <final_super> on the derived classes.

Only one instance of a component from each subclass group can be added to an entity at a time. For example, given this group of components, only one light_component can exist on a single entity. To create multiple lights you should use multiple entities.

light_component := class(component){} capsule_light_component := class(light_component){} directional_light_component := class(light_component){} spot_light_component := class(light_component){} sphere_light_component := class(light_component){} rect_light_component := class(light_component){}

============================================================================== Component Lifetime

Components move through a series of lifetime functions as they are added to entities, added to the scene, and begin running in the simulation. Components should override these methods to perform setup and run their simulation.

As a component shuts down it will then move through shutdown version of these functions, giving users the opportunity to clean up any retained state on the component before it is disposed . Lifetime Methods: OnAddedToScene OnBeginSimulation -> OnSimulate OnEndSimulation OnRemovingFromScene ==============================================================================

Entities are the base object in the SceneGraph.

• Objects in experiences are constructed of one or more entities.
• Entities are hierarchical. You can query your parent using GetParent and add child entities using AddEntities.
• Behavior is added to entities through components. You can add new components using AddComponents.
• The structure and content of entities is dynamic and be changed at any time through your experience

  .

  Deriving from entity

In the SceneGraph system a class that derives from entity is also known as a prefab. Prefabs are useful when you want to spawn/re-use a collection of entities and components many times within your game. Primarily prefabs are authored through the editor, with their Verse classes generated as part of the build into the projects Assets.digest.verse file.

While you can create base prefabs for common game object types like a vehicle or character, we highly recommended that you do not add code directly to the entity class, and instead keep logic in components. Keeping logic and data in components allows you to restructure your prefabs throughout production of your experience, without needing to massively refactor your class structure.

Reference type to editor defined prefab. Only generated digest code should reference this type.

Component that holds an icon for an entity.

class to provide alternative origin to the 'transform_component' as an entity

Rarity may be used by gameplay and presentation systems to classify and rank things.

Component that denotes the rarity of an entity.

A component that when attached to an entity allows for it to merge or 'stack' with other entities with compatible components.

Describes discrete phases of a frame update. Subscribe to members of the tick_events object to run code before or after the physics system has updated your object, allowing you to affect or react to these updates.

Stores the transforms for an entity, which are used to position the entity.

Users to subscribe to, or await on, a DeltaTime based callback from one of the phases in a component's TickEvents object.

Interface for classes that own a camera modifier stack.

Interface used to trigger easing behaviors

An event which can be sent through the scene graph.

Interface to provide alternative origin to an entity which is defaulted to its parent. See transform_component

Merge Rules Interface. Implemented by components that want to participate in entity mergeability checks.

Controls how a camera mode transitions to another

Entity client streaming modes

Child entities client streaming modes

Specifies how a collision volume pair should interact. See collision_profile.