stride3d.stride-docs/en/manual/glossary/index.md

Glossary

• Stride: A C# game engine for creating 2D/3D games and visualizations.
• Stride Community Toolkit: A collection of extensions and helpers for the Stride engine.
• Code-Only: A feature of the toolkit that allows you to create a game without using the Game Studio.

Animation terms

• Additive animation: Blends an animation additively onto a base pose.
• Animation: Moving or changing values of objects over time, typically applied to models, lights, or component properties.
• Animation clip: A timeline containing curves and keyframes that animate values over a defined duration.
• Animation curve: A function describing how a value changes over time; composed of keyframes and an interpolation mode.
• Blend tree: Logic that blends multiple animations based on parameters.
• Custom blend trees: Complex blending graphs that combine multiple clips.
• Import animations: Bring animations from DCC tools into Stride.
• Keyframe: A time/value sample on a curve.
• Model node links: Link animation channels to specific nodes in a model.
• Preview animations: Inspect and debug clips in the editor.
• Procedural animation: Animation generated at runtime via code rather than authored keyframes.
• Set up animations: Assign clips and configure animation components.
• Skeleton / rig: A hierarchy of bones used to pose and animate skinned models.

Asset terms

• Archetype: A template for asset properties that other assets can inherit from.
• Asset: Content used by the game (models, textures, materials, scripts, etc.) managed by the asset pipeline.
• Asset URL: The path used in code to load an asset, for example with Content.Load<T>("MyFolder/MyAsset"). See Create a model from code and Create a script.
• Asset bundles: Groups of assets packaged for deployment/streaming.
• Asset control: Control asset loading, references, and lifetime.
• Build pipeline: Compiles assets into runtime-ready formats.
• Prefab: A reusable entity hierarchy that can be instantiated at design time or runtime.
• Root asset: An asset included in the build so it is available at runtime. See Manage assets.

Audio terms

• Audio emitter: A component that plays sounds in 3D space.
• Audio listener: Represents the listener position/orientation used for spatial audio.
• Doppler effect: Pitch shift proportional to relative velocity between emitter and listener.
• Global audio settings: Project-wide audio configuration.
• Non-spatialized audio: 2D audio that does not attenuate with distance.
• Spatialized audio: Audio that changes with distance and direction; can use HRTF for realism.
• Stream audio: Play long audio from disk instead of preloading.

Core terms

• Delta Time: The time elapsed between frames, used for frame-independent movement.
• Frame rate: The number of frames rendered per second (FPS).
• GameTime: Time information passed to the game loop.
• Vector3: A 3D vector representing a point or direction.

Editor terms

• Add entities: Create new entities in a scene.
• Archetypes: Share default properties across assets.
• Asset View: Panel used to manage assets in your project.
• Create assets: Create and organize project assets.
• Game settings: Project-wide defaults such as the graphics compositor and rendering options.
• Graphics compositor editor: Node-based editor to configure the rendering pipeline.
• Manage entities: Select, group, and organize entities.
• Manage scenes: Open, set defaults, and load/unload scenes.
• Navigate the Scene Editor: Viewport navigation and controls.
• Property Grid: Panel used to view and edit properties of selected entities/components.
• Scene Editor: The 3D/2D viewport for arranging entities in a scene.
• Splash screen: Configure startup visuals.
• Use assets: Reference and place assets in scenes.
• World units: Scene scale conventions (unit size, conversions).

General terms

• ECS (Entity Component System): The architecture where entities host components and systems process them.
• Entity: An object in the scene that can represent anything from a 3D model to a camera or light and aggregates multiple components.
• Entity component: A piece of data/behavior attached to an entity (for example Transform, Model, Light).
• Game: A Stride application or interactive experience running the game loop.
• Game loop: The main loop that updates and renders the game each frame.
• Scene: The container for entities, defining the game world or environment.
• Transform: Defines an entity's position, rotation, and scale in the scene.

Graphics terms

• 3D primitive: A basic geometric mesh such as a cube, sphere, or cylinder.
• Camera: Captures the scene from a perspective or orthographic view.
• Camera slot: Binds scene cameras to the graphics compositor.
• Debug renderers: On-screen debug drawings (lines, shapes, labels).
• Effects and shaders: Shader authoring and customization for rendering.
• Graphics compositor: Organizes how scenes are rendered, including cameras, render targets, and post effects.
• Material: Defines how a surface is shaded (color, textures, and lighting response).
• Mesh: Geometry to render, defined by vertex and optionally index buffers.
• Model: A container of one or more meshes and a list of materials.
• Pipeline state: Input layout, primitive type, shaders, and states used for a draw.
• Post effects: Image effects (bloom, color grading, etc.) applied after scene rendering.
• Procedural Model: A model built at runtime from generated meshes (e.g., via built-in geometric primitives or custom vertex/index buffers) rather than imported as an asset. See also Create a model from code and Draw vertices.
• Render groups and masks: Filter which objects render in each pass.
• Render texture: A texture that receives the output of a camera or rendering pass.
• Resource binding: Bind textures/buffers and constants to shaders.
• Scene renderers: Components that draw the scene (for example forward renderer, debug renderer).
• Skybox: A background using a cubemap or 360° panorama to simulate distant surroundings.
• SpriteBatch: Batched 2D drawing of sprites.
• SpriteFont: Fonts for drawing text in 2D/3D with SpriteBatch.
• Vertex buffer / index buffer / primitive type: Low-level geometry data and topology used to render meshes.

Post-effect terms

• Ambient occlusion: Screen-space occlusion to enhance contact shadows.
• Anti-aliasing: Techniques to smooth jagged edges.
• Bloom: Glow effect from bright areas.
• Bright filter: Extract bright regions for bloom/compositing.
• Depth of field: Simulates camera focus blur.
• Lens flare: Light artifacts caused by bright sources.
• Light streaks: Streaking effect from bright lights.
• Local reflections: Screen-space reflections for shiny surfaces.
• Tone mapping: Map HDR values to displayable range.

Input terms

• Gamepads: Controller input support and mapping.
• Gestures: Touch gesture detection.
• Keyboards: Keyboard input handling.
• Mouse: Mouse input handling.
• Pointers: Unified pointer input across devices.
• Sensors: Device sensors like accelerometers and gyroscopes.
• Virtual buttons: Map multiple physical inputs to actions.

Lighting terms

• Ambient light: Uniform lighting applied across the scene.
• Directional light: Light from a distant source with parallel rays (e.g., sunlight).
• Light probes: Sampled lighting information used for indirect lighting.
• Point light: Light that radiates from a point in all directions.
• Shadows: Techniques to render occlusion from lights.
• Skybox light: Image-based lighting derived from a skybox.
• Spot light: Light that radiates within a cone.
• Voxel cone tracing GI: Real-time global illumination technique.

Navigation terms

• Dynamic navigation: Runtime updates to navigation data.
• Navigation bounding boxes: Volumes defining navigation constraints.
• Navigation components: Components that enable navigation behaviors.
• Navigation groups: Layers/groups to partition navigation.
• Navigation meshes: Walkable areas computed from scene geometry.

Particles terms

• Emitters: Particle sources that spawn particles over time.
• Initializers: Set initial particle properties when spawned.
• Materials (particles): Materials used for rendering particles.
• Ribbons and trails: Ribbon/trail rendering driven by particles.
• Shapes: Spawn shapes for emitters (sphere, cone, box, etc.).
• Spawners: Control particle spawn rates and bursts.
• Updaters: Modify particle properties over their lifetime.

Performance terms

• Profiler: A tool that monitors performance metrics like frames per second (FPS) and memory usage.

Physics terms

• Bepu Physics: The preferred physics engine for Stride, providing advanced Bepu physics simulation capabilities.
• BodyComponent: The runtime component for dynamic bodies (API reference).
• Character: Specialized collider and controller for player or NPC movement.
• Collidable: Base component category for physics objects (statics, bodies, characters).
• Collider shapes: Primitive and complex shapes that define collision bounds.
• Collision layers and groups: Settings that filter which objects can collide with each other.
• Constraints: Joints and limits connecting physics objects.
• Impulse: An instantaneous change in momentum applied to a rigid body.
• Kinematic body: Animated or code-driven colliders that affect others but are not affected by forces.
• Movement
  • Non-physical movement: Moving entities by directly changing their position without physics interactions.
  • Physics-based movement: Moving entities using the physics engine to simulate realistic interactions.
• Physics engine: Simulates physical interactions between entities in the scene.
• Physics queries: Raycasts and overlaps to test collisions.
• Physics update: Fixed timestep and update order considerations.
• Rigid body: Dynamic colliders affected by forces (gravity, collisions).
• Static: Non-moving colliders (terrain, walls) that other objects collide with.
• Trigger: A collider that raises events when other objects overlap without blocking them.

Scripting terms

• Asynchronous script: Runs a task-like Execute method; can await operations and return to the main thread with await Script.NextFrame().
• Best practices: Recommended coding patterns for Stride projects.
• Camera controller: A script enabling camera movement using input.
• Content.Load: Load assets at runtime via the content system.
• Debugging: Inspect and troubleshoot scripts at runtime.
• Entity.GetOrCreate: Retrieve or add a component to the entity.
• Events: Script event patterns (subscribe, raise, handle).
• Gizmos: Draw editor helpers for custom components.
• Preprocessor variables: Conditional compilation for scripts.
• Public properties and fields: Expose script fields to the editor.
• SceneSystem.SceneInstance.RootScene: Access the active scene instance.
• Scheduling and priorities: Control script execution order and timing.
• Startup script: Runs when added/removed at runtime; used to initialize or tear down game elements.
• Synchronous script: Has an Update method that runs every frame on the main thread.
• Update method: A callback that runs every frame to update game logic.

Sprites terms

• Nine-slice (sprite borders): Scalable UI frames using sprite borders.
• Sprite: A 2D image used in UI or scenes.
• Sprite sheet: Texture atlas containing multiple sprites.

UI terms

• Add a UI to a scene: How to display UI in your scene.
• Layout system: Mechanism that arranges UI elements (stack panels, grids, anchors).
• UI editor: Tooling to author and preview UI within Game Studio.
• UI libraries: Reusable sets of UI controls and styles.
• UI pages: Screens composed of UI elements.

Virtual reality terms

• Enable VR: Enable VR support for your project.
• Overlays: Display UI or HUDs in VR using overlays.
• Preview a scene in VR: Test your scene with a VR headset.