Table of Contents

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

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

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

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

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

Sprites terms

UI terms

Virtual reality terms

Edit this page