Manual
Scripting API
unity.com
Version:
Unity 6.1 Alpha
(6000.1)
Versions with this page:
2023.2
2023.1
2022.3
2022.2
2022.1
2021.3
2021.2
2021.1
2020.3
2020.2
2020.1
2019.4
2019.3
2019.2
2019.1
2018.4
2018.3
2018.2
2018.1
2017.4
2017.3
2017.2
2017.1
5.6
5.5
5.4
5.3
5.2
Versions without this page:
Supported
Legacy
Language :
English
English
中文
日本語
한국어
Unity Manual
Version: Unity 6.1 Alpha
Select a different version
2023.2 - Supported
2023.1 - Supported
2022.3 - Supported
2022.2 - Not supported
2022.1 - Not supported
2021.3 - Supported
2021.2 - Not supported
2021.1 - Not supported
2020.3 - Not supported
2020.2 - Not supported
2020.1 - Not supported
2019.4 - Not supported
2019.3 - Not supported
2019.2 - Not supported
2019.1 - Not supported
2018.4 - Not supported
2018.3 - Not supported
2018.2 - Not supported
2018.1 - Not supported
2017.4 - Not supported
2017.3 - Not supported
2017.2 - Not supported
2017.1 - Not supported
5.6 - Not supported
5.5 - Not supported
5.4 - Not supported
5.3 - Not supported
5.2 - Not supported
Language :
English
English
中文
日本語
한국어
Unity 6.1 User Manual (Alpha)
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.1 (Alpha)
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
2D Tilemap Extras
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 Diagnostics
Cloud Save
Cloud Services Apis
Code Coverage
Collections
Dedicated Server
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
Lobby
Localization
Magic Leap XR Plugin
Matchmaker
Mathematics
Memory Profiler
Microsoft GDK API
Microsoft GDK Tools
ML Agents
Mobile Notifications
Moderation
Multiplay
Multiplayer Play Mode
Multiplayer Services
Multiplayer Tools
Multiplayer Widgets
Muse Sprite
Muse Texture
Netcode for Entities
Netcode for GameObjects
Oculus XR Plugin
OpenXR Plugin
Performance testing API
Player Accounts
Polybrush
PolySpatial Extensions
PolySpatial visionOS
Post Processing
ProBuilder
Profile Analyzer
Push Notifications
Recorder
Relay
Remote Config
Scriptable Build Pipeline
Sentis
Services Tooling
SharpZipLib
Splines
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
Cloud Code
Deployment
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 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
Manage 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
BindableElement
VisualElement
BoundsField
BoundsIntField
Box
Button
ColorField
CurveField
DoubleField
DropdownField
EnumField
EnumFlagsField
FloatField
Foldout
GradientField
GroupBox
Hash128Field
HelpBox
IMGUIContainer
Image
InspectorElement
IntegerField
Label
LayerField
LayerMaskField
LongField
ListView
MaskField
MinMaxSlider
MultiColumnListView
MultiColumnTreeView
ObjectField
PopupWindow
ProgressBar
PropertyField
RadioButton
RadioButtonGroup
RectField
RectIntField
RepeatButton
RenderingLayerMaskField
ScrollView
Scroller
Slider
SliderInt
Tab
TabView
TagField
TextElement
TextField
TemplateContainer
Toggle
ToggleButtonGroup
Toolbar
ToolbarBreadcrumbs
ToolbarButton
ToolbarMenu
ToolbarPopupSearchField
ToolbarSearchField
ToolbarSpacer
ToolbarToggle
TreeView
TwoPaneSplitView
UnsignedLongField
UnsignedIntegerField
Vector2Field
Vector2IntField
Vector3Field
Vector3IntField
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
Color emojis
Advanced Text Generator
UITK 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
Unity multiplayer overview
Use the Multiplayer Center
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
Create a Render 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 Preview)
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 Preview)
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
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
Profiling low-level native plug-ins
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
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
Activating and enabling Profiler modules
Customizing Profiler modules
Creating Profiler modules
Creating Profiler module detail panels
Profiler Module Editor 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
Adding profiling information to your code
Adding profiling information to your code introduction
Adding profiler markers to your code
Adding profiler counters to your code
Visualizing profiler counters
Running the Profiler in its own process
Profiler window reference
Profiler Preferences reference
Profiler command line arguments
Profiler markers reference
Profiler counters 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
Accessibility for mobile applications
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
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
Quit a Unity Android application
Testing and debugging
Debug on Android devices
Android symbols
Simulate an Android device
Collecting performance data on an Android device
Unity Remote
Application patching
Handle Android crashes
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
Embedded systems
Embedded Linux
Get started with Embedded Linux
Install the Unity Editor for Embedded Linux
Embedded Linux Player settings
Develop for Embedded Linux
Autodetect plug-ins for Embedded Linux
Enable optional features for Embedded Linux
Troubleshooting for Embedded Linux
Build and deliver for Embedded Linux
Embedded Linux Build Profiles reference
Build for Embedded Linux from the command line
Deploy an Embedded Linux project
QNX
Get started with QNX
Install the Unity Editor for QNX
QNX Player settings reference
Develop for QNX
Autodetect plug-ins for QNX
Support touch input for QNX
Enable optional features for QNX
Troubleshooting for QNX
Build and deliver for QNX
QNX Build Profiles reference
Build for QNX from the command line
Deploy a QNX project
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 requirements and compatibility
macOS Player settings reference
Developing for macOS
Deep linking for macOS
Use IL2CPP with macOS
Building and delivering for macOS
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 development and publishing process
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 APIs
Introduction to Web graphics APIs
WebGL2
WebGPU (Experimental)
Limitations of WebGPU
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
Using Web templates
Add a custom Web template
Web template structure and instantiation
Web template variables
Web template build configuration and interaction
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
Platform development
XR
XR API reference
Audio Spatializers
Unity XR SDK
XR API reference
XR.XRSettings
XR.XRDevice
XR.InputTracking
对文档有任何疑问，请移步至
开发者社区
提问，我们将尽快为您解答
Audio Spatializers
Unity XR SDK
Copyright © 2023 Unity Technologies
优美缔软件（上海）有限公司 版权所有
"Unity"、Unity 徽标及其他 Unity 商标是 Unity Technologies 或其附属机构在美国及其他地区的商标或注册商标。其他名称或品牌是其各自所有者的商标。
公安部备案号:
31010902002961
法律条款
隐私政策
Cookies
沪ICP备13002771号-8