Unity 手册

• Unity 6 User Manual
  • Documentation versions
  • Offline documentation
  • Trademarks and terms of use
• What's new in Unity
  • New in Unity 6
  • New in Unity 6 Preview
  • New in Unity 2023.2
  • New in Unity 2023.1
• Install and upgrade
  • Install Unity
    • System requirements for Unity 6
    • Install Unity from the command line
    • Install Unity offline without using the Hub
  • Deploy Unity across your enterprise
    • Enable Unity installation by standard users (Windows)
    • Use Unity through web proxies
      • Enable automatic proxy configuration
      • Store credentials for automatic proxy configuration (Windows)
      • Store credentials for automatic proxy configuration (macOS)
      • Trusting the web proxy security certificate
      • Use environment variables to identify your web proxy
      • Create a command file to set environment variables and open applications
      • Define exceptions on your web proxy
  • Licenses and activation
    • Licensing overview
    • License activation methods
    • Manage your license through the command line
    • Manual license activation
      • Submit a license request from the Hub
      • Submit a license request from a command line and browser (Windows)
      • Submit a license request from a command line and browser (macOS, Linux)
    • License troubleshooting
  • Upgrade Unity
    • API updater
    • Upgrade to Unity 6
    • Upgrade to Unity 2023.2
    • Upgrade to Unity 2023.1
    • Upgrade to Unity 2022 LTS
    • Upgrade to Unity 2021 LTS
• Packages and feature sets
  • Unity's Package Manager
    • How Unity works with packages
    • Concepts
      • Package types
      • Package states and lifecycle
      • Dependency and resolution
      • Global cache
    • Configuration
      • Solving network issues
      • Scoped registry authentication
      • Customize the global cache
      • Customize the asset package cache location
      • Using private repositories with HTTPS Git URLs
      • Using passphrase-protected SSH keys with SSH Git URLs
        • Loading SSH keys automatically on Windows (OpenSSH)
        • Loading SSH keys automatically on Windows (PuTTY)
        • Loading SSH keys automatically on macOS
    • Package Manager window
      • Access the Package Manager window
      • Navigation panel
      • List panel
      • Details panel
      • Features (details panel)
      • Finding packages and feature sets
        • Packages list context
        • Sorting the list
        • Filtering the list
        • Search box
      • Add and remove UPM packages or feature sets
        • Install a feature set from the Unity registry
        • Install a UPM package from a registry
        • Install a UPM package from the Asset Store
        • Install a UPM package from a local folder
        • Install a UPM package from a local tarball file
        • Install a UPM package from a Git URL
        • Install a UPM package by name
        • Remove a UPM package from a project
        • Switch to another version of a UPM package
      • Add and remove asset packages
        • Download and import an asset package
        • Update an asset package
        • Remove imported assets from a project
        • Delete an asset package from the cache
      • Disable a built-in package
      • Perform an action on multiple packages
      • Finding package documentation
    • Inspecting packages
      • Package Manifest window
    • Scripting API for packages
      • Accessing package assets
    • Scoped registries
    • Resolution and conflict
      • Lock files
    • Project manifest
      • Embedded dependencies
      • Git dependencies
      • Local folder or tarball paths
    • Troubleshooting
      • Diagnose network issues
  • Packages
    • Released packages
      • 2D Animation
      • 2D Aseprite Importer
      • 2D Pixel Perfect
      • 2D PSD Importer
      • 2D SpriteShape
      • Adaptive Performance
      • Addressables
      • Addressables for Android
      • Ads Mediation
      • Advertisement Legacy
      • AI Navigation
      • Alembic
      • Analytics
      • Android Logcat
      • Animation Rigging
      • Apple ARKit XR Plugin
      • Apple visionOS XR Plugin
      • AR Foundation
      • Asset Manager
      • Authentication
      • Behavior
      • Build Automation
      • Burst
      • CCD Management
      • Character Controller
      • Cinemachine
      • Cloud Code
      • Cloud Diagnostics
      • Cloud Save
      • Cloud Services Apis
      • Code Coverage
      • Collections
      • Dedicated Server
      • Deployment
      • Device Simulator Devices
      • Economy
      • Editor Coroutines
      • Entities
      • Entities Graphics
      • FBX Exporter
      • Friends
      • Google ARCore XR Plugin
      • Havok Physics for Unity
      • In App Purchasing
      • Input System
      • iOS 14 Advertising Support
      • JetBrains Rider Editor
      • Leaderboards
      • Live Capture
      • Lobby
      • Localization
      • Magic Leap XR Plugin
      • Matchmaker
      • Mathematics
      • Memory Profiler
      • Microsoft GDK API
      • Microsoft GDK Tools
      • ML Agents
      • Multiplay
      • Multiplayer Play Mode
      • Multiplayer Services
      • Multiplayer Tools
      • Multiplayer Widgets
      • Muse Sprite
      • Muse Texture
      • Netcode for Entities
      • OpenXR Plugin
      • Performance testing API
      • Player Accounts
      • Polybrush
      • PolySpatial Extensions
      • PolySpatial visionOS
      • Post Processing
      • ProBuilder
      • Profile Analyzer
      • Push Notifications
      • Python Scripting
      • Recorder
      • Relay
      • Remote Config
      • Scriptable Build Pipeline
      • Sentis
      • Sequences
      • Services Tooling
      • SharpZipLib
      • Sysroot Base
      • Sysroot Linux x64
      • System Metrics Mali
      • Terrain Tools
      • Timeline
      • Toolchain Linux x64
      • Toolchain MacOS Arm64 Linux x64
      • Toolchain MacOS Linux x64
      • Toolchain Win Linux x64
      • Toolchain WinArm64 Linux x64
      • Tutorial Authoring Tools
      • Tutorial Framework
      • Unity Logging
      • Unity OpenXR Meta
      • Unity Physics
      • Unity Profiling Core API
      • Unity Transport
      • User Generated Content
      • User Generated Content Bridge
      • User Reporting
      • Version Control
      • Visual Scripting
      • Visual Studio Editor
      • Vivox
      • WebGL Publisher
      • XR Hands
      • XR Interaction Toolkit
      • XR Plugin Management
      • ZivaRT Player
    • Release candidates
    • Pre-release packages
      • Moderation
    • Core packages
      • 2D Sprite
      • 2D Tilemap Editor
      • Core RP Library
      • High Definition RP
      • Multiplayer Center
      • Shader Graph
      • Unity Denoising
      • Unity UI
      • Universal RP
      • Visual Effect Graph
    • Built-in packages
      • Accessibility
      • AI
      • AMD
      • Android JNI
      • Animation
      • Asset Bundle
      • Audio
      • Cloth
      • Director
      • Image Conversion
      • IMGUI
      • JSONSerialize
      • NVIDIA
      • Particle System
      • Physics
      • Physics 2D
      • Screen Capture
      • Terrain
      • Terrain Physics
      • Tilemap
      • UI
      • UIElements
      • Umbra
      • Unity Web Request
      • Unity Web Request Asset Bundle
      • Unity Web Request Audio
      • Unity Web Request Texture
      • Unity Web Request WWW
      • Vehicles
      • Video
      • VR
      • Wind
      • XR
    • Experimental packages
    • Packages by keywords
    • Deprecated packages
  • Creating custom packages
    • Naming your package
    • Package layout
    • Adding tests to a package
    • Creating samples for packages
    • Package manifest
      • Versioning
    • Assembly definition and packages
    • Meeting legal requirements
    • Documenting your package
    • Sharing your package
  • Feature sets
    • 2D feature set
    • 3D Characters and Animation feature set
    • 3D World Building feature set
    • AR feature set
    • Cinematic Studio feature set
    • Engineering feature set
    • Gameplay and Storytelling feature set
    • Mobile feature set
    • VR feature set
• Get started with Unity
  • 2D or 3D projects
  • Quickstart guides
    • 3D game development quickstart guide
      • Creating a 3D game
  • Advanced best practice guides
• The Unity Editor
  • Unity's interface
    • The Project window
    • The Scene view
      • Overlays
        • Default Scene view overlay reference
        • Display or hide an overlay
        • Position an overlay
        • Change the layout of an overlay
        • Create and manage overlay configurations
        • Cameras overlay
        • Create your own overlay
      • Scene view grid snapping
        • Enable automatic snapping to grid
        • Move, rotate, and scale in increments
        • Align a GameObject to the grid
        • Customize the grid
        • Grid and snap shortcuts
        • Grid and Snap toolbar overlay
      • Pick and select GameObjects in the Scene view
        • Select GameObjects
        • Select a GameObject that overlaps with other GameObjects
        • Scene picking controls
      • Position GameObjects
      • Scene view navigation
      • Scene view Camera
      • Control a camera in first person
      • Scene visibility
      • Scene view View Options overlay
      • Gizmos menu
      • Scene view context menu
      • Custom Editor tools
    • The Game view
    • Device Simulator
      • Device Simulator introduction
      • The Simulator view
      • Simulated classes
      • Adding a device
      • Extending the device simulator
    • The Hierarchy window
    • The Inspector window
      • Working in the Inspector
      • Focused Inspectors
    • Editing properties
    • The Toolbar
    • The status bar
    • The Background Tasks window
    • Console Window
    • Additional windows
    • Undo
    • Search in the Editor
    • Customizing your workspace
    • Unity shortcuts
  • Save your work
  • Editor Features
    • 2D and 3D mode settings
    • Preferences
    • Shortcuts Manager
    • Build profiles
      • Understanding build types
      • Introduction to build profiles
      • Create a build profile
      • Manage scenes in your build
      • Override Player settings with build profiles
      • Build Profiles window reference
    • Incremental build pipeline
    • Project Settings
      • Use the Project Settings window
      • Audio
      • Editor
      • Graphics
      • Package Manager
      • Physics
      • Physics 2D reference
      • Player
        • Splash Image Player settings
      • Preset Manager
      • Quality
      • Script Execution Order settings
      • Tags and Layers
      • Time
      • UI Toolkit project settings
      • Version Control
    • Visual Studio C# integration
    • RenderDoc Integration
    • Editor analytics
    • Check For Updates
    • IME in Unity
    • Version Control
      • Version control integrations
      • Perforce Integration
      • Smart merge
    • Safe Mode
    • Command-line arguments
      • Unity Editor command line arguments
      • Unity Standalone Player command line arguments
      • Batch mode and built-in coroutine compatibility
    • Text-Based Scene Files
      • Format of Text Serialized files
      • UnityYAML
      • An Example of a YAML Scene File
      • YAML Class ID Reference
    • Troubleshoot the Editor
  • Unity Search
    • Search usage
      • Filter searches
      • Search query operators
      • The Index Manager
    • Search tables
    • Search Providers
      • Search Project Assets
      • Search the current Scene
      • Search the Unity main menu
      • Search Object Picker
      • Search Settings and Preferences
      • The calculator
      • Search for files
      • Execute API methods
      • Search for packages
      • Search the Unity Asset Store
      • Additional Search filters
    • Search expressions
      • Functions reference
    • Creating a custom Search Provider
      • The SearchProvider class
      • Registering a Search Provider
      • Performing a search
      • Registering an Action Handler
• Working in Unity
  • Assets and media
    • Asset workflow
      • Importing assets
        • Importing assets simultaneously
      • Supported Asset Types
        • Built-in Importers
        • Scripted Importers
        • Importer Consistency
        • Text assets
      • Asset Metadata
      • The Asset Database
        • Refreshing the Asset Database
        • Customizing the Asset Database workflow
        • Batching with the AssetDatabase
      • Special folder names
      • Import Activity window
      • Presets
        • Supporting presets
        • Applying default presets to Assets by folder
      • AssetBundles
        • AssetBundle workflow
        • Preparing Assets for AssetBundles
        • AssetBundle Dependencies
        • Output of the Build
        • Using AssetBundles Natively
        • AssetBundle compression and caching
        • Patching with AssetBundles
        • Troubleshooting
        • AssetBundle Download Integrity and Security
        • Multi-Process AssetBundle Building (Experimental)
      • Scripting with Assets
        • Loading Resources at Runtime
        • Streaming Assets
        • Modifying Source Assets Through Scripting
      • Asset packages
        • Create and export asset packages
        • Importing local asset packages
        • Removing local asset packages
      • Archives
      • Asset Loading Profiler module
    • Unity's Asset Store
      • Asset Store packages
        • Purchase or download a package from the Asset Store
        • Finding your Asset Store packages
        • Using labels to organize My Assets
      • Publish to the Asset Store
        • Creating your Publisher Account
        • Creating a new package draft
        • Deleting a package draft
        • Uploading assets to your package
        • Filling in the package details
        • Submitting your package for approval
        • Viewing the status of your Asset Store submissions
        • Collecting revenue
        • Providing support to your customers
        • Adding tags to published packages
        • Connecting your account to Google Analytics
        • Promoting your Assets
        • Refunding your customers
        • Upgrading packages
        • Deprecating your Assets
        • Issuing vouchers
        • Managing your publishing team
        • Asset Store Publisher portal
      • Verified Solutions
        • Decentralized technology Verified Solutions
    • Unity Accelerator
  • Working with GameObjects
    • Introduction to GameObjects
    • GameObject fundamentals
      • Transforms
      • Rotation and orientation in Unity
      • Static GameObjects
      • Deactivate GameObjects
    • Primitive and placeholder objects
      • Types of 2D primitive GameObjects
    • Components
      • Introduction to components
      • Use components
      • Create components with scripts
    • Models
      • Creating models outside of Unity
        • Model file formats
        • Support for proprietary model file formats
        • Preparing your model files for export
        • Creating models for optimal performance
        • Creating models for animation
      • Importing models into Unity
        • Importing a model
        • Importing a model with humanoid animations
        • Importing a model with non-humanoid (generic) animations
        • Model Import Settings window
          • Model tab
          • Rig tab
            • Avatar Mapping tab
            • Avatar Muscle & Settings tab
            • Avatar Mask window
            • Human Template window
          • Animation tab
            • Euler curve resampling
            • Extracting animation clips
            • Loop optimization on Animation clips
            • Curves
            • Events
            • Mask
            • Motion
          • Materials tab
        • SketchUp Import Settings window
    • Meshes
      • Get started with meshes
        • Introduction to meshes
        • Mesh data
          • Mesh vertex data
          • Mesh topology data
          • Mesh index data
          • Mesh data for deformable meshes
          • View mesh data visualizations
      • Creating and accessing meshes via script
        • Create a mesh
        • Access meshes via the Mesh API
        • Create a quad mesh via script
      • Simplifying distant meshes with level of detail (LOD)
        • Mesh LOD
        • Configure mesh LOD
        • Import a mesh with LOD settings
        • LOD Group component reference
        • 2D images for low level of detail (LOD)
          • Applying 2D billboards for low LOD meshes
          • Billboard Renderer component reference
          • Billboard asset reference
      • Compressing mesh data for optimization
        • Types of mesh data compression
        • Configure vertex compression
        • Configure mesh compression
      • Loading texture and mesh data asynchronously
        • Texture and mesh loading
        • Check whether a mesh uses the asynchronous upload pipeline
        • Configure the asynchronous upload pipeline
      • Text meshes
        • Create meshes for text strings
        • Text Mesh component reference
      • Mesh components reference
        • Mesh Renderer component reference
        • Skinned Mesh Renderer component reference
        • Mesh Filter component reference
        • Mesh asset Inspector window reference
      • Troubleshooting Skinned Mesh Renderer visibility
    • Prefabs
      • Creating Prefabs
      • Editing a Prefab in Prefab Mode
      • Instance overrides
      • Editing a Prefab via its instances
      • Nested Prefabs
      • Prefab Variants
      • Overrides at multiple levels
      • Unused Overrides
      • Unpacking Prefab instances
    • Constraints
      • Aim Constraints
      • Look At Constraints
      • Parent Constraints
      • Position Constraints
      • Rotation Constraints
      • Scale Constraints
  • Working with scenes
    • Introduction to scenes
    • Creating, loading, and saving Scenes
    • Work with multiple scenes in Unity
      • Set up multiple scenes
      • Bake data in multiple scenes
      • Use scripts to edit multiple scenes
    • Scene Templates
      • Creating scene templates
      • Editing scene templates
      • Customizing new scene creation
      • Scene template settings
    • Layers
      • Uses of layers in Unity
      • Create functional layers in Unity
      • Layer-based collision detection
      • Layers and layerMasks
        • Introduction to layerMasks
        • Set a layerMask
        • Add a layer to a layerMask
        • Remove a layer from a layerMask
    • Tags
  • Cameras
    • Introduction to cameras
    • The camera view
      • Introduction to the camera view
      • Make the camera perspective oblique
      • Calculate the size of the frustum at a distance
      • Rays from the camera
        • Introduction to raycasting
        • Cast a ray from a camera
        • Move a camera along a ray
    • Using multiple cameras
      • Configure multiple cameras
      • Set the order of multiple cameras
      • Display camera views on multiple monitors
    • Changing resolution scale with Dynamic Resolution
      • Introduction to Dynamic Resolution
      • Control scaling with Dynamic Resolution
      • Control when Dynamic Scaling happens
      • Enable or disable Dynamic Resolution for render targets
    • Excluding hidden objects with occlusion culling
      • Occlusion culling
      • Set up a scene for occlusion culling
      • Set up multiple scenes for occlusion culling
      • Cull moving GameObjects
      • Create high-precision occlusion areas
      • Control occlusion in areas with Occlusion Portals
      • Occlusion Culling window reference
      • Configure culling with the CullingGroup API
        • Introduction to the CullingGroup API
        • Create a Culling Group
        • Get culling results
    • Simulating real-world cameras with Physical Cameras
      • Introduction to Physical Cameras
      • Widen the view with Lens Shift
      • Crop or stretch the view with Gate Fit
        • Introduction to Gate Fit
        • Configure Gate Fit
    • Camera output
      • Introduction to camera output
      • Output a depth texture from a camera
      • Output a motion vector texture from a camera
      • Sample output textures in a shader
      • Troubleshooting camera output
    • Cameras in URP
      • Introduction to cameras in URP
      • Camera render types in URP
        • Introduction to camera render types in URP
        • Change the render type of a camera in URP
      • Multiple cameras in URP
        • Camera stacking in URP
        • Set up a camera stack in URP
        • Add and remove cameras in a camera stack in URP
        • Set up split-screen rendering in URP
        • Apply different post processing effects to separate cameras in URP
        • Render a camera's output to a Render Texture in URP
        • Create a render request in URP
      • Camera render order in URP
      • Motion vectors in URP
        • Introduction to motion vectors in URP
        • Built-in shader support for motion vectors in URP
        • Motion vectors render pass in URP
        • Output a motion vector texture in a custom shader in URP
        • Sample motion vectors in a shader in URP
        • Troubleshooting motion vectors in URP
        • Motion vectors settings reference for URP
      • Upscaling resolution in URP with Spatial-Temporal Post-Processing
        • Introduction to Spatial-Temporal Post-processing in URP
        • Enable Spatial-Temporal Post-processing in URP
        • Spatial-Temporal Post-processing Rendering Debugger reference for URP
      • Access camera data with the Universal Additional Camera Data component in URP
      • Camera Inspector windows reference for URP
        • Camera Inspector window reference for URP
        • Physical Camera Inspector window reference for URP
    • Cameras in the Built-In Render Pipeline
      • Set the camera background with Clear Flags in the Built-In Render Pipeline
      • Camera Inspector window reference for the Built-In Render Pipeline
    • Troubleshooting cameras
  • Input
    • Mobile Keyboard
    • Unity XR Input
    • Legacy Input
      • Input Manager
      • Mobile device input
  • User interface (UI)
    • Comparison of UI systems in Unity
    • UI Toolkit
      • Get started with UI Toolkit
      • UI Builder
        • UI Builder interface overview
        • Get started with UI Builder
        • Work with elements
        • Use UXML instances as templates
        • Style UI with UI Builder
        • Assign USS variables in UI Builder
        • Test UI
      • Structure UI
        • The visual tree
          • Introduction to visual elements and the visual tree
          • Panels
          • Draw order
          • Coordinate and position systems
        • Structure UI with UXML
          • Introduction to UXML
          • Add styles to UXML
          • Reuse UXML files
          • Reference other files from UXML
          • Load UXML and USS C# scripts
          • Instantiate UXML from C# scripts
          • Find visual elements with UQuery
        • Structure UI with C# scripts
        • Custom controls
          • Create a custom control
          • Customize UXML tag names and attributes
          • Bind custom controls to data
          • Define a namespace prefix
        • Best practices for managing elements
        • Encapsulate UXML documents with logic
        • Visual elements reference
          • UXML element BindableElement
          • UXML element VisualElement
          • UXML element BoundsField
          • UXML element BoundsIntField
          • UXML element Box
          • UXML element Button
          • UXML element ColorField
          • UXML element CurveField
          • UXML element DoubleField
          • UXML element DropdownField
          • UXML element EnumField
          • UXML element EnumFlagsField
          • UXML element FloatField
          • UXML element Foldout
          • UXML element GradientField
          • UXML element GroupBox
          • UXML element Hash128Field
          • UXML element HelpBox
          • UXML element IMGUIContainer
          • UXML element Image
          • UXML element InspectorElement
          • UXML element IntegerField
          • UXML element Label
          • UXML element LayerField
          • UXML element LayerMaskField
          • UXML element LongField
          • UXML element ListView
          • UXML element MaskField
          • UXML element MinMaxSlider
          • UXML element MultiColumnListView
          • UXML element MultiColumnTreeView
          • UXML element ObjectField
          • UXML element PopupWindow
          • UXML element ProgressBar
          • UXML element PropertyField
          • UXML element RadioButton
          • UXML element RadioButtonGroup
          • UXML element RectField
          • UXML element RectIntField
          • UXML element RepeatButton
          • UXML element RenderingLayerMaskField
          • UXML element ScrollView
          • UXML element Scroller
          • UXML element Slider
          • UXML element SliderInt
          • UXML element Tab
          • UXML element TabView
          • UXML element TagField
          • UXML element TextElement
          • UXML element TextField
          • UXML element TemplateContainer
          • UXML element Toggle
          • UXML element ToggleButtonGroup
          • UXML element Toolbar
          • UXML element ToolbarBreadcrumbs
          • UXML element ToolbarButton
          • UXML element ToolbarMenu
          • UXML element ToolbarPopupSearchField
          • UXML element ToolbarSearchField
          • UXML element ToolbarSpacer
          • UXML element ToolbarToggle
          • UXML element TreeView
          • UXML element TwoPaneSplitView
          • UXML element UnsignedLongField
          • UXML element UnsignedIntegerField
          • UXML element Vector2Field
          • UXML element Vector2IntField
          • UXML element Vector3Field
          • UXML element Vector3IntField
          • UXML element Vector4Field
        • Structure UI examples
          • Create list and tree views
          • Create a complex list view
          • Create a list view runtime UI
          • Wrap content inside a scroll view
          • Create a tabbed menu
          • Create a pop-up window
          • Use Toggle to create a conditional UI
          • Create a custom control with two attributes
          • Create a slide toggle custom control
          • Create a bindable custom control
          • Create a custom style for a custom control
          • Create a drag-and-drop list and tree views between windows
          • Create an aspect ratio custom control
      • Style UI
        • Introduction to USS
        • USS selectors
          • Type selectors
          • Name selectors
          • Class selectors
          • Universal selectors
          • Descendant selectors
          • Child selectors
          • Multiple selectors
          • Selector lists
          • Pseudo-classes
          • Selector precedence
        • USS properties
          • USS data types
          • USS common properties
          • Position element with the layout engine
          • Relative and absolute positioning
          • Set background images
          • Image import settings
          • USS transform
          • USS transition
          • USS properties reference
          • USS color keywords
        • USS custom properties (variables)
          • Create USS variables
          • Introduction to USS built-in variables
          • USS built-in variable references
          • Get custom styles in C# scripts
        • Apply styles in C# scripts
        • Best practices for USS
        • Theme Style Sheet (TSS)
        • Apply masking effects in UI Toolkit
      • UI Toolkit Debugger
      • Control behavior with events
        • Dispatch events
        • Capture the pointer with a manipulator
        • Handle event callbacks and value changes
        • Focus order of elements
        • Respond to events with custom controls
        • Manipulators
        • Synthesize and send events
        • Event reference
          • Capture events
          • Change events
          • Click events
          • Command events
          • Drag-and-drop events
          • Layout events
          • Focus events
          • Input events
          • Keyboard events
          • Mouse events
          • Navigation events
          • Panel events
          • Pointer events
          • Tooltip event
          • Transition events
          • Contextual menu events
          • IMGUI events
        • Event examples
          • Create a simple transition with UI Builder and C# scripts
          • Create a drag-and-drop UI inside a custom Editor window
          • Create a drag-and-drop UI to drag between Editor windows
          • Create a transition event
          • Create looping transitions
      • UI Renderer
        • Generate 2D visual content
        • Create a pie chart in the Editor and runtime UI
        • Use Vector API to create a radial progress indicator
        • Use Mesh API to create a radial progress indicator
        • Parallel tessellation
      • Data binding
        • Comparison of the binding systems
        • Runtime data binding
          • Get started with runtime binding
          • Create a runtime binding in C# scripts
          • Define a data source for runtime binding
          • Define binding mode and update trigger
          • Convert data types
          • Define logging levels
          • Create custom binding types
          • Runtime data binding examples
            • Bind to multiple properties with runtime binding
            • Create a runtime binding with a type converter
            • Create a custom binding to bind USS selectors
            • Bind ListView to a list with runtime binding
        • SerializedObject data binding
          • Introduction to SerializedObject data binding
          • Bindable elements reference
          • Bindable data types and fields
          • Binding system implementation details
          • Binding examples
            • Bind with binding path in C# script
            • Bind without the binding path
            • Bind with UXML and C# script
            • Create a binding with the Inspector
            • Bind to nested properties
            • Bind to a UXML template
            • Receive callbacks when a bound property changes
            • Receive callbacks when any bound properties change
            • Bind to a list with ListView
            • Bind to a list without ListView
            • Bind a custom control
            • Bind a custom control to custom data type
      • Support for Editor UI
        • Create a custom Editor window with C# script
        • Create a Custom Inspector
        • View data persistence
      • Support for runtime UI
        • Get started with runtime UI
        • Render UI in the Game view
        • Panel Settings properties reference
        • Runtime UI event system and input handling
        • Performance consideration for runtime UI
          • Use usage hints to reduce draw calls and geometry regeneration
          • Control textures of the dynamic atlas
          • Platform and mesh considerations
        • FAQ for input and event systems with UI Toolkit
      • Work with text
        • Get started with text
        • Style text with USS
        • Style text with rich text tags
        • Supported rich text tags
        • Font assets
          • Introduction to font assets
          • Font Asset properties reference
          • Font Asset Creator properties reference
        • Text effects
        • Style sheets
        • Include sprites in text
          • Sprite Asset properties reference
        • Color gradients
        • Advanced Text Generator
        • Panel Text Settings assets
        • Fallback font
      • Examples
      • Migration guides
        • Migrate from Unity UI (uGUI) to UI Toolkit
        • Migrate from Immediate Mode GUI (IMGUI) to UI Toolkit
    • Unity UI
    • Immediate Mode GUI (IMGUI)
      • IMGUI Basics
      • IMGUI Controls
      • Customize your IMGUI Controls
      • IMGUI Layout Modes
      • Extending IMGUI
      • GUI Skin (IMGUI System)
      • GUI Style (IMGUI System)
      • Extending the Editor with IMGUI
        • Create custom Editor Windows with IMGUI
        • Use Property Drawers with IMGUI to customize the Inspector
        • Create custom Editors with IMGUI
        • Create TreeView with IMGUI
    • UI and UI Details Profiler
  • 2D in Unity
    • Introduction to 2D
    • 2D game development
      • Setup a project for 2D games
      • 2D game creation workflow
      • 2D game perspectives reference
      • 2D game art style reference
    • 2D renderer sorting
    • Sprites
      • Image import as sprites
        • Images as sprites import process
        • Place images directly into the project folder
        • Import an image through the Editor menu
        • Set the Texture Type of an imported image to Sprite (2D and UI)
      • Sprites sorting order
        • Sort sprites
        • Sort sprites using scripts
        • Sprites sorting reference
      • Sprite Renderer
        • Install the 2D Sprite package
        • Add a Sprite Renderer to an existing GameObject
        • Change the color of a sprite
        • Set the sort point of a sprite
        • Sprite Renderer reference
      • Placeholder sprites
        • Access the Sprite Creator
        • Use the placeholder sprite
        • Replace the placeholder sprite
      • Sprite editor
        • Open the sprite editor
        • Use the editor
        • Automatic slicing
        • Resize polygons
        • Custom outline
          • Generate the outline
          • Edit the custom outline
          • Add or remove control points
          • Move control points
          • Move edges
          • Custom outline editor reference
        • Custom physics shape
          • Use the Custom Physics Shape editor
          • Open the Custom Physics Shape editor
          • Generate the physics shape
          • Manually edit the physics shape
          • Move a control point
          • Add or remove control points
          • Move edges
          • Work with multiple outlines
          • Update the shape of the collider 2D meshes
          • Custom physics shape editor reference
        • Sprite editor secondary textures
          • Add a secondary texture
          • Delete a secondary texture
        • Sprite Editor Data Provider API
      • Sorting groups
        • Set up a sorting group
        • Sort renderers within a sorting group
        • Use sorting groups
        • Sorting group reference
      • Various image sizes without multiple assets
        • 9-slicing
        • Set up your sprite for 9-slicing
        • 9-slice your sprite
      • Sprite masks
        • Hide or reveal parts of a sprite with a mask
        • Create a sprite mask
        • Apply a mask to a sprite
        • Sprite mask reference
      • Sprite atlas
        • Create a Sprite Atlas
        • Sprite Atlas reference
        • Variant Sprite Atlases
          • Master and Variant Sprite Atlases
          • Variant Sprite Atlas
          • Create a variant Sprite Atlas
          • Scale the textures of a variant Sprite Atlas
        • Sprite Atlas workflow
          • Create a sprite Atlas workflow
          • Create a Sprite Atlas Asset
          • Select items for the objects for packing list
          • Include in build
          • Optimize Sprite Atlas usage and size for improved performance
        • Distribution
          • Prepare Sprite Atlases for distribution
          • Methods of distribution
          • Late binding
          • Load a Sprite Atlas with SpriteAtlasManager.atlasRequested
          • Retrieve sprite contents at runtime with GetSprites
          • Resolve different Sprite Atlas scenarios
        • Sprite packer modes
          • Enable or disable the Sprite Atlas default packing behavior
          • Sprite packer modes reference
        • Sprite Atlas V2
          • Sprite Atlas V2
          • Enable Sprite Atlas V2
          • Enable Sprite Atlas V2 effects
          • Sprite Atlas V2 inspector reference
      • Sprite shape renderer
        • Color
        • Mask interaction
        • Sprite shape renderer reference
    • Tilemaps in Unity
      • Tilemaps
      • Work with tilemaps
        • Create a tilemap
        • Hexagonal Tilemaps
        • Isometric tilemaps in Unity
          • Isometric tilemaps
          • Isometric tilemap grid cells
          • Tilemap Renderer for Isometric Tilemaps
            • Tilemap Renderer isometric modes
            • Sort isometric Sprites with the Sprite Atlas
            • Sort Sprites with a Custom Sorting Axis
          • Create an Isometric Tilemap
          • Create a Tile Palette for an Isometric Tilemap
          • Import Sprites for an Isometric Tilemap
          • Isometric scriptable brush methods
          • Isometric brush shortcut Reference
        • Tilemap Collider 2D
        • Tilemap component reference
        • Tilemap Renderer component reference
        • Tilemap Collider 2D component reference
        • Troubleshoot mismatched Cell Layouts
      • Tiles for tilemaps
        • Create tile assets
        • Delete tile assets
        • Scriptable Tile assets
          • Scriptable tiles
          • Create a scriptable tile
        • Tile asset reference
      • Tile palettes
        • Create a Tile Palette
        • Tile palette brushes
          • Active brush
          • Tile palette Brush Picks
            • Brush Picks
            • Create a Brush Pick asset
            • Work with Brush Picks
            • Customize a scriptable Brush's thumbnail
            • Brush Picks overlay reference
          • Create a Scriptable Brush
          • Brush Inspector window reference
          • Active brush shortcuts reference
        • Tile palette editor tools
          • The Select tool
            • Select tiles with the Select tool
            • Grid Selection properties reference
            • Modify Tilemap reference
          • Move tiles with the Move tool
          • Paint tiles with the Paint tool
          • Remove tiles with the Eraser tool
          • Fill an area with the Box Fill tool
          • Fill an area with the Flood Fill tool
          • Create Brush Picks from tiles with the Pick tool
        • New tile palette properties reference
        • Tile palette preferences reference
        • Tile palette editor reference
      • Grid component reference
    • 2D Physics
      • Rigidbody 2D
        • Introduction to Rigidbody 2D
        • Rigidbody 2D body types
          • Introduction to Rigidbody 2D body types
          • Dynamic Body Type
            • Dynamic Body Type fundamentals
            • Dynamic Body Type
          • Kinematic Body Type
            • Kinematic Body Type fundamentals
            • Kinematic Body Type reference
          • Static Body Type
            • Static Body Type fundamentals
            • Static Body Type reference
        • Rigidbody 2D Simulated property
      • Collider 2D
        • Circle Collider 2D component reference
        • Box Collider 2D component reference
        • Polygon Collider 2D component reference
        • Edge Collider 2D component reference
        • Capsule Collider 2D
          • Capsule Collider 2D component reference
          • Configure Capsule Collider 2D
        • Composite Collider 2D
          • Composite Collider 2D component reference
          • Combine Colliders with the Composite Collider 2D
        • Custom Collider 2D
          • Custom Collider 2D component reference
          • Use a Custom Collider 2D
        • Edit the collider's geometry
        • Edit Collider mode reference
      • Effectors 2D
        • Area Effector 2D reference
        • Buoyancy Effector 2D reference
        • Point Effector 2D reference
        • Platform Effector 2D reference
        • Surface Effector 2D reference
      • 2D joints
        • Introduction to 2D joints
        • 2D joint constraints
        • Distance Joint 2D
          • Distance Joint 2D fundamentals
          • Distance Joint 2D component reference
        • Fixed Joint 2D
          • Fixed Joint 2D fundamentals
          • Fixed Joint 2D component reference
        • Friction Joint 2D
          • Friction Joint 2D fundamentals
          • Friction Joint 2D component reference
        • Hinge Joint 2D
          • Hinge Joint 2D fundamentals
          • Hinge Joint 2D component reference
        • Relative Joint 2D
          • Relative Joint 2D fundamentals
          • Relative Joint 2D component reference
        • Slider Joint 2D
          • Slider Joint 2D fundamentals
          • Slider Joint 2D
        • Spring Joint 2D
          • Spring Joint 2D fundamentals
          • Spring Joint 2D
        • Target Joint 2D
          • Target Joint 2D fundamentals
          • Target Joint 2D
        • Wheel Joint 2D
          • Wheel Joint 2D fundamentals
          • Wheel Joint 2D
      • Physics 2D Profiler
        • Physics 2D Profiler module reference
        • Use the Physics Profiler Legacy mode
      • Constant Force 2D reference
      • Physics Material 2D reference
    • 2D game development in URP
      • 2D lighting in URP
        • Types of 2D lights
          • Introduction to the 2D lighting system in URP
          • Prepare your project for 2D lighting
          • Light 2D component reference for URP
          • Configure a 2D light
        • Set up the 2D Renderer asset in URP
        • Prepare and upgrade sprites for 2D lighting in URP
        • Enable 2D lighting with the Tilemap Renderer in URP
        • Blend Modes in 2D lighting
          • Blend Modes
          • Masking
          • Add normal map and mask textures to a sprite in URP
          • HDR emulation scale
        • Create shadows with Shadow Caster 2D in URP
        • Create a 2D sprite lit Shader Graph in URP
        • Light a VFX Graph asset with 2D lights in URP
        • Optimizing 2D lights
          • Optimize 2D lights
          • Introduction to 2D light batching
          • Check how Unity batches lights
        • 2D Renderer asset component reference for URP
        • Light Blend Styles component reference for URP
      • Precise pixel scaling and rotation via the Pixel Perfect Camera in URP
        • Introduction to the Pixel Perfect Camera in URP
        • Prepare your sprites for the 2D Pixel Perfect Camera in URP
        • Make Cinemachine compatible with the 2D Pixel Perfect camera in URP
        • Pixel Perfect Camera component reference for URP
  • Troubleshooting
• World building
  • Sky
    • Sky
    • Create a skybox
    • Configure a skybox with a Skybox Shader
    • Skybox Shader Material Inspector window reference
      • 6 Sided Skybox Shader Material Inspector Window reference
      • Cubemap Skybox Shader Material Inspector Window reference
      • Panoramic Skybox Shader Material Inspector Window reference
      • Procedural Skybox Shader Material Inspector Window reference
  • Terrain
    • Creating and editing Terrains
    • Create Neighbor Terrains
    • Terrain tools
      • Raise or Lower Terrain
      • Paint Holes
      • Paint Texture
      • Set Height
      • Smooth Height
      • Stamp Terrain
    • Terrain Layers
    • Brushes
    • Trees
      • Create trees with Tree Editor
        • Tree Editor concepts
        • Shaders and the Ambient-Occlusion folder
        • Design a tree
        • Create trees and leaves from meshes
        • Performance tips for trees
        • Tree Hierarchy view UI reference
        • Root node reference
        • Branch group reference
        • Leaf group reference
      • Import trees from SpeedTree
        • SpeedTree model import
        • SpeedTree Import Settings window
          • Model tab
          • Materials tab
      • Tree level of detail (LOD)
      • Add collision to trees
      • Add trees to the terrain
      • Animate trees with Wind Zones
        • Wind reference
    • Grass and other details
    • Working with Heightmaps
    • Terrain Settings reference
    • Using Terrain at runtime
  • Terrain Tools
• Multiplayer
  • Use the Multiplayer Center
  • New in Multiplayer
• Animation
  • Mecanim Animation system
    • Animation clips
      • Animation from external sources
      • Animation window
        • Use the Animation view
        • Create a new Animation Clip
        • Animate a GameObject
        • Use Animation curves
        • Edit Animation curves
        • Rotation in animations
        • Key manipulation in Dopesheet mode
        • Key manipulation in Curves mode
        • Add an Animation Event
        • Work with blend shapes
    • Humanoid Avatar
      • Retarget Humanoid animations
      • Inverse Kinematics
      • How Root Motion works
      • Scripting Root Motion
    • Animator component
    • Animator Controller
      • Create an Animator Controller
      • Animator Controller Asset
      • Animator Window
      • Animation State Machine
        • State Machine Basics
        • Animation States
        • Animation Parameters
        • State Machine Transitions
        • Animation transitions
        • Animation Blend Trees
          • 1D Blending
          • 2D Blending
          • Direct blending
          • Common Blend Tree Options
        • State Machine Behaviours
        • Sub-State Machines
        • Animation Layers
        • State Machine Solo and Mute
        • Target Matching
    • Animator Override Controller
    • Playables API
      • The PlayableGraph
      • ScriptPlayable and PlayableBehaviour
      • Playables Examples
    • Performance and optimization
    • Mecanim FAQ
  • Legacy Animation system
    • Legacy Animation component
• Physics
  • Built-in 3D Physics
    • Character control
      • Introduction to character control
      • Character Controller component reference
    • Rigidbody physics
      • Introduction to rigid body physics
      • Configure Rigidbody Colliders
      • Apply constant force to a Rigidbody
      • Apply interpolation to a Rigidbody
      • Rigidbody component reference
      • Constant Force component reference
    • Collision
      • Introduction to collision
      • Introduction to collider types
      • Collider shapes
        • Introduction to collider shapes
        • Primitive collider shapes
          • Introduction to primitive collider shapes
          • Box collider component reference
          • Sphere collider component reference
          • Capsule collider component reference
        • Mesh colliders
          • Introduction to Mesh colliders
          • Prepare a Mesh for Mesh colliders
          • Mesh collider component reference
        • Wheel colliders
          • Introduction to Wheel colliders
          • Wheel collider friction
          • Wheel collider suspension
          • Create a car with Wheel colliders
          • Wheel collider component reference
        • Terrain colliders
          • Introduction to Terrain colliders
          • Terrain collider component reference
        • Compound colliders
          • Introduction to compound colliders
          • Create a compound collider
      • Collider surfaces
        • Collider surface friction
        • Collider surface bounciness
        • How collider surface values combine
        • Create and apply a custom Physics Material
        • Physics Material asset reference
      • Collider interactions
        • Use collisions to trigger other events
        • Interaction between collider types
        • OnCollision events
        • OnTrigger events
        • Create and configure a trigger collider
        • Example scripts for collider events
      • Collision detection
        • Choose a collision detection mode
        • Discrete collision detection
        • Continuous collision detection (CCD)
          • Sweep-based CCD
          • Speculative CCD
    • Joints
      • Introduction to joints
      • Character Joint component reference
      • Fixed Joint component reference
      • Hinge Joint component reference
      • Spring Joint component reference
      • Create a configurable joint
        • Customize movement constraint with Configurable Joints
        • Driving forces with Configurable Joints
        • Configure driving forces on a Configurable Joint
        • Configurable Joint component reference
    • Articulations
      • Introduction to physics articulations
      • Articulation Body component reference
    • Ragdoll physics
      • Create a ragdoll
      • Joint and Ragdoll stability
    • Cloth
    • Multi-scene physics
    • Physics Debug window reference
    • Physics Profiler module
• Lighting
  • Get started with lighting
    • Introduction to lighting
    • Choose a lighting setup
  • Light sources
    • Light components
      • Types of Light component
      • Place Light components
      • Configuring Light components
        • Setting a light as realtime or baked
          • Light Modes
          • Choose a Light Mode
          • Set the Mode of a Light
        • Configuring Mixed lights with Lighting Modes
          • Lighting Mode
          • Choose a Lighting Mode
          • Set the Lighting Mode of a scene
          • Adjust Mixed lights at runtime
        • Configuring lights with the Light Explorer
          • Light Explorer window
          • Customize the Light Explorer
    • Add ambient light from the environment
    • Cookies
      • Introduction to cookies
      • Apply a cookie
      • Enable cookies for baked lights
  • Direct and indirect lighting
    • Lighting data
      • Introduction to lighting data
      • Lighting Data Assets
      • Global Illumination (GI) cache
      • Lightmap data format
      • Light Probe data format
    • Precalculating surface lighting with lightmaps
      • Baking lightmaps before runtime
        • Introduction to lightmaps and baking
        • Set up your scene and lights for baking
        • Preview baked lighting
        • Bake lighting
        • Configuring lightmaps and baking
          • Select the CPU or GPU for baking
          • Group GameObjects together in a lightmap with Baked Tags
        • Troubleshooting baked lightmaps
          • Smooth hard edges in lightmaps
          • Fix light bleeding in lightmaps
        • Optimize baking
        • Lightmapping settings in the Lighting Settings Asset reference
      • Creating lightmaps at runtime with Enlighten Realtime Global Illumination
        • Introduction to Realtime Global Illumination using Enlighten
        • Enable Enlighten Realtime Global Illumination
        • Optimize Enlighten Realtime Global Illumination
        • LOD and Enlighten Realtime Global Illumination
        • Global Illumination Profiler module
      • Configuring lightmapping
        • Configure lightmapping with a Lighting Settings Asset
        • Change the fade distance of lights with fall-off
        • Store light direction with Directional Mode
      • Lightmap UVs
        • Introduction to Lightmap UVs
        • Generate lightmap UVs
        • Check lightmap UVs
        • Troubleshooting automatically generated lightmap UVs
        • Lightmap UVs Settings in the Model Import Settings Inspector window reference
    • Precalculating indirect light with Light Probes
      • Light Probes
      • Light Probes and moving GameObjects
      • Place Light Probes with the Editor
      • Place Light Probes with a script
      • Set a GameObject to use light from Light Probes
      • Load Light Probes in multiple scenes
      • Move Light Probes at runtime
      • Troubleshooting Light Probes
      • Light Probes reference
    • Save and load lighting settings with Lightmap Parameters Assets
  • Shadows
    • Enable or disable shadows
    • Real-time shadows
      • Shadow mapping
      • Set shadow distance in a scene
      • Shadow Cascades
        • Introduction to Shadow Cascades
        • Configure Shadow Cascades
    • Add ambient occlusion
    • Troubleshooting shadows
  • Reflections
    • Introduction to Reflection Probes
    • Types of Reflection Probe
    • Place a Reflection Probe
    • Add GameObjects to reflections
    • Set GameObjects to use Reflection Probes
    • Enable reflections of reflections
    • Optimize reflections
    • Troubleshooting reflections
    • Reflection Probe Inspector window reference
  • Lighting in URP
    • Introduction to lighting in the Universal Render Pipeline
    • View and control a light from its perspective in URP
    • Shadows in URP
      • Set the size of shadow atlases in URP
      • Add screen space shadows in URP
      • Screen space ambient occlusion (SSAO) in URP
        • Introduction to screen space ambient occlusion in URP
        • Add a Screen Space Ambient Occlusion Renderer Feature to a URP Renderer
        • Configure screen space ambient occlusion in URP
      • Troubleshooting shadows in URP
    • Reflections in URP
      • Reflection Probes in URP
      • Troubleshooting reflections
    • Adaptive Probe Volumes (APV) in URP
      • Introduction to Adaptive Probe Volumes
      • Use Adaptive Probe Volumes
      • Display Adaptive Probe Volumes
      • Configure the size and density of Adaptive Probe Volumes
      • Bake multiple scenes together with Baking Sets
      • Changing lighting at runtime
        • Choose how to change lighting at runtime
        • Bake different lighting setups with Lighting Scenarios
        • Update light from the sky at runtime with sky occlusion
      • Optimize loading Adaptive Probe Volume data
      • Troubleshooting Adaptive Probe Volumes
        • Light Probe validity in Adaptive Probe Volumes in URP
        • Troubleshooting dark blotches or streaks in Adaptive Probe Volumes in URP
        • Troubleshooting light leaks in Adaptive Probe Volumes in URP
      • Adaptive Probe Volume Inspector reference
      • Adaptive Probe Volumes panel reference
      • Probe Volumes Options Override reference
      • Probe Adjustment Volume component reference
    • Rendering Layers in URP
      • Introduction to Rendering Layers in URP
      • Enable Rendering Layers for Lights in URP
      • Enable Rendering Layers for Decals in URP
    • Universal Additional Light Data component in URP
    • Light component Inspector window reference for URP
  • Lighting in the Built-In Render Pipeline
    • Emit light from a GameObject in the Built-In Render Pipeline
    • Create cookies in the Built-In Render Pipeline
    • Customize how shaders contribute lightmap data in the Built-In Render Pipeline
    • Configure shadow resolution in the Built-In Render Pipeline
    • Configure a GameObject to sample more Light Probes in the Built-In Render Pipeline
      • Introduction to Light Probe Proxy Volumes in the Built-In Render Pipeline
      • Set a GameObject to use a Light Probe Proxy Volume in the Built-In Render Pipeline
      • Configure a Light Probe Proxy Volume in the Built-In Render Pipeline
      • Light Probe Proxy Volume component reference for the Built-In Render Pipeline
      • Add Light Probe Proxy Volume support to a custom shader in the Built-In Render Pipeline
    • Blend Reflection Probes in the Built-In Render Pipeline
    • Light component Inspector window reference for the Built-In-Render-Pipeline
  • Lighting reference
    • Lighting window reference
    • Lighting Settings Asset Inspector window reference
    • Lightmap Parameters Asset Inspector window reference
    • Debug Draw Modes for lighting reference
• Materials and shaders
  • Textures
    • Get started with textures
      • Introduction to textures
      • Texture types
      • Texture formats in memory
        • GPU texture format fundamentals
        • Choose a GPU texture format by platform
        • GPU texture formats reference
      • Mipmaps
    • Import a texture
    • 2D texture arrays
      • Introduction to 2D texture arrays
      • Create a 2D texture array
      • Create a 2D texture array in a script
      • Render to a 2D texture array
      • Sample a 2D texture array in a shader
    • Cubemaps
      • Introduction to cubemaps
      • Create a cubemap
      • Create a cubemap array
      • Sample a cubemap array in a shader
      • Preview a cubemap array
    • 3D textures
      • Introduction to 3D textures
      • Create a 3D texture
      • Preview a 3D texture
      • Sample a 3D texture in a shader
      • Create a 3D texture via script
    • Rendering to a texture
      • Render a camera view to a Render Texture
      • Drawing to textures with shaders via Custom Render Textures
        • Introduction to Custom Render Textures
        • Create a Custom Render Texture
        • Write a shader for a Custom Render Texture
        • Control when a Custom Render Texture updates
    • Playing video in Movie Textures
      • Create a Movie Texture
      • Play video on mobile platforms
    • Texture optimization
      • Loading textures in the background
        • Texture and mesh loading
        • Make a texture compatible with asynchronous texture loading
      • Optimizing GPU texture memory with mipmap streaming
        • Introduction to mipmap streaming
        • Enable mipmap streaming
        • Configure mipmap streaming
        • Override the mipmap level of a texture
        • Preload mipmap levels
        • Analyze mipmap streaming
      • Sparse Textures
      • Streaming Virtual Texturing
        • Streaming Virtual Texturing requirements and compatibility
        • How Streaming Virtual Texturing works
        • Enabling Streaming Virtual Texturing in your project
        • Using Streaming Virtual Texturing in Shader Graph
        • Cache Management for Virtual Texturing
        • Marking textures as "Virtual Texturing Only"
        • Virtual Texturing error material
        • Virtual Texturing Profiler module
    • Textures reference
      • Texture Import Settings window reference
      • Default texture Import Settings window reference
      • Normal Map texture Import Settings window reference
      • Editor GUI and Legacy GUI texture Import Settings window reference
      • Sprite (2D and UI) texture Import Settings window reference
      • Cubemap texture Import Settings window reference
      • 3D texture preview reference
      • Cursor texture Import Settings window reference
      • Cookie texture Import Settings window reference
      • Lightmap texture Import Settings window reference
      • Lightmap texture Import Settings window reference
      • Shadowmask texture Import Settings window reference
      • Single Channel texture Import Settings window reference
      • Movie Texture Inspector window reference
      • Render Texture Inspector window reference
      • Custom Render Texture Inspector window reference
  • Shaders
    • Introduction to shaders
    • Prebuilt shaders
      • Prebuilt shaders render pipeline compatibility reference
      • Configuring material properties in prebuilt shaders
        • Creating a material from a prebuilt shader
        • Texture maps
          • Normal maps
            • Introduction to normal maps (bump mapping)
            • Introduction to surface normals
            • Import a normal map
          • Height maps
          • Occlusion maps
          • Add light emission to a material
          • Secondary Maps (Detail Maps) and Detail Mask
      • Legacy prebuilt shaders
        • Usage and Performance of Built-in Shaders
        • Normal Shader Family
          • Vertex-Lit
          • Diffuse
          • Specular
          • Bumped Diffuse
          • Bumped Specular
          • Parallax Diffuse
          • Parallax Bumped Specular
          • Decal
          • Diffuse Detail
        • Transparent Shader Family
          • Transparent Vertex-Lit
          • Transparent Diffuse
          • Transparent Specular
          • Transparent Bumped Diffuse
          • Transparent Bumped Specular
          • Transparent Parallax Diffuse
          • Transparent Parallax Specular
        • Transparent Cutout Shader Family
          • Transparent Cutout Vertex-Lit
          • Transparent Cutout Diffuse
          • Transparent Cutout Specular
          • Transparent Cutout Bumped Diffuse
          • Transparent Cutout Bumped Specular
        • Self-Illuminated Shader Family
          • Self-Illuminated Vertex-Lit
          • Self-Illuminated Diffuse
          • Self-Illuminated Specular
          • Self-Illuminated Normal mapped Diffuse
          • Self-Illuminated Normal mapped Specular
          • Self-Illuminated Parallax Diffuse
          • Self-Illuminated Parallax Specular
        • Reflective Shader Family
          • Reflective Vertex-Lit
          • Reflective Diffuse
          • Reflective Specular
          • Reflective Bumped Diffuse
          • Reflective Bumped Specular
          • Reflective Parallax Diffuse
          • Reflective Parallax Specular
          • Reflective Normal Mapped Unlit
          • Reflective Normal mapped Vertex-lit
    • Writing custom shaders
      • Creating shaders with Shader Graph
      • Writing shaders in code
        • Introduction to writing shaders in code
        • Shader object fundamentals
        • Writing a custom shader in ShaderLab and HLSL
          • Create a shader file
          • Add a subshader in a custom shader
          • Add a shader pass in a custom shader
          • Include a shader pass with the UsePass command
          • Writing HLSL shader programs
            • Shader program fundamentals
            • Add an HLSL shader program
            • Duplicate HLSL in multiple programs
            • Shader input
              • HLSL data types in Unity
              • Use 16-bit precision in shaders
              • Input vertex data into a shader
              • Texture samplers
            • Include another HLSL file in a shader
            • Pass information to the shader compiler in HLSL
            • Writing shaders for different graphics APIs
            • GLSL in Unity
          • Setting the render state on the GPU
            • Enable conservative rasterization in a shader
            • Set the culling mode in a shader
            • Set the depth bias in a shader
            • Set the depth clip mode in a shader
            • Set the depth testing mode in a shader
            • Disable writing to the depth buffer in a shader
            • Check or write to the stencil buffer in a shader
            • Set the blending mode in a shader
            • Set the color channels the GPU renders to
            • Reduce aliasing with AlphaToMask mode
            • Group commands with the Category block
        • Adding material properties to shaders
          • Introduction to material properties
          • Add material properties
          • Texture properties
          • Access material properties in a script
          • Set shader variables with material property values
          • Control material properties in the Inspector window
        • Changing how shaders work via branching and keywords
          • Branching in shaders
            • Introduction to static and dynamic branching
            • Static and dynamic branching in a shader
            • Branch in a shader via built-in macros
              • Branch based on platform or graphics API
              • Branch based on shader model
              • Branch based on platform features
              • Branch based on Unity version
              • Branch based on shader pass or shader stage
          • Shader keywords
            • Shader keyword fundamentals
            • Shader keyword scope fundamentals
            • Choose which type of keyword to use in shaders
            • Declare shader keywords
            • Make shader behavior conditional on keywords
            • Add shader keywords to the Inspector window
            • Toggle and check shader keywords in a script
            • Built-in keywords
              • Default shader keywords
              • Add built-in keyword sets
        • Configure when and if Unity uses a shader
          • Introduction to shader tags
          • Add a shader tag to a SubShader or Pass
          • Set a shader to require URP or HDRP
          • Set a shader to require a graphics API or platform
          • Set a shader to require a shader model or GPU feature
          • Set a shader to require a package
          • Set the render queue of a shader
          • Set when Unity runs a shader pass via a LightMode tag
          • Prioritize lower quality shaders with the LOD command
          • Disable dynamic batching of a shader
          • Get tag values in a script
          • Troubleshooting package requirement definitions
      • Compute shaders
        • Introduction to compute shaders
        • Create a compute shader
        • Use HLSL and ShaderLab in a compute shader
        • Run a compute shader
        • Writing compute shaders for multiple platforms
    • Optimize shaders
    • Shaders in URP
      • Shading models in URP
      • Choose a prebuilt shader in URP
      • Assign a shader to a material in URP
      • Reduce shader variants in URP
      • Writing custom shaders in URP
        • Examples of writing a custom shader in URP
          • Create a sample scene in URP
          • Write an unlit basic shader in URP
          • Write an unlit shader with color input in URP
          • Draw a texture in a shader in URP
          • Visualize normal vectors in a shader in URP
          • Reconstruct world space positions in a shader in URP
        • Shader methods in URP
          • Import a file from the URP shader library
          • Transform positions in a custom URP shader
          • Use the camera in a custom URP shader
          • Use lighting in a custom URP shader
          • Use shadows in a custom URP shader
          • ShaderLab Pass tags in URP reference
        • Make a URP shader compatible with the SRP Batcher
      • Shader Material Inspector window reference for URP
        • Blending Modes in URP
        • Lit Shader Material Inspector window reference for URP
        • Simple Lit Shader Material Inspector window reference for URP
        • Complex Lit Shader Material Inspector window reference for URP
        • Baked Lit Shader Material Inspector window reference for URP
        • Unlit Shader Material Inspector window reference for URP
        • Terrain Lit Shader Material Inspector window reference for URP
        • Particles Lit Shader Material Inspector window reference for URP
        • Particles Simple Lit Shader Material Inspector window reference for URP
        • Particles Unlit Shader Material Inspector window reference for URP
        • Canvas Shader Graph
    • Shaders in the Built-In Render Pipeline
      • Prebuilt shaders in the Built-In Render Pipeline
        • Standard Shader in the Built-In Render Pipeline
          • Introduction to the Standard Shader in the Built-In Render Pipeline
          • Choose a metallic or specular shader in the Built-In Render Pipeline
          • Configuring material properties in the Standard Shader in the Built-In Render Pipeline
            • Make a material transparent
            • Set the color of a material in the Standard Shader
            • Configure reflections with the Standard Shader
            • Configure edge reflections (Fresnel effect)
            • Configure specular reflections in the Standard Shader
            • Configure smoothness with the Standard Shader
            • Set the Rendering Mode in the Standard Shader using a script
            • Standard Shader realistic settings in the Built-In Render Pipeline reference
          • Customize the Standard shader source code in the Built-In Render Pipeline
          • Standard Shader Material Inspector window reference for the Built-In Render Pipeline
        • Particle shaders in the Built-In Render Pipeline
          • Create a particle material in the Built-In Render Pipeline
          • Standard Particle Shaders Material Inspector window reference for the Built-In Render Pipeline
        • Autodesk Interactive shader in the Built-In Render Pipeline
      • Replace shaders at runtime in the Built-In Render Pipeline
      • Writing custom shaders in the Built-In Render Pipeline
        • Writing Surface Shaders
          • Introduction to surface shaders in the Built-In Render Pipeline
          • Surface Shader output structures in the Built-In Render Pipeline
          • Surface Shaders and rendering paths in the Built-In Render Pipeline
          • Create a surface shader in the Built-In Render Pipeline
          • Set the lighting model in a Surface Shader in the Built-In Render Pipeline
          • Optimize Surface Shaders
          • Surface Shader examples in the Built-In Render Pipeline
            • Normal mapping Surface Shader example in the Built-In Render Pipeline
            • Reflection Surface Shader examples in the Built-In Render Pipeline
            • Vertex modifier Surface Shader example in the Built-In Render Pipeline
            • Custom data Surface Shader example in the Built-In Render Pipeline
            • Final color modifier Surface Shader example in the Built-In Render Pipeline
            • Decals Surface Shader example in the Built-In Render Pipeline
            • Wrapped diffuse Surface Shader example in the Built-In Render Pipeline
            • Toon shading Surface Shader example in the Built-In Render Pipeline
            • Global illumination Surface Shader example in the Built-In Render Pipeline
            • Tessellation Surface Shader examples in the Built-In Render Pipeline
          • Surface Shader language reference for the Built-In Render Pipeline
            • Surface Shader required directives reference for the Built-In Render Pipeline
            • Surface Shader optional directives reference for the Built-In Render Pipeline
            • Surface Shader input structure reference for the Built-In Render Pipeline
        • Shader methods in the Built-In Render Pipeline
          • Import a file from the shader library in the Built-In Render Pipeline
          • Use built-in shader functions in the Built-In Render Pipeline
        • Get the current framebuffer with the GrabPass command
        • HLSL shader examples in the Built-in Render Pipeline
          • Single color shader example in the Built-In Render Pipeline
          • Checkerboard pattern shader example in the Built-In Render Pipeline
          • Simple unlit shader example in the Built-In Render Pipeline
          • Mesh normals shader example in the Built-In Render Pipeline
          • Reflections shader example in the Built-In Render Pipeline
          • Normal map texturing shader example in the Built-In Render Pipeline
          • Tri-planar texturing shader example in the Built-In Render Pipeline
          • Simple diffuse lighting shader example in the Built-In Render Pipeline
          • Ambient light shader example in the Built-In Render Pipeline
          • Shadow casting shader example in the Built-In Render Pipeline
          • Receiving shadows shader example in the Built-In Render Pipeline
          • Fog shader example in the Built-In Render Pipeline
          • Visualizing vertex data shader examples in the Built-In Render Pipeline
    • Troubleshooting shaders
      • Error and loading shaders
      • Fixing hitches or stalls
        • Shader loading
        • Prewarm shaders
        • Create a shader variant collection
        • Asynchronous shader compilation in the Editor
          • Introduction to asynchronous shader compilation
          • Enable or disable asynchronous shader compilation
          • Detect asynchronous shader compilation
          • Troubleshooting asynchronous shader compilation
      • Reducing the size or number of shaders
        • Shader compilation
        • Reducing shader variants
          • Introduction to shader variants
          • Check how many shader variants you have
          • Strip shader variants
        • Troubleshooting shader duplication from AssetBundles
        • Control how much memory shaders use
      • Debugging shaders
        • Debug shaders with Visual Studio
        • Debug shaders with PIX
    • Shader languages reference
      • ShaderLab language reference
        • Shader in ShaderLab reference
          • Shader block in ShaderLab reference
          • Properties block reference in ShaderLab
          • Fallback block in ShaderLab reference
          • Custom Editor block in ShaderLab reference
        • SubShader in ShaderLab reference
          • SubShader block in ShaderLab reference
          • LOD directive in ShaderLab reference
          • SubShader tags in ShaderLab reference
          • UsePass directive in ShaderLab reference
          • GrabPass directive in ShaderLab reference
        • Pass in ShaderLab reference
          • Pass block in ShaderLab reference
          • Name directive in ShaderLab reference
          • Pass tags in ShaderLab reference
          • Shader code blocks in ShaderLab reference
        • GPU render state commands in ShaderLab reference
          • AlphaToMask command in ShaderLab reference
          • Blend command in ShaderLab reference
          • BlendOp command in ShaderLab reference
          • ColorMask command in ShaderLab reference
          • Conservative command in ShaderLab reference
          • Cull command in ShaderLab reference
          • Offset command in ShaderLab reference
          • Stencil command in ShaderLab reference
          • ZClip command in ShaderLab reference
          • ZTest command in ShaderLab reference
          • ZWrite command in ShaderLab reference
        • PackageRequirements block in ShaderLab reference
        • ShaderLab legacy functionality reference
          • ShaderLab: legacy fog
          • ShaderLab: legacy lighting
          • ShaderLab: legacy alpha testing
          • ShaderLab: legacy texture combining
          • ShaderLab: legacy vertex data channel mapping
      • HLSL pragma directives reference
      • HLSL pragma target command reference
      • HLSL pragma require command reference
      • Built-in shader variables reference
  • Materials
    • Introduction to materials
    • Create and assign a material
    • Access material properties in a script
    • Material Variants
      • Introduction to Material Variants
      • Material Variant inheritance
      • Create, modify, and apply Material Variants
    • Material Validator in the Built-In Render Pipeline
      • Material Validator in the Built-In Render Pipeline
      • Validate and correct materials in the Built-In Render Pipeline
      • Make a shader compatible with the Material Validator in the Built-In Render Pipeline
      • Material Validator window reference for the Built-In Render Pipeline
    • Material Inspector window reference
• Visual effects
  • Particle systems
    • Choosing your particle system solution
    • Create and view a Particle System
    • Vary Particle System properties over time
    • Configuring particles
      • Particle emissions and emitters
      • Configuring global particle properties
      • Particle movement
        • Particle movement patterns
        • Particle velocity
        • Create particles that change velocity over time
        • Particle rotation
      • Particle appearance
        • Particle size
        • Change particle color
        • Particle lights and trails
        • Particle rendering and shading
        • Particle animations
      • Particle physics
        • Particle physics forces
        • Apply forces to particles
        • Particle collisions
        • Particle triggers
        • Configure a particle trigger
        • Particle System Force Field component reference
    • Access the Particle System from the Animation system
    • Custom data streams in Particle Systems
      • Particle System custom vertex streams
      • Example of Particle System Standard Shader custom vertex streams
      • Example of Particle System Surface Shader custom vertex streams
      • Define custom data formats for particles
    • Particle System optimization
      • GPU instancing for Particle Systems
        • Apply GPU instancing for a Particle System
        • Example of Particle System GPU instancing in a Surface Shader
        • Example of Particle System GPU instancing in a Custom Shader
        • Example of Particle System GPU instancing with custom vertex streams
      • Integrate the C# Job System into the Particle System workflow
    • Particle System component reference
    • Particle System module component reference
      • Activate and access Particle System modules
      • Main module reference
      • Emission module reference
      • Shape module reference
      • Velocity over Lifetime module reference
      • Noise module reference
      • Limit Velocity over Lifetime module reference
      • Inherit Velocity module reference
      • Lifetime by Emitter Speed module reference
      • Force over Lifetime module reference
      • Color over Lifetime module reference
      • Color by Speed module reference
      • Size over Lifetime module reference
      • Size by Speed module reference
      • Rotation over Lifetime module reference
      • Rotation by Speed module reference
      • External Forces module reference
      • Collision module reference
      • Triggers module reference
      • Sub Emitters module reference
      • Texture Sheet Animation module reference
      • Lights module reference
      • Trails module reference
      • Custom Data module reference
      • Renderer module reference
      • Particle System Force Field component reference
  • Decals and projectors
    • Introduction to decals and projection
    • Decals in URP
      • Introduction to decals in URP
      • Create a decal via a Decal Renderer Feature in URP
      • Create a decal via a Decal Projector in URP
      • Decal Renderer Feature reference
      • Decal Projector component reference for URP
      • Decal Shader Graph reference for URP
    • Decals in the Built-In Render Pipeline
      • Prepare materials for projection in the Built-In Render Pipeline
      • Projector component reference for the Built-In Render Pipeline
  • Lens flares
    • Introduction to lens flare effects
    • Lens flares in URP
      • Choose a lens flare type in URP
      • Add lens flares in URP
      • Add screen space lens flares in URP
      • Lens Flare (SRP) component reference for URP
      • Lens Flare (SRP) Data Asset in URP
      • Screen Space Lens Flare override reference for URP
    • Lens flares in the Built-In Render Pipeline
      • Create a lens flare
      • Configuring Flare elements
      • Flare asset reference
      • Lens Flare component reference
      • Flare Layer component reference
  • Light halos
    • Create and configure a halo light effect
    • Halo component reference
  • Lines, trails, and billboards
    • Rendering lines
      • Rendering lines
      • Draw and configure a line in 3D space
      • Line Renderer component reference
    • Rendering trails
      • Rendering trails for moving GameObjects
      • Draw and configure a trail behind a moving GameObject
      • Trail Renderer component reference
  • Visual Effect Graph
    • VFX Project Settings
    • Visual Effect Graph asset
    • Block Subgraph asset
    • Operator Subgraph asset
    • Visual Effect component
    • Property Binder component
• Rendering
  • Render pipelines
    • Introduction to render pipelines
    • Scriptable Render Pipeline fundamentals
    • Choosing a render pipeline
      • Choose a render pipeline
      • Render pipeline feature comparison reference
      • Set up a render pipeline
      • Change or detect the active render pipeline
    • Using the Universal Render Pipeline
      • Introduction to the Universal Render Pipeline
      • Requirements and compatibility for URP
      • What's new in URP 17 (Unity 6)
      • Get started with URP
        • Universal Render Pipeline fundamentals
          • Rendering in the Universal Render Pipeline
          • Rendering paths in URP
            • Introduction to rendering paths in URP
            • Set the rendering path in URP
            • Deferred rendering path in URP
              • Render passes in the Deferred rendering path in URP
              • G-buffer layout in the Deferred rendering path in URP
              • Limitations of the Deferred rendering path in URP
              • Make a shader compatible with the Deferred rendering path in URP
              • Enable accurate G-buffer normals in the Deferred rendering path in URP
              • Deferred rendering path code files reference for URP
            • Forward+ rendering path in URP
              • Introduction to the Forward+ rendering path in URP
              • Troubleshooting the Forward+ rendering path in URP
        • Installing and upgrading URP
          • Creating a URP project
            • Create a new project that uses URP
            • Scene templates in URP
            • Import a package sample in URP
            • Package samples reference for URP
            • Install URP into an existing project
          • Upgrading from the Built-In Render Pipeline to URP
            • Convert assets using the Render Pipeline Converter
            • Upgrading shaders to URP from the Built-In Render Pipeline
              • Convert shaders to URP with the Render Pipeline Converter
              • Upgrade custom shaders for URP compatibility
            • Convert quality settings from the Built-In Render Pipeline to URP
            • Find Built-In Render Pipeline quality settings in URP
          • Upgrade URP
            • Upgrade to URP 17 (Unity 6)
            • Upgrade to URP 16 (Unity 2023.2)
            • Upgrade to URP 15 (Unity 2023.1)
            • Upgrade to URP 14 (Unity 2022.2)
            • Upgrade to URP 13 (Unity 2022.1)
            • Upgrade to URP 12 (Unity 2021.2)
            • Upgrade to version 11.0.x of the Universal Render Pipeline
            • Upgrade to version 10.1.x of the Universal Render Pipeline
            • Upgrade to version 10.0.x of the Universal Render Pipeline
            • Upgrade to version 9.0.x of the Universal Render Pipeline
            • Upgrade to version 8.2.x of the Universal Render Pipeline
            • Upgrade to version 8.1.x of the Universal Render Pipeline
            • Upgrade to version 8.0.0 of the Universal Render Pipeline
            • Upgrade to version 7.4.0 of the Universal Render Pipeline
            • Upgrade to version 7.3.0 of the Universal Render Pipeline
            • Upgrade to version 7.2.0 of the Universal Render Pipeline
            • Upgrade from the Lightweight Render Pipeline to the Universal Render Pipeline
          • Known issues in URP
        • Configure for better performance in URP
      • Graphics quality settings in URP
        • Universal Render Pipeline asset
        • Display advanced properties in a URP Asset
        • Change the active URP Asset at runtime
        • Change URP Asset settings at runtime
        • Configure settings with the URP Config package
      • Add anti-aliasing in the Universal Render Pipeline
      • Custom rendering and post-processing in URP
        • Introduction to Scriptable Render Passes in URP
        • Adding pre-built effects via Renderer Features in URP
          • Add a Renderer Feature to a URP Renderer
          • Example of creating a custom rendering effect via the Render Objects Renderer Feature in URP
          • Render Objects Renderer Feature reference for URP
        • Custom render pass workflow in URP
        • Render graph system in URP
          • Introduction to the render graph system in URP
          • Write a render pass using the render graph system in URP
          • Textures in the Render Graph system in URP
            • Create a texture in the render graph system in URP
            • Import a texture into the render graph system in URP
            • Use a texture in a render pass in URP
            • Transfer a texture between render passes in URP
            • Best practice for blitting in URP
          • Frame data in the render graph system in URP
            • Get data from the current frame in URP
            • Get data from previous frames in URP
            • Add textures to the camera history
            • Get the current framebuffer via framebuffer fetch in URP
            • Frame data textures reference for URP
          • Draw objects in the render graph system in URP
          • Compute shaders in the render graph system in URP
            • Run a compute shader in a render pass in URP
            • Create input data for a compute shader in URP
          • Analyze a render graph in URP
          • Use Compatibility Mode APIs in render graph render passes
          • Render Graph Viewer window reference for URP
        • Adding a Scriptable Render Pass to the frame rendering loop in URP
          • Injecting a render pass via a Scriptable Renderer Feature in URP
            • Introduction to Scriptable Renderer Features in URP
            • Create a Scriptable Renderer Feature in URP
            • Apply a Scriptable Renderer Feature to a specific camera type in URP
            • Example of a complete Scriptable Renderer Feature in URP
            • Scriptable Renderer Feature API reference for URP
          • Inject a render pass via scripting in URP
          • Injection points reference for URP
        • Compatibility Mode in URP
          • Write a Scriptable Render Pass in Compatibility Mode in URP
          • Example of a complete Scriptable Renderer Feature in Compatibility Mode in URP
          • Example of performing a full screen blit in Compatibility Mode in URP
          • Scriptable Render Pass Compatibility Mode API reference for URP
      • Universal Render Pipeline reference
        • Universal Render Pipeline asset reference for URP
        • Universal Renderer asset reference for URP
        • Graphics settings window reference for URP
    • Using the High Definition Render Pipeline
    • Using the Built-In Render Pipeline
      • Hardware requirements for the Built-in Render Pipeline
      • Graphics quality settings in the Built-In Render Pipeline
        • Graphics tiers in the Built-In Render Pipeline
        • Configure graphics tiers in the Built-In Render Pipeline
      • Rendering paths in the Built-In Render Pipeline
        • Introduction to rendering paths in the Built-In Render Pipeline
        • Forward rendering path in the Built-In Render Pipeline
        • Deferred rendering path in the Built-In Render Pipeline
        • Legacy Vertex Lit rendering path in the Built-In Render Pipeline
      • Rendering order in the Built-In Render Pipeline
        • Render queues and sorting behaviours in the Built-in Render Pipeline
        • Set the render queue for a material in the Built-In Render Pipeline
        • Set how a camera sorts materials in the Built-In Render Pipeline
      • Custom rendering in the Built-In Render Pipeline
        • CommandBuffer fundamentals in the Built-In Render Pipeline
        • CameraEvent and LightEvent events order reference for the Built-In Render Pipeline
  • Post-processing and full-screen effects
    • Introduction to post-processing
    • Post-processing effect availability reference
    • Post-processing and full-screen effects in URP
      • Post-processing in URP
        • Introduction to post-processing in URP
        • Add post-processing in URP
        • Volumes in URP
          • Understand volumes in URP
          • Set up a volume in URP
          • Create a Volume Profile in URP
          • Configure Volume Overrides in URP
          • Volume component reference for URP
        • Post-processing Volume Overrides reference for URP
          • Bloom Volume Override reference for URP
          • Channel Mixer Volume Override reference for URP
          • Chromatic Aberration Volume Override reference for URP
          • Color Adjustments Volume Override reference for URP
          • Color Curves Volume Override reference for URP
          • Depth of Field in URP
            • Depth of Field Volume Override in URP
            • Depth of Field Volume Override reference for URP
          • Film Grain Volume Override reference for URP
          • Lens Distortion Volume Override reference for URP
          • Lift Gamma Gain Volume Override reference for URP
          • Motion Blur Volume Override reference for URP
          • Panini Projection Volume Override reference for URP
          • Add screen space lens flares in URP
          • Shadows Midtones Highlights Volume Override reference for URP
          • Split Toning Volume Override reference for URP
          • Tonemapping Volume Override reference for URP
          • Vignette Volume Override reference for URP
          • White Balance Volume Override reference for URP
        • Custom post-processing in URP
          • Create a low-code custom post-processing effect in URP
          • Create a custom post-processing effect with Volume support in URP
          • Full Screen Pass Renderer Feature reference for URP
          • Creating a full-screen shader in Shader Graph in URP
            • Fullscreen Master Stack reference for Shader Graph in URP
            • Fullscreen Master Stack in Shader Graph reference for URP
  • Color
    • Color spaces
      • Color spaces in Unity
      • Differences between linear and gamma color space
      • Gamma color space
      • Linear color space
        • Introduction to linear color space in Unity
        • Gamma Textures in linear color space
        • Linear textures
      • Set a project's color space
      • Disable sRGB sampling for a texture
    • High dynamic range (HDR)
      • Introduction to high dynamic range (HDR)
      • HDR color picker reference
      • Color space and HDR in the Built-in Render Pipeline
        • HDR in the Built-in Render Pipeline
      • HDR
        • HDR Output in URP
        • HDR Output debug views in URP
        • Enable HDR Output in URP
        • Implement an HDR Output compatible custom overlay in URP
        • Troubleshooting Scriptable Render Passes with HDR Output in URP
  • Graphics performance and profiling
    • Reduce rendering work on the CPU or GPU
    • Optimizing draw calls
      • Introduction to optimizing draw calls
      • GPU instancing
        • Introduction to GPU instancing
        • Enable GPU instancing
        • Troubleshooting GPU instancing
      • Batching draw calls
        • Introduction to batching draw calls
        • Enable draw call batching
        • Batching static GameObjects
          • Introduction to static batching
          • Enable static batching
        • Batching moving GameObjects
          • Introduction to dynamic batching
          • How Unity batches moving GameObjects
          • Enable dynamic batching
      • Combine meshes manually
    • Profile rendering
      • Frame Debugger
        • Introduction to the Frame Debugger
        • Debug a frame
        • Check or find a rendering event
        • Attach the Frame Debugger to a built project
        • Share information about a rendering event
      • Frame Timing Manager
        • Introduction to the Frame Timing Manager
        • Enable the FrameTimingManager
        • Get frame timing data
        • Record frame timing data
        • Troubleshooting the Frame Time Manager
      • Rendering Profiler module
      • GPU Usage Profiler module
    • Graphics performance and profiling in URP
      • Understand performance in URP
      • Analyze your project in URP
      • Reducing rendering work on the CPU or GPU in URP
        • Reducing rendering work on the CPU in URP
          • Enable the GPU Resident Drawer in URP
          • Make a GameObject compatible with the GPU Resident Drawer in URP
          • Enable GPU occlusion culling in URP
        • Adjust settings to improve performance in URP
        • Optimize for untethered XR devices in URP
      • Optimizing draw calls in URP
        • Scriptable Render Pipeline (SRP) Batcher in URP
          • Scriptable Render Pipeline Batcher in URP
          • Check whether a GameObject is compatible with the SRP Batcher in URP
          • Enable the SRP Batcher in URP
          • Troubleshoot the SRP Batcher in URP
          • Remove SRP Batcher compatibility for GameObjects in URP
        • BatchRendererGroup API in URP
          • Introduction to the BatchRendererGroup API in URP
          • Set up your project for the BatchRendererGroup API in URP
          • Creating a renderer with the BatchRendererGroup API in URP
            • Initialize a BatchRendererGroup object in URP
            • Register meshes and materials with the BatchRendererGroup API in URP
            • Create batches with the BatchRendererGroup API in URP
            • Create draw commands with the BatchRendererGroup API in URP
          • Writing custom shaders for the BatchRendererGroup API
            • DOTS Instancing shaders in URP
            • Support DOTS Instancing in a a custom shader in URP
            • Declare DOTS Instancing properties in a custom shader in URP
            • Access DOTS Instancing properties in a custom shader
            • Best practice for DOTS Instancing shaders in URP
            • DOTS Instancing shader examples in URP
              • Example of a DOTS Instancing shader that accesses per-instance data in URP
              • Example of a DOTS Instancing shader that accesses constant data in URP
              • Example of using UNITY_DOTS_INSTANCED_PROP macros in a DOTS Instancing shader in URP
            • DOTS Instancing shader macros reference for URP
            • DOTS Instancing shader functions reference for URP
      • Rendering Debugger in URP
        • Enable the Rendering Debugger in URP
        • Add controls to the Rendering Debugger in URP
        • Rendering Debugger window reference for URP
    • Graphics performance and profiling in the Built-In Render Pipeline
      • Creating custom shaders that support GPU instancing in the Built-In Render Pipeline
        • GPU Instancing in the Built-In Render Pipeline
        • Add per-instance properties to GPU instancing shaders in the Built-In Render Pipeline
        • Examples of GPU instancing shaders in the Built-In Render Pipeline
          • Example of a Surface Shader that supports GPU Instancing in the Built-In Render Pipeline
          • Example of an HLSL shader that supports GPU Instancing in the Built-In Render Pipeline
          • Example of changing per-instance data at runtime in the Built-In Render Pipeline
        • Prevent Unity stripping GPU instancing shaders in the Built-In Render Pipeline
        • GPU instancing shader reference for the Built-In Render Pipeline
    • Graphics performance and profiling reference
      • Frame Debugger window reference
      • Frame Debugger Event Information reference
      • Rendering Statistics window reference
• Audio
  • Audio overview
  • Audio files
  • Tracker Modules
  • Audio Mixer
    • An overview of the concepts and Audio Mixer
    • Specifics on the Audio Mixer window
    • AudioGroup Inspector
    • Overview of Usage and API
  • Native audio plug-in SDK
    • Develop a native DSP audio plug-in
    • Customize the GUI for your audio plug-in
    • Use your native audio DSP plug-in and GUI in Unity
    • Example native audio plug-ins included in the SDK
    • Audio Spatializer SDK
  • Audio playlist randomization
    • Audio Random Container reference
    • Audio Random Container fundamentals
    • Create a randomized playlist with the Audio Random Container
  • Audio Profiler module
  • Ambisonic Audio
    • Develop an ambisonic audio decoder
  • Audio Reference
    • Audio Clip
    • Audio Listener
    • Audio Source
    • Audio Mixer
    • Audio Filters
      • Audio Low Pass Filter
      • Audio High Pass Filter
      • Audio Echo Filter
      • Audio Distortion Filter
      • Audio Reverb Filter
      • Audio Chorus Filter
    • Audio Effects
      • Audio Low Pass Effect
      • Audio High Pass Effect
      • Audio Echo Effect
      • Audio Flange Effect
      • Audio Distortion Effect
      • Audio Normalize Effect
      • Audio Parametric Equalizer Effect
      • Audio Pitch Shifter Effect
      • Audio Chorus Effect
      • Audio Compressor Effect
      • Audio SFX Reverb Effect
      • Audio Low Pass Simple Effect
      • Audio High Pass Simple Effect
    • Reverb Zones
    • Microphone
    • Audio Settings
• Video and cutscenes
  • Video sources
    • Import and preview video clips
    • Use video sources
    • Understanding video files
    • Video file compatibility
    • Video Clip Importer
    • Video transparency support
  • Video Player
    • Video Player component
    • Migrating from MovieTexture to VideoPlayer
    • Clock management with the Video Player component
    • Panoramic video
  • Video Profiler module
• Scripting
  • Get started with scripting
    • Introduction to scripting
    • Creating scripts
    • Naming scripts
    • Inspecting scripts
    • Fundamental Unity types
      • Object
      • GameObject
      • MonoBehaviour
      • ScriptableObject
      • Transform
  • Environment and tools
    • Integrated development environment (IDE) support
    • Automated testing
    • Unity .NET features
      • .NET profile support
      • .NET system libraries
      • Third-party .NET libraries
      • Referencing additional class library assemblies
      • C# compiler
      • C# reflection overhead
      • Garbage collection
  • Object-oriented development
    • Managing time and frame rate
      • Per-frame updates
      • Fixed updates
      • Handling variation in time
      • In-game time and real time
      • Capturing frame rate
    • Instantiating prefabs at runtime
      • Introduction to instantiating prefabs
      • Build a structure with prefabs
      • Instantiate projectiles and explosions
      • Replace a character with a ragdoll or wreck
    • Handling events
      • Event functions
      • Order of execution for event functions
      • Inspector-configurable custom events
    • Splitting tasks across frames
    • Interacting with web servers
      • Common operations: using the HLAPI
        • Retrieving text or binary data from an HTTP Server (GET)
        • Retrieving a Texture from an HTTP Server (GET)
        • Downloading an AssetBundle from an HTTP server (GET)
        • Sending a form to an HTTP server (POST)
        • Uploading raw data to an HTTP server (PUT)
      • Advanced operations: Using the LLAPI
        • Creating UnityWebRequests
        • Creating UploadHandlers
        • Creating DownloadHandlers
    • Adding functionality to objects at runtime
      • Property bags
      • Property visitors
      • Property paths
      • Use PropertyVisitor to create a property visitor
      • Use low-level APIs to create a property visitor
    • Moving objects with vectors
    • Rotation and oriention with quaternion
    • Using common math functions
    • Using randomness
    • Gizmos and Handles
    • Null references
    • Unity attributes
  • Compilation and code reload
    • Script compilation
      • Special folders and script compilation order
      • Conditional compilation
        • Conditional compilation in Unity
        • Unity scripting symbol reference
        • Custom scripting symbols
        • Test conditional compilation
      • Organizing scripts into assemblies
        • Introduction to assemblies in Unity
        • Creating assembly assets
        • Referencing assemblies
        • Conditionally including assemblies
        • Assembly metadata and compilation details
        • Assembly Definition properties reference
        • Assembly Definition Reference properties reference
        • Assembly Definition File Format reference
    • Scripting backends
      • Mono overview
      • IL2CPP Overview
        • Handling platform specific settings for IL2CPP additional arguments
        • Linux IL2CPP cross-compiler
        • Windows Runtime support
        • Managed stack traces with IL2CPP
      • Scripting restrictions
      • Managed code stripping
        • The Unity linker
    • Code reload in the Unity Editor
      • Configurable Enter Play Mode
        • Domain Reloading
        • Scene Reloading
        • Details of disabling domain and scene reload
      • Running project code on Editor launch
    • Script serialization
      • Serialization rules
      • Custom serialization
      • How Unity uses serialization
      • JSON Serialization
      • Script serialization errors
      • Serialization best practice
    • Integrating third-party code libraries (plug-ins)
      • Import and configure plug-ins
      • Managed plug-ins
      • Native plug-ins
      • Profiling low-level native plug-ins
      • Building plug-ins for desktop platforms
      • Low-level native plug-in interface
        • Low-level native plug-in rendering extensions
        • Low-level native plug-in Shader compiler access
        • Memory Manager API for low-level native plug-ins
          • IUnityMemoryManager API reference
  • Code optimization
    • Asynchronous programming
    • Job system
      • Job system overview
      • Jobs overview
      • Thread safe types
        • Implement a custom native container
        • Copying NativeContainer structures
        • Custom NativeContainer example
      • Create and run a job
      • Job dependencies
      • Parallel jobs
  • Debugging and diagnostics
    • Debug C# code in Unity
    • The Debug class
    • Log files reference
    • Stack trace logging
    • Roslyn analyzers and source generators
      • Create and use a source generator
      • Install and use an existing analyzer or source generator
      • Create rule set files
      • Analyzer scope and diagnostics
• Optimization
  • Memory in Unity
    • Managed memory
      • Garbage collector overview
        • Incremental garbage collection
        • Disabling garbage collection
        • Garbage collection best practices
    • Native memory
      • Dynamic heap allocator
      • Bucket allocator
      • Dual thread allocator
      • Thread Local Storage (TLS) stack allocator
      • Thread-safe linear allocator
      • Customize allocators
  • Unity Profiler
    • Profiler introduction
    • Collect performance data
      • Collect performance data introduction
      • Connecting the Profiler to a data source
        • Collect performance data on a target platform
        • Collect performance data in Play mode
        • Collect performance data about the Unity Editor
        • Build Profiles Profiler settings
      • Data visualization
        • Profiler modules introduction
        • Activating and enabling Profiler modules
        • CPU performance data
          • CPU Usage Profiler module introduction
          • Navigating the CPU Usage Profiler module
          • CPU Usage Profiler module reference
        • Memory performance data
          • Memory Profiler module introduction
          • Accessing memory counters in players
          • Memory Profiler module reference
        • File Access Profiler module reference
        • GPU Usage Profiler module
        • Highlights Profiler module reference
      • Play mode and Editor profile samples
      • Instrument all function calls
    • Navigating the Profiler window
    • Running the Profiler in its own process
    • Customizing the Profiler
      • Creating custom Profiler counters
      • Creating Custom Profiler modules
        • Profiler Module Editor
      • Creating a custom module details panel
    • Profiler window reference
    • Profiler Preferences reference
    • Profiler command line arguments
    • Profiler markers reference
  • Profiling tools
    • Analyzing profiler traces
  • Understanding optimization in Unity
    • Asset auditing
    • Strings and text
    • The Resources folder
    • General Optimizations
    • Special optimizations
  • Asset loading metrics
• Platform development
  • Cross-platform features and considerations
    • Troubleshooting common cross-platform issues
    • Using Unity as a Library in other applications
    • Deep linking
    • Xcode frame debugger Unity integration
    • Build path requirements for target platforms
    • Graphics API support
      • Configure graphics APIs
      • DirectX
      • Metal
        • Metal requirements and compatibility
        • Debug Metal graphics
        • Optimize Metal graphics
      • OpenGL Core
    • Reducing the file size of your build
    • Build Player Pipeline
  • Android
    • Introducing Android
      • Android requirements and compatibility
      • Gradle for Android
      • Android App Manifest
      • Unity Launcher Manifest
      • Unity Library Manifest
      • How Unity builds Android applications
    • Getting started with Android
      • Android environment setup
      • Android Player settings
      • Android keystores
        • Keystore Manager window reference
        • Create a new keystore
        • Add keys to a keystore
        • Load a keystore
    • Developing for Android
      • Android mobile scripting
      • Input for Android devices
      • Android application size restrictions
        • Introduction to asset splitting
        • APK expansion files
          • APK expansion files in Unity
          • Manually install an APK expansion file
          • Host APK expansion files
        • Play Asset Delivery
          • Asset packs in Unity
          • Set up Play Asset Delivery
          • Create a custom asset pack
          • Manage asset packs at runtime
      • Graphics for Android
        • Screen configuration
        • Single-pass stereo rendering for Android
        • Framebuffer orientation
        • Allow or deny Vulkan API usage
      • Testing and debugging
        • Debug on Android devices
        • Android symbols
        • Simulate an Android device
        • Collecting performance data on an Android device
        • Unity Remote
        • Application patching
      • Optimization for Android
        • Android thread configuration
        • Optimize application startup times
        • Game state hinting
        • Optimize for user preferences
        • Large screen and foldable device support
      • Create and use plug-ins in Android
        • Android plug-in types
          • Android Library Projects and Android Archive plug-ins
            • Introducing Android Library Projects and Android Archive plug-ins
            • Import an Android Library Project
            • Import an Android Archive plug-in
          • JAR plug-ins
          • Native plug-ins for Android
            • Introducing native plug-ins for Android
            • Create a native plug-in for Android
            • Import a native plug-in for Android
            • Call native plug-in for Android code
          • Java and Kotlin source plug-ins
        • Call Java and Kotlin plug-in code from C# scripts
      • Integrating Unity into Android applications
      • Android application entry points
        • The Activity application entry point
          • Activity requirements and compatibility
          • Extend the default Unity activity
            • Create a custom activity
            • Specify Android Player command-line arguments
        • The GameActivity application entry point
          • GameActivity requirements and compatibility
          • Modify GameActivity bridge code
          • Update the GameActivity library
        • Set the application entry point for your Android application
      • Deep linking on Android
      • Device features and permissions
        • Android permissions in Unity
        • Declare permissions for an application
        • Request runtime permissions
      • Handle Android crashes
      • Quit a Unity Android application
    • Building and delivering for Android
      • Gradle templates
      • Gradle template variables
      • Modify Gradle project files
        • Modify the Gradle project files for a Unity application
        • Modify Gradle project files with Gradle template files
        • Modify Gradle project files with the Android Project Configuration Manager
        • Modify Gradle project files with Android Studio
      • Android Build Settings reference
      • Build your application for Android
      • Export an Android project
      • Optimize distribution size
      • Digital distribution services for Android
        • Delivering to Google Play
  • Dedicated Server
    • Introduction to Dedicated Server
    • Get started with Dedicated Server
      • Dedicated Server requirements
      • Dedicated Server Player settings
      • Dedicated Server optimizations
    • Build your application for Dedicated Server
    • Dedicated Server AssetBundles
    • Desktop headless mode
  • iOS
    • Introducing iOS
      • iOS requirements and compatibility
      • How Unity builds iOS applications
      • Structure of a Unity Xcode project
    • Getting started with iOS
      • iOS environment setup
      • iOS Player settings
    • Developing for iOS
      • iOS Scripting
      • Input for iOS devices
        • iOS input overview
        • Game Controller support
          • Detect Game Controllers
          • Handle Game Controller input
      • Test and debug an iOS application
        • Device Simulator for iOS
        • Collecting performance data on an iOS device
        • Unity Remote
        • Managed stack traces on iOS
        • Troubleshooting on iOS devices
        • Report crash bugs for iOS
      • Optimize performance for iOS
        • Optimize for mobile
        • Measure performance with the built-in profiler
        • Optimize the size of the iOS Player
      • Native plug-ins for iOS
        • Create a native plug-in for iOS
        • Use your native plug-in for iOS
          • Call native plug-ins for iOS
          • Callback from native code
          • Automated plug-in integration
          • Bonjour browser sample
      • Integrating Unity into native iOS applications
      • Deep linking on iOS
      • iOS authorizations in Unity
      • Prepare your application for in-app purchases
      • Social API
    • Building and delivering for iOS
      • Build an iOS application
      • iOS Build Settings reference
      • App thinning
        • On-demand resources
        • App slicing
      • Apple’s privacy manifest policy requirements
  • Linux
    • Linux Player settings
    • Linux Build Settings reference
    • Build a Linux application
    • Troubleshooting the Linux Editor issues
  • macOS
    • macOS player settings
    • macOS development
      • Deep linking for macOS
      • Use IL2CPP with macOS
    • Build and distribute a macOS application
      • Build a macOS application
      • macOS Build Settings reference
      • Code sign and notarize your macOS application
        • Code sign your application
        • Notarize with Xcode and command-line tools
        • Notarize with altool
      • Deliver applications to the Mac App Store
  • tvOS
    • Requirements and compatibility
    • tvOS Player Settings
    • Developing for tvOS
      • Supporting input devices on tvOS
      • Setting up app navigation from the Unity UI
      • Debugging Your Application
    • Build your application for tvOS
  • Universal Windows Platform
    • Introduction to Universal Windows Platform
      • UWP requirements and compatibility
      • Integrate Unity into UWP applications
    • Get started with Universal Windows Platform
      • Set up your environment for UWP
      • UWP Player settings
    • Develop for Universal Windows Platform
      • Use deep linking on UWP
      • Connect the profiler to UWP
      • UWP scripting symbols
      • IL2CPP scripting backend for UWP
        • Use UWP plug-ins with IL2CPP
          • Use managed UWP plug-ins
          • Call and implement native UWP plug-ins
          • Author native UWP plug-ins
          • Use P/Invoke
        • Debug UWP applications with IL2CPP
          • Debug C# code
          • Debug generated C++ code
      • WinRT API in C# scripts for UWP
      • AppCallbacks class reference
      • Command line arguments for UWP
      • Association launching for UWP
    • Build and deliver for Universal Windows Platform
      • UWP Build Settings reference
      • Generate your Visual Studio C++ solution
      • Package a UWP app in Visual Studio
      • Deploy a UWP application
      • Deploy a Windows or UWP app with the Windows Device Portal
  • visionOS
  • Web
    • Web introduction
      • Web browser compatibility
      • Technical limitations
      • Web prerequisites
    • Web development
      • Web Player settings
      • Interaction with browser scripting
        • Code examples: Call JavaScript and C/C++/C# functions in Unity
        • Set up your JavaScript plug-in
        • Call JavaScript functions from Unity C# scripts
        • Call Unity C# script functions from JavaScript
        • Call C/C++/C# functions from Unity C# scripts
        • Compile a static library as a Unity plug-in
        • Create callbacks between Unity C#, JavaScript, and C/C++/C# code
        • JavaScript interface in Unity Web builds
        • Replace deprecated browser interaction code
      • Web native plug-ins for Emscripten
      • Memory in Unity Web
      • Cache behavior in Web
      • Web graphics
      • Audio in Web
      • Video playback in Web
      • Texture compression in Web
      • Embedded resources in Web
      • Input in Web
      • Configure a Web Canvas size
      • Web browser access to device features
      • Web networking
      • WebAssembly 2023
        • Prerequisites for WebAssembly 2023
        • Optimize your Web build with WebAssembly 2023
        • Enable WebAssembly 2023
      • Web performance considerations
      • Debug and troubleshoot Web builds
    • Build and distribute a Web application
      • Web Build Settings
      • Web Build folder
      • AssetBundles in Web
      • Distribution size and code stripping
      • Optimize your Web build
        • Recommended Graphics settings to optimize your Web build
        • Recommended Player settings to optimize your Web build
        • Recommended Quality settings to optimize your Web build
        • Use C# code to enable optimization settings
        • Remove unused resources from your Web build
      • Optimize Web platform for mobile
      • Web templates
      • Deploy a Web application
      • Server configuration code samples
  • Windows
    • Integrating Unity into Windows applications
    • Windows Player settings
    • Develop for Windows
      • Visual Studio project generation for Windows
      • Windows debugging
      • Windows integrity control
      • Windows Player: IL2CPP Scripting Backend
    • Windows Build Settings reference
  • XR
    • Overview
      • XR packages
      • AR development in Unity
      • VR development in Unity
      • XR architecture
    • XR project set up
      • Choose XR provider plug-ins
      • Create an XR project
      • Set up an XR scene
        • XR input options
        • XR Origin
        • XR Plug-in Management settings
    • Run an XR application
    • XR graphics
      • Universal Render Pipeline compatibility in XR
      • Stereo rendering
        • Single-pass instanced rendering and custom shaders
      • Foveated rendering
      • VR frame timing
    • XR audio
      • Audio Spatializers
    • XR API reference
    • Unity XR SDK
      • Provider setup
        • Creating an XR provider
        • UnitySubsystemsManifest.json
      • Runtime discovery and activation of subsystems
      • Subsystems
        • XR SDK Input subsystem
        • XR SDK Display subsystem
        • XR SDK Meshing subsystem
      • Interfaces
        • XR SDK PreInit interface
        • XR SDK Stats interface
• Unity Services
  • Unity IAP
    • Setting up Unity IAP
      • Configuring for Apple App Store and Mac App Store
      • Configuring for Google Play Store
      • Configuring for Windows Store
      • Configuration for the Amazon Appstore
    • Cross Platform Guide
      • Codeless IAP
      • Defining products
      • Subscription Product support
      • Initialization
      • Browsing Product Metadata
      • Initiating Purchases
      • Processing Purchases
      • Handling purchase failures
      • Restoring Transactions
      • Purchase Receipts
      • Receipt validation
      • Store Extensions
      • Cross-store installation issues with Android in-app purchase stores
    • Store Guides
      • iOS & Mac App Stores
      • Universal Windows Platform
      • Google Play
      • Amazon Appstore and Amazon Underground Store
    • Implementing a Store
      • Initialization
      • Retrieving products
      • Handling purchases
      • Store Modules
        • Registering your store
        • Store Configuration
        • Store Extensions
  • Unity Distribution Portal
    • Getting started with UDP
    • Distributing your game with UDP
    • Implementing IAP products
    • Testing your game in the UDP sandbox
    • Managing and publishing your game on the UDP console
    • Using UDP with other services
      • Using Firebase with UDP builds
    • UDP reference
      • UDP API
      • UDP SDK data collection
    • UDP troubleshooting
• Glossary