Unity Manual

• Unity User Manual 2020.2
  • Documentation versions
  • Switching between Unity versions in the documentation
  • Offline documentation
• New in Unity 2020.2
• Packages
  • Verified packages
    • 2D Animation
    • 2D Pixel Perfect
    • 2D PSD Importer
    • 2D SpriteShape
    • Adaptive Performance
    • Adaptive Performance Samsung Android
    • Addressables
    • Advertisement
    • Alembic
    • Analytics Library
    • Android Logcat
    • Animation Rigging
    • AR Foundation
    • ARCore XR Plugin
    • ARKit Face Tracking
    • ARKit XR Plugin
    • Burst
    • Cinemachine
    • Editor Coroutines
    • High Definition RP
    • In App Purchasing
    • Input System
    • JetBrains Rider Editor
    • Magic Leap XR Plugin
    • ML Agents
    • Mobile Notifications
    • Multiplayer HLAPI
    • Oculus XR Plugin
    • OpenXR Plugin
    • Polybrush
    • Post Processing
    • ProBuilder
    • Profile Analyzer
    • Quick Search
    • Remote Config
    • Scriptable Build Pipeline
    • Shader Graph
    • Test Framework
    • TextMeshPro
    • Timeline
    • Unity Collaborate
    • Unity Distribution Portal
    • Unity Recorder
    • Universal RP
    • Visual Effect Graph
    • Visual Studio Code Editor
    • Visual Studio Editor
    • Windows XR Plugin
    • Xiaomi SDK
    • XR Plugin Management
  • Preview packages
    • 2D IK
    • 2D Tilemap Extras
    • Code Coverage
    • Device Simulator
    • FBX Exporter
    • Game Foundation
    • Havok Physics for Unity
    • Jobs
    • Kinematica
    • Memory Profiler
    • MockHMD XR Plugin
    • ProGrids
    • Terrain Tools
    • UI Builder
    • Unity NetCode
    • Unity Reflect
    • USD
    • XR Interaction Toolkit
  • Core packages
    • 2D Sprite
    • 2D Tilemap Editor
    • Unity UI
  • Built-in packages
    • AI
    • Android JNI
    • Animation
    • Asset Bundle
    • Audio
    • Cloth
    • Director
    • Image Conversion
    • IMGUI
    • JSONSerialize
    • Particle System
    • Physics
    • Physics 2D
    • Screen Capture
    • Terrain
    • Terrain Physics
    • Tilemap
    • UI
    • UIElements
    • Umbra
    • Unity Analytics
    • 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
  • Packages by keywords
  • Unity's Package Manager
    • Concepts
      • Package states and lifecycle
      • Dependency and resolution
      • Global Cache
    • Configuration
      • Solving network issues
      • Scoped registry authentication
    • Package Manager window
      • List view
      • Details view
      • Finding packages
        • Packages list context
        • Sorting the list
        • Asset Store package filters
        • Search box
      • Adding and removing packages
        • Installing from a registry
        • Installing a package from a local folder
        • Installing a package from a local tarball file
        • Installing from a Git URL
        • Removing an installed package
        • Disabling a built-in package
        • Importing an Asset Store package
        • Switching to another package version
        • Updating your Asset Store package
      • 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
      • Network issues
  • Creating custom packages
    • Naming your package
    • Package layout
    • Adding tests to a package
    • Package manifest
      • Versioning
    • Assembly definition and packages
    • Meeting legal requirements
    • Sharing your package
• Working in Unity
  • Installing Unity
    • System requirements for Unity 2020.2
    • Unity Hub
    • Installing the Unity Hub
    • Adding modules to the Unity Editor
    • Installing Unity from the command line
    • Installing Unity offline without the Hub
    • Unity Hub advanced deployment considerations
    • Licenses and Activation
      • Online activation
      • Offline / Manual Activation
      • Managing your License
      • Activation FAQ
    • Starting Unity
      • The Learn screen
      • Opening existing Projects
      • 2D or 3D projects
      • Project Templates
    • Learning the interface
  • Upgrading Unity
    • Using the API Updater
    • Upgrading to Unity 2020.2
    • Upgrading to Unity 2020.1
    • Upgrading to Unity 2019 LTS
    • Upgrading to Unity 2018 LTS
    • Legacy Upgrade Guides
      • Upgrading to Unity 2017.3
      • Upgrading to Unity 2017.2
      • Upgrading to Unity 2017.1
      • Upgrading to Unity 5.6
      • Upgrading to Unity 5.5
      • Upgrading to Unity 5.4
        • 5.4 Networking API Changes
      • Upgrading to Unity 5.3
      • Upgrading to Unity 5.2
      • Upgrading to Unity 5.0
        • AI in Unity 5.0
        • Animation in Unity 5.0
        • Audio in Unity 5.0
        • Baked Data in Unity 5.0
        • Plugins in Unity 5.0
        • Physics in Unity 5.0
        • Shaders in Unity 5.0
        • Other Upgrade Notes for Unity 5.0
      • Upgrading to Unity 4.0
      • Upgrading to Unity 3.5
  • Unity's interface
    • The Project window
    • The Scene view
      • Scene view navigation
      • Picking and selecting GameObjects
      • Positioning GameObjects
        • Grid snapping
      • Using custom Editor tools
      • Scene visibility
      • Scene view control bar
      • Scene view Camera
      • Gizmos menu
    • The Game view
    • 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
    • Searching in the Editor
    • Customizing your workspace
    • Unity shortcuts
  • Asset workflow
    • Common types of assets
    • Asset packages
    • Using the Asset Store
      • Purchasing or downloading a package on the Asset Store
      • Finding your Assets packages
      • Using labels to organize "My Assets"
      • Creating your own Asset packages
      • Importing local Asset packages
    • The Asset Database
      • Refreshing the Asset Database
      • Batching with the AssetDatabase
      • Scripted Importers
      • Importer Consistency
    • AssetBundles
      • AssetBundle workflow
      • Preparing Assets for AssetBundles
      • Building AssetBundles
      • AssetBundle Dependencies
      • Using AssetBundles Natively
      • AssetBundle compression
      • Patching with AssetBundles
      • Troubleshooting
      • Unity Asset Bundle Browser tool
    • Scripting with Assets
      • Loading Resources at Runtime
      • Streaming Assets
      • Applying defaults to Assets by folder
      • Modifying Source Assets Through Scripting
  • Creating Gameplay
    • Scenes
      • Creating, loading, and saving Scenes
      • Multi-Scene editing
      • Scene Templates
        • Creating scene templates
        • Editing scene templates
        • Customizing new scene creation
        • Scene template settings
    • GameObjects
      • Transforms
      • Introduction to components
      • Using Components
      • Primitive and placeholder objects
        • 2D Primitive GameObjects
      • Creating components with scripting
      • Deactivating GameObjects
      • Tags
      • Static GameObjects
      • Saving your work
    • 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
      • Unpacking Prefab instances
    • Layers
      • Layer-based collision detection
    • Constraints
      • Aim Constraints
      • Look At Constraints
      • Parent Constraints
      • Position Constraints
      • Rotation Constraints
      • Scale Constraints
    • Rotation and Orientation in Unity
    • Lights
    • Cameras
    • Cross-Platform Considerations
    • Publishing Builds
      • Reducing the file size of your build
      • Build Player Pipeline
    • Troubleshooting
  • Editor Features
    • 2D and 3D mode settings
    • Preferences
    • Presets
    • Shortcuts Manager
    • Build Settings
    • Project Settings
      • Audio
      • Editor
      • Graphics
      • Package Manager
      • Physics
      • Physics 2D
      • Player
        • Splash Screen
      • Preset Manager
      • Quality
      • Script Execution Order settings
      • Tags and Layers
      • Time
    • Visual Studio C# integration
    • RenderDoc Integration
    • Using the Xcode frame debugger
    • Editor Analytics
    • Check For Updates
    • IME in Unity
    • Special folder names
    • Reusing Assets between Projects
    • Version Control
      • Version control integrations
      • Perforce Integration
      • Plastic SCM Integration
      • Plastic SCM plugin for Unity (beta)
      • Using external version control systems with Unity
      • Smart Merge
    • Multi-Scene editing
    • Safe Mode
    • Command line arguments
      • Batch mode and built-in coroutine compatibility
    • Support for custom Menu Item and Editor features
    • Text-Based Scene Files
      • Format of Text Serialized files
      • UnityYAML
      • An Example of a YAML Scene File
      • YAML Class ID Reference
    • Troubleshooting The Editor
  • Analysis
    • Profiler overview
      • Profiling your application
      • Common Profiler markers
      • The Profiler window
        • Audio Profiler module
        • CPU Usage Profiler module
        • Global Illumination Profiler module
        • GPU Usage Profiler module
        • Memory Profiler module
        • Physics Profiler module
        • 2D Physics Profiler module
        • Rendering Profiler module
        • UI and UI Details Profiler
        • Video Profiler module
        • Virtual Texturing Profiler module
      • Profiler Module Editor
      • Low-level native plug-in Profiler API
    • Log Files
    • Understanding optimization in Unity
      • Profiling
      • Memory
      • Coroutines
      • Asset auditing
      • Understanding the managed heap
      • Strings and text
      • The Resources folder
      • General Optimizations
      • Special optimizations
    • Asset loading metrics
• Importing
  • Importing Models
    • Importing humanoid animations
    • Importing non-humanoid 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
  • SpeedTree Import Settings window
    • Model tab
    • Materials tab
  • Supported Model file formats
  • Creating Assets outside of Unity
    • Modeling characters for optimal performance
    • Preparing Humanoid Assets for export
    • Using FBX files in other applications
    • Limitations on importing Models into Unity
• Input
  • Input Manager
  • Mobile device input
    • Mobile Keyboard
  • Unity XR Input
• 2D
  • Gameplay in 2D
  • 2D Sorting
  • Sprites
    • Sprite Renderer
    • Sprite Creator
    • Sprite Editor
      • Sprite Editor: Custom Outline
      • Sprite Editor: Custom Physics Shape
      • Sprite Editor: Secondary Textures
    • Sorting Groups
    • 9-slicing Sprites
    • Sprite Masks
    • Sprite Atlas
      • Master and Variant Sprite Atlases
        • Variant Sprite Atlas
      • Sprite Atlas workflow
      • Preparing Sprite Atlases for distribution
        • Methods of distribution
        • Late Binding
        • Resolving different Sprite Atlas scenarios
      • Sprite Packer Modes
      • Sprite Atlas version 2 (Experimental)
      • Sprite Packer
    • Sprite Shape Renderer
  • Tilemap
    • Grid
    • Tilemap Renderer
    • Tile Assets
    • Tilemap workflow
      • Creating Tilemaps
      • Creating Tiles
      • **Creating** a Tile Palette
      • Painting on Tilemaps
        • Select Tool
      • Tilemap Collider 2D
    • Hexagonal Tilemaps
    • Isometric Tilemaps
      • Importing and preparing Sprites for an Isometric Tilemap
      • Creating an Isometric Tilemap
      • Creating a Tile Palette for an Isometric Tilemap
      • Tilemap Renderer Modes
      • Scriptable Brushes
    • Scriptable Tiles
      • TileBase
      • Tile
      • TileData
      • TileAnimationData
      • Other useful classes
      • Scriptable Tile example
    • Scriptable Brushes
      • GridBrushBase
      • GridBrushEditorBase
      • Other useful classes
      • Scriptable Brush example
  • Physics Reference 2D
    • Rigidbody 2D
    • Collider 2D
      • Circle Collider 2D
      • Box Collider 2D
      • Polygon Collider 2D
      • Edge Collider 2D
      • Capsule Collider 2D
      • Composite Collider 2D
    • Physics Material 2D
    • 2D Joints
      • Distance Joint 2D
      • Fixed Joint 2D
      • Friction Joint 2D
      • Hinge Joint 2D
      • Relative Joint 2D
      • Slider Joint 2D
      • Spring Joint 2D
      • Target Joint 2D
      • Wheel Joint 2D
    • Constant Force 2D
    • Effectors 2D
      • Area Effector 2D
      • Buoyancy Effector 2D
      • Point Effector 2D
      • Platform Effector 2D
      • Surface Effector 2D
• Graphics
  • Render pipelines
    • Render pipelines introduction
    • Switching render pipelines
    • Using the Built-in Render Pipeline
      • Rendering order in the Built-in Render Pipeline
      • Rendering paths in the Built-in Render Pipeline
        • Forward rendering path
        • Deferred Shading rendering path
        • Legacy Deferred rendering path
        • Vertex Lit Rendering Path
      • Extending the Built-in Render Pipeline with CommandBuffers
      • Hardware requirements for the Built-in Render Pipeline
    • Using the Universal Render Pipeline
    • Using the High Definition Render Pipeline
    • Scriptable Render Pipeline fundamentals
      • Scriptable Render Pipeline introduction
      • Scheduling and executing rendering commands in the Scriptable Render Pipeline
      • Scriptable Render Pipeline (SRP) Batcher
    • Creating a custom render pipeline
      • Creating a custom render pipeline based on the Scriptable Render Pipeline
      • Creating a Render Pipeline Asset and Render Pipeline Instance in a custom render pipeline
      • Creating a simple render loop in a custom render pipeline
  • Cameras
    • Using more than one camera
    • Using Physical Cameras
    • Camera Tricks
      • Understanding the View Frustum
      • The Size of the Frustum at a Given Distance from the Camera
      • Rays from the Camera
      • Using an oblique frustum
    • Occlusion culling
      • Getting started with occlusion culling
      • Using occlusion culling with dynamic GameObjects
      • Occlusion culling and Scene loading
      • Occlusion Areas
      • Occlusion Portals
      • The Occlusion Culling window
      • Occlusion culling additional resources
    • Dynamic resolution
    • Cameras Reference
      • Camera
      • Flare Layer
      • GUI Layer (Legacy)
  • Post-processing
  • Lighting
    • Introduction to lighting
    • Light sources
      • Lights
        • Types of light
        • Using Lights
        • Light Modes
          • Light Mode: Realtime
          • Light Mode: Mixed
          • Light Mode: Baked
        • Cookies (filename: Cookies.md)
          • Creating cookies for the Built-in Render Pipeline
      • Emissive materials
      • Ambient light
    • Shadows
      • Shadow mapping
      • Configuring shadows
      • Shadow Distance
      • Shadow Cascades
      • Shadow troubleshooting
    • The Lighting window
    • Lighting Settings Asset
      • Lighting Mode
        • Lighting Mode: Baked Indirect
        • Lighting Mode: Shadowmask
        • Lighting Mode: Subtractive
    • The Light Explorer window
      • Light Explorer extension
    • Lightmapping
      • The Progressive Lightmapper
        • The Progressive GPU Lightmapper (preview)
      • Lightmapping using Enlighten (deprecated)
      • Lightmapping: Getting started
      • Lightmap Parameters Asset
      • Directional Mode
      • Lightmaps and LOD
      • Ambient occlusion
      • Lightmaps: Technical information
      • Lightmapping and the Shader Meta Pass
      • Lightmap UVs
        • Importing UVs from Autodesk® Maya® to Unity
        • Generating lightmap UVs
      • UV overlap
      • Lightmap seam stitching
      • Custom fall-off
    • Realtime Global Illumination using Enlighten (deprecated)
      • LOD and Realtime GI
    • Light Probes
      • Light Probes: Technical information
      • Light Probe Groups
      • Placing Light Probes using scripting
      • Light Probes for moving objects
      • Light Probes and the Mesh Renderer
      • Light Probes and Scene loading
      • Light Probe Proxy Volume component
    • Reflection Probes
      • Types of Reflection Probe
      • Using Reflection Probes
      • Advanced Reflection Probe Features
      • Reflection Probe performance
      • Reflection Probe
    • Precomputed lighting data
      • Generating lighting data
      • Lighting Data Asset
      • GI cache
    • Scene View Draw Modes for lighting
  • Meshes, Materials, Shaders and Textures
    • Mesh Components
      • Meshes
      • Mesh Filter
      • Mesh Renderer
      • Skinned Mesh Renderer
      • Text Mesh
        • Text Asset
        • Font
      • Procedural Mesh Geometry
        • Anatomy of a Mesh
        • Using the Mesh Class
        • Example - Creating a quad
    • Creating and Using Materials
      • Material
      • Physically Based Rendering Material Validator
      • Accessing and Modifying Material parameters via script
    • Textures
      • Importing Textures
        • Texture Import Settings
        • Texture types
        • Texture compression formats
          • Recommended, default, and supported texture compression formats, by platform
      • Render Texture
      • Custom Render Textures
      • Movie Textures
      • 3D textures
      • Texture arrays
      • Cubemaps
      • Cubemap arrays
    • Writing Shaders
      • Standard Shader
        • Content and Context
        • Metallic vs. specular workflow
        • Material parameters
          • Rendering Mode
          • Albedo Color and Transparency
          • Specular mode: Specular parameter
          • Metallic mode: Metallic Parameter
          • Smoothness
          • Normal map (Bump mapping)
          • Heightmap
          • Occlusion Map
          • Emission
          • Secondary Maps (Detail Maps) & Detail Mask
          • The Fresnel Effect
        • Material charts
        • Make your own
      • Standard Particle Shaders
      • Autodesk Interactive shader
      • Legacy 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
      • Shader Reference
        • Writing Surface Shaders
          • Surface Shaders and rendering paths
          • Surface Shader examples
          • Custom lighting models in Surface Shaders
          • Surface Shader lighting examples
          • Surface Shaders with DX11 / OpenGL Core Tessellation
        • Writing vertex and fragment shaders
          • Vertex and fragment shader examples
          • Shader semantics
          • Accessing shader properties in Cg/HLSL
          • Providing vertex data to vertex programs
          • Built-in shader include files
          • Predefined Shader preprocessor macros
          • Built-in shader helper functions
          • Built-in shader variables
          • Shader variants and keywords
          • GLSL Shader programs
          • Shading language used in Unity
          • Shader Compilation Target Levels
          • Shader data types and precision
          • Using sampler states
        • ShaderLab Syntax
          • ShaderLab: Properties
          • ShaderLab: SubShader
            • ShaderLab: Pass
              • ShaderLab culling and depth testing
              • ShaderLab: Blending
              • ShaderLab: Pass Tags
              • ShaderLab: Stencil
              • ShaderLab: Name
              • ShaderLab: Legacy Lighting
              • ShaderLab: Legacy Texture Combiners
              • ShaderLab: Legacy Alpha Testing
              • ShaderLab: Legacy Fog
              • ShaderLab: Legacy BindChannels
            • ShaderLab: UsePass
            • ShaderLab: GrabPass
            • ShaderLab: SubShader Tags
            • ShaderLab: SubShader LOD value
          • ShaderLab: Fallback
          • ShaderLab: CustomEditor
          • ShaderLab: other commands
        • Shader assets
        • Advanced ShaderLab topics
          • Optimizing shader variants
          • Asynchronous Shader compilation
          • Performance tips when writing shaders
          • Rendering with Replaced Shaders
          • Custom Shader GUI
          • Using Depth Textures
          • Camera's Depth Texture
          • Platform-specific rendering differences
          • Using texture arrays in shaders
          • Debugging DirectX 11/12 shaders with Visual Studio
          • Debugging DirectX 12 shaders with PIX
          • Implementing Fixed Function TexGen in Shaders
  • Particle systems
    • Choosing your particle system solution
    • Built-in Particle System
      • Using the Built-in Particle System
      • Particle System vertex streams and Standard Shader support
      • Particle System GPU Instancing
      • Particle System C# Job System integration
      • Components and Modules
        • Particle System
        • Particle System modules
          • Particle System Main module
          • Emission module
          • Shape Module
          • Velocity over Lifetime module
          • Noise module
          • Limit Velocity Over Lifetime module
          • Inherit Velocity module
          • Lifetime by Emitter Speed
          • Force Over Lifetime module
          • Color Over Lifetime module
          • Color By Speed module
          • Size over Lifetime module
          • Size by Speed module
          • Rotation Over Lifetime module
          • Rotation By Speed module
          • External Forces module
          • Collision module
          • Triggers module
          • Sub Emitters module
          • Texture Sheet Animation module
          • Lights module
          • Trails module
          • Custom Data module
          • Renderer module
        • Particle System Force Field
      • Built-in Particle System examples
        • Creating a simple explosion
        • Creating exhaust smoke from a vehicle
    • Visual Effect Graph
      • Project Settings - VFX
      • Visual Effect Graph Asset
      • Block Subgraph
      • Operator Subgraph
      • Visual Effect
      • Property Binders
  • Creating environments
    • 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
        • SpeedTree
      • Wind Zones
      • Grass and other details
      • Working with Heightmaps
      • Terrain settings
      • Using Terrain at runtime
    • Terrain Tools
    • Tree Editor
      • Building Your First Tree
      • Tree Basics
      • Branch Group Properties
      • Leaf Group Properties
  • Sky
    • Skyboxes
      • Using skyboxes
    • Skybox shaders
      • 6 Sided skybox
      • Cubemap skybox
      • Panoramic skybox
      • Procedural skybox
    • Skybox component reference
  • Visual Effects Components
    • Halo
    • Lens Flare
      • Flare
    • Line Renderer
    • Trail Renderer
    • Billboard Renderer
    • Billboard Asset
    • Projector
  • Advanced rendering features
    • High dynamic range
      • HDR color picker
    • Level of Detail (LOD) for meshes
      • LOD Group
      • Importing LOD Meshes
    • Graphics API support
      • DirectX
      • Metal
      • OpenGL Core
    • 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
    • Compute shaders
    • GPU instancing
    • Sparse Textures
    • CullingGroup API
    • Loading texture and mesh data
  • Optimizing graphics performance
    • Draw call batching
    • Rendering statistics window
    • Frame Debugger
    • Mip Map Streaming
      • Streaming Controller
      • Mip Map Streaming API
  • Color space
    • Linear or gamma workflow
    • Gamma Textures with linear rendering
    • Working with linear Textures
  • Graphics tutorials
    • How do I fix the rotation of an imported model?
    • Art Asset best practice guide
    • Importing models from 3D modeling software
    • Making believable visuals in Unity
      • Update: believable visuals in URP and HDRP
      • Believable visuals: preparing assets
      • Believable visuals: render settings
      • Believable visuals: lighting strategy
      • Believable visuals: models
      • Believable visuals: materials and shaders
      • Believable visuals: outdoor lighting
      • Believable visuals: indoor and local lighting
      • Believable visuals: post-processing
      • Believable visuals: dynamic lighting
    • Setting up the Rendering Pipeline and Lighting in Unity
• Physics
  • 3D Physics for object-oriented projects
    • Rigidbody overview
    • Colliders
    • Joints
    • Physics articulations
    • Character Controllers
    • Continuous collision detection (CCD)
    • Multi-scene physics
    • Physics Debug Visualization
  • 3D Physics Reference
    • Articulation Body
    • Box Collider
    • Capsule Collider
    • Character Controller
    • Character Joint
    • Configurable Joint
    • Constant Force
    • Fixed Joint
    • Hinge Joint
    • Mesh Collider
    • Rigidbody
    • Sphere Collider
    • Spring Joint
    • Cloth
    • Wheel Collider
    • Terrain Collider
    • Physic Material
  • Physics HOWTOs
    • Ragdoll Wizard
    • Joint and Ragdoll stability
    • Wheel Collider Tutorial
• Scripting
  • Setting Up Your Scripting Environment
    • Integrated development environment (IDE) support
    • Debugging C# code in Unity
    • Unit Testing
    • Roslyn analyzers and ruleset files
  • Scripting concepts
    • Creating and Using Scripts
    • Variables and the Inspector
    • Instantiating Prefabs at run time
    • Order of execution for event functions
    • Event Functions
    • Coroutines
    • Namespaces
    • Attributes
    • UnityEvents
    • Null Reference Exceptions
  • Important Classes
    • Important Classes - GameObject
    • Important Classes - MonoBehaviour
    • Important Classes - Object
    • Important Classes - Transform
    • Important Classes - Vectors
    • Important Classes - Quaternion
    • ScriptableObject
    • Important Classes - Time and Framerate Management
    • Important Classes - Mathf
    • Important Classes - Random
    • Important Classes - Debug
    • Important Classes - Gizmos & Handles
  • Unity architecture
    • Overview of .NET in Unity
      • .NET profile support
      • Stable scripting runtime: known limitations
      • Understanding Automatic Memory Management
      • Referencing additional class library assemblies
      • C# compiler
    • Scripting backends
      • IL2CPP
        • Building a project using IL2CPP
        • Compiler options
        • Windows Runtime support
        • How IL2CPP works
        • Optimizing IL2CPP build times
        • Managed stack traces with IL2CPP
      • Scripting restrictions
      • Managed code stripping
    • Code reloading in the Unity Editor
      • Configurable Enter Play Mode
        • Domain Reloading
        • Scene Reloading
        • Details of disabling Domain and Scene Reload
      • Running Editor Script Code on Launch
    • Script Serialization
      • Built-in serialization
      • Custom serialization
      • Script serialization errors
      • JSON Serialization
    • Script compilation
      • Special folders and script compilation order
      • Platform dependent compilation
      • Assembly definitions
        • Assembly Definition properties
        • Assembly Definition Reference properties
        • Assembly Definition File Format
  • Plug-ins
    • Plugin Inspector
    • 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
  • C# Job System
    • C# Job System Overview
    • What is multithreading?
    • What is a job system?
    • The safety system in the C# Job System
    • NativeContainer
    • Creating jobs
    • Scheduling jobs
    • JobHandle and dependencies
    • ParallelFor jobs
    • ParallelForTransform jobs
    • C# Job System tips and troubleshooting
• Multiplayer and Networking
  • Multiplayer Overview
  • Setting up a multiplayer project
  • Using the Network Manager
  • Using the Network Manager HUD
  • The Network Manager HUD in LAN mode
  • The Network Manager HUD in Matchmaker mode
  • Converting a single-player game to Unity Multiplayer
  • Debugging Information
  • The Multiplayer High Level API
    • Networking HLAPI System Concepts
    • Networked GameObjects
      • Player GameObjects
      • Custom Player Spawning
      • Spawning GameObjects
      • Custom Spawn Functions
      • Network Authority
      • State synchronization
      • Advanced State Synchronization
      • Network visibility
      • Customizing network visibility
      • Scene GameObjects
    • Actions and communication
      • Remote Actions
      • Network Manager callbacks
      • NetworkBehaviour callbacks
      • Network Messages
    • Dealing with clients and servers
      • Network clients and servers
      • Host Migration
      • Network Discovery
      • Multiplayer Lobby
    • Using the Transport Layer API
      • NetworkReader and NetworkWriter serializers
    • Setting up Unity Multiplayer
      • Integrating the Multiplayer Service
      • Integration using the HUD
      • Integration using Unity's High-Level API
      • Integration using NetworkTransport
      • Common Errors
      • Customized Matchmaking callbacks
    • Networking Tips for Mobile devices.
  • Multiplayer Component Reference
    • Network Animator
    • Network Discovery
    • Network Identity
    • Network Lobby Manager
    • Network Lobby Player
    • Network Manager HUD
    • Network Manager
    • Network Proximity Checker
    • NetworkStartPosition
    • Network Transform
    • Network Transform Child
    • Network Transform Visualizer
  • Multiplayer Classes Reference
    • NetworkBehaviour
    • NetworkClient
    • NetworkConnection
    • NetworkServer
    • NetworkServerSimple
  • Multiplayer Encryption Plug-ins
  • UnityWebRequest
    • 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
• Audio
  • Audio Overview
  • Audio files
  • Tracker Modules
  • Audio Mixer
    • An overview of the concepts and AudioMixer
    • Specifics on the AudioMixer window
    • AudioGroup Inspector
    • Overview of Usage and API
  • Native Audio Plugin SDK
    • Audio Spatializer SDK
  • Audio Profiler
  • Ambisonic Audio
  • 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 overview
  • Video Player component
    • Migrating from MovieTexture to VideoPlayer
    • Video Clips
    • Video sources
    • Video file compatibility
    • Understanding video files
    • Video transparency support
    • Panoramic video
• Animation
  • Animation System Overview
  • Animation Clips
    • Animation from external sources
      • Humanoid Avatars
    • Animation Window Guide
      • Using the Animation view
      • Creating a new Animation Clip
      • Animating a GameObject
      • Using Animation Curves
      • Editing Curves
      • Key manipulation in Dopesheet mode
      • Key manipulation in Curves mode
      • Objects with Multiple Moving Parts
      • Using Animation Events
  • Animator Controllers
    • The Animator Controller Asset
    • The Animator Window
    • Animation State Machines
      • State Machine Basics
      • Animation Parameters
      • State Machine Transitions
      • State Machine Behaviours
      • Sub-State Machines
      • Animation Layers
      • Solo and Mute functionality
      • Target Matching
      • Inverse Kinematics
      • Root Motion - how it works
        • Tutorial: Scripting Root Motion for "in-place" humanoid animations
    • Blend Trees
      • 1D Blending
      • 2D Blending
      • Direct Blending
      • Additional Blend Tree Options
    • Working with blend shapes
    • Animator Override Controllers
  • Retargeting of Humanoid animations
  • Performance and optimization
  • Animation Reference
    • Animator component
    • Animator Controller
      • Creating an AnimatorController
      • Animation States
      • Animation transitions
  • Animation FAQ
  • Playables API
    • The PlayableGraph
    • ScriptPlayable and PlayableBehaviour
    • Playables Examples
  • A Glossary of animation terms
• Creating user interfaces (UI)
  • Comparison of UI systems in Unity
  • UI Toolkit
    • The UI Toolkit Package
    • The Visual Tree
    • The Layout Engine
    • The UXML format
      • Writing UXML Templates
      • Loading UXML from C#
      • UXML elements reference
      • UQuery
    • Styles and Unity style sheets
      • USS Selectors
        • Simple selectors
        • Complex Selectors
        • Pseudo-classes
      • USS Properties types
      • USS supported properties
      • USS custom properties (variables)
        • Built-in Unity variables
      • USS Writing style sheets
    • The Event System
      • Dispatching Events
      • Responding to Events
      • Supporting drag and drop
      • Synthesizing Events
      • Event Type Reference
    • Built-in Controls
    • Bindings
    • Supporting IMGUI
    • ViewData persistence
  • Unity UI
    • Canvas
    • Basic Layout
    • Visual Components
    • Interaction Components
    • Animation Integration
    • Auto Layout
    • Rich Text
    • Event System
      • Messaging System
      • Input Modules
      • Supported Events
      • Raycasters
    • UI Reference
      • Rect Transform
      • Canvas Components
        • Canvas
        • Canvas Scaler
        • Canvas Group
        • Canvas Renderer
      • Visual Components
        • Text
        • Image
        • Raw Image
        • Mask
        • RectMask2D
        • UI Effect Components
          • Shadow
          • Outline
          • Position as UV1
      • Interaction Components
        • Selectable Base Class
          • Transition Options
          • Navigation Options
        • Button
        • Toggle
        • Toggle Group
        • Slider
        • Scrollbar
        • Dropdown
        • Input Field
        • Scroll Rect
      • Auto Layout
        • Layout Element
        • Content Size Fitter
        • Aspect Ratio Fitter
        • Horizontal Layout Group
        • Vertical Layout Group
        • Grid Layout Group
      • Event System Reference
        • Event System Manager
        • Graphic Raycaster
        • Physics Raycaster
        • Physics 2D Raycaster
        • Standalone Input Module
        • Touch Input Module
        • Event Trigger
    • UI How Tos
      • Designing UI for Multiple Resolutions
      • Making UI elements fit the size of their content
      • Creating a World Space UI
      • Creating UI elements from scripting
      • Creating Screen Transitions
  • Immediate Mode GUI (IMGUI)
    • IMGUI Basics
    • Controls
    • Customization
    • IMGUI Layout Modes
    • Extending IMGUI
    • GUI Skin (IMGUI System)
    • GUI Style (IMGUI System)
    • Extending the Editor
      • Editor Windows
      • Property Drawers
      • Custom Editors
      • TreeView
• Navigation and Pathfinding
  • Navigation Overview
    • Navigation System in Unity
    • Inner Workings of the Navigation System
    • Building a NavMesh
    • NavMesh building components
      • NavMesh Surface
      • NavMesh Modifier
      • NavMesh Modifier Volume
      • NavMesh Link
      • NavMesh building components API
    • Advanced NavMesh Bake Settings
    • Creating a NavMesh Agent
    • Creating a NavMesh Obstacle
    • Creating an Off-mesh Link
    • Building Off-Mesh Links Automatically
    • Building Height Mesh for Accurate Character Placement
    • Navigation Areas and Costs
    • Loading Multiple NavMeshes using Additive Loading
    • Using NavMesh Agent with Other Components
  • Navigation Reference
    • NavMesh Agent
    • Nav Mesh Obstacle
    • Off-Mesh Link
  • Navigation How-Tos
    • Telling a NavMeshAgent to Move to a Destination
    • Moving an Agent to a Position Clicked by the Mouse
    • Making an Agent Patrol Between a Set of Points
    • Coupling Animation and Navigation
• Unity Services
  • Setting up your project for Unity services
    • Using the developer dashboard
  • Unity Organizations
    • Subscriptions and seats
    • Managing your Organization
    • Managing your Organization’s Projects
    • Transfer a Project to a new Organization
    • Working with Unity Teams
  • Unity Ads
  • Unity Analytics
    • Unity Analytics Overview
    • Setting Up Analytics
    • Analytics Dashboard
      • Overview page
      • Data Explorer
      • Funnel Analyzer page
      • Segment Builder
      • Remote Settings page
      • Raw Data Export page
      • Event Manager
      • Configure page
      • Market Insights
    • Analytics events
      • Core Events
      • Standard Events
      • Custom Events
        • Custom Event scripting
      • Analytics Event Tracker
      • Analytics event parameters
      • Analytics Event limits
    • Funnels
    • Remote Settings
      • Creating and changing Remote Settings
      • Using Remote Settings in a Unity project
        • Remote Settings network requests
        • Enabling Remote Settings
        • Managing Remote Settings in the Unity Editor
        • Remote Settings component
        • Remote Settings scripting
        • Testing Remote Settings
    • Unity Analytics A/B Testing
    • Monetization
      • Receipt Verification
    • User Attributes
    • Unity Analytics Raw Data Export
    • Data reset
    • Upgrading Unity Analytics
      • Upgrade Unity Analytics 4.x-5.1 (SDK) to 5.2 onwards
      • Upgrade Unity Analytics 5.1 to 5.2 onwards
      • Unity Analytics Re-integrate SDK to 5.1
      • What to Do if Project IDs Don't Match
    • COPPA Compliance
    • Unity Analytics and the EU General Data Protection Regulation (GDPR)
      • Unity Analytics DataPrivacy API
    • Analytics Metrics, Segments, and Terminology
  • Unity Cloud Build
    • Automated Build Generation
    • Supported platforms
    • Supported versions of Unity
    • Share links
    • Version control systems
      • Using the Unity Developer Dashboard to configure Unity Cloud Build for Git
      • Using the Unity Developer Dashboard to configure Unity Cloud Build for Mercurial
      • Using Apache Subversion (SVN) with Unity Cloud Build
      • Using the Unity Developer Dashboard to configure Unity Cloud Build for Perforce
      • Using the Unity Developer Dashboard to configure Unity Cloud Build for Plastic
    • Building for iOS
    • Advanced options
      • Development builds
      • Pre- and post-export methods
      • Xcode frameworks
      • Custom scripting #define directives
      • Including specific Scenes
    • Using Addressables in Unity Cloud Build
    • Build manifest
      • Build manifest as JSON
      • Build manifest as ScriptableObject
    • Scheduled builds
    • Cloud Build REST API
  • Unity Cloud Content Delivery
    • Cloud Content Delivery interfaces
      • Unity CCD Command-line interface (CLI)
      • Unity CCD Develop Dashboard
    • Using CCD via the command-line interface
  • 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
      • Samsung Galaxy IAP configuration
    • 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
      • Samsung Galaxy apps
    • Implementing a Store
      • Initialization
      • Retrieving products
      • Handling purchases
      • Store Modules
        • Registering your store
        • Store Configuration
        • Store Extensions
  • Unity Collaborate
    • Setting up Unity Collaborate
    • Adding team members to your Unity project
    • Viewing history
    • Enabling Cloud Build with Collaborate
    • Managing Unity Editor versions
    • Reverting files
    • Resolving file conflicts
    • Excluding Assets from publishing to Collaborate
    • Publishing individual files to Collaborate
    • Restoring previous versions of a project
    • In-Progress edit notifications
    • Managing cloud storage
    • Moving your Project to another version control system
    • Unity Accelerator
    • Collaborate troubleshooting tips
  • Unity Cloud Diagnostics
  • Unity Integrations
  • Multiplayer Services
  • Unity Distribution Portal
    • Getting started with UDP
    • Distributing your game with UDP
    • Implementing in-app purchases with the UDP package
    • Testing your game in the UDP sandbox
    • Managing and publishing your game on the UDP console
    • Using UDP with other services
    • UDP reference
    • UDP troubleshooting
• XR
  • Getting started with AR development in Unity
  • Getting started with VR development in Unity
  • XR Plug-in Framework
  • Configuring your Unity Project for XR
  • Universal Render Pipeline compatibility in XR
  • XR API reference
  • Single Pass Stereo rendering (Double-Wide rendering)
    • Single Pass Instanced rendering
    • Single-Pass Stereo Rendering for HoloLens
  • VR Audio Spatializers
  • VR frame timing
  • 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
• Open-source repositories
  • How to contribute to Unity
    • Step 1: Get a Bitbucket account
    • Step 2: Fork the repository you want to contribute to
    • Step 3: Clone your fork
    • Step 4: Apply modifications to your fork
    • Step 5: Open a pull request on Bitbucket
    • Step 6: Wait for feedback
    • Further Reading
    • FAQ
• Asset Store Publishing
  • 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
• Platform development
  • Using Unity as a Library in other applications
  • Enabling deep linking
  • Standalone
    • Standalone Player settings
    • PC, Mac & Linux Standalone build settings
    • Multi-display
  • macOS
    • macOS Player: IL2CPP Scripting Backend
      • macOS Player: C++ source code plugins for IL2CPP
    • Delivering your application to the Mac App Store
  • Apple TV
    • tvOS build considerations
    • tvOS build settings
    • Apple TV Player settings
  • WebGL
    • Getting started with WebGL development
      • WebGL Player settings
      • Building and running a WebGL project
      • WebGL: Compressed builds and server configuration
      • WebGL: Server configuration code samples
      • WebGL Browser Compatibility
      • WebGL Graphics
      • Using Audio In WebGL
      • Embedded Resources on WebGL
      • Using WebGL templates
      • Cursor locking and full-screen mode in WebGL
      • Input in WebGL
      • WebGL: Interacting with browser scripting
      • WebGL performance considerations
      • Memory in WebGL
      • Debugging and troubleshooting WebGL builds
      • WebGL Networking
  • iOS
    • Integrating Unity into native iOS applications
    • Getting started with iOS development
      • Unity iOS Basics
      • iOS account setup
      • Inside the iOS build process
      • Structure of a Unity Xcode Project
    • iOS build settings
    • iOS Player settings
      • iOS Player settings - Icon
      • iOS Player settings - Resolution and presentation
      • iOS Player settings - Splash image
      • iOS Player settings - Debugging and crash reporting
      • iOS Player settings - Other settings
      • iOS Player settings - XR settings
    • iOS Advanced Topics
      • Unity Remote
      • iOS Scripting
        • iOS Game Controller support
        • Advanced iOS scripting
      • Optimizing Performance on iOS
        • iOS-specific optimizations
        • Measuring performance with the built-in profiler
        • Optimizing the size of the built iOS Player
        • Optimizing Physics Performance
      • Building plug-ins for iOS
      • Preparing your application for In-App Purchases (IAP)
      • App thinning
      • Managed stack traces on iOS
      • Social API
    • Troubleshooting on iOS devices
    • Reporting crash bugs on iOS
  • Android
    • Android environment setup
    • Integrating Unity into Android applications
    • Unity Remote
    • Android Player settings
    • Android Keystore Manager
    • Building apps for Android
      • Customizing an Android Splash Screen
      • Gradle for Android
      • Android Manifest
      • Requesting Permissions
      • Support for APK expansion files (OBB)
      • App patching for fast development iteration
    • Single-Pass Stereo Rendering for Android
    • Vulkan swapchain pre-rotation
    • Building and using plug-ins for Android
      • AAR plug-ins and Android Libraries
      • JAR plug-ins
      • Extending the UnityPlayerActivity Java Code
      • Native (C++) plug-ins for Android
      • Using Java or Kotlin source files as plug-ins
    • Android mobile scripting
    • Troubleshooting Android development
      • Gradle troubleshooting
    • Reporting crash bugs under Android
  • Windows
    • Integrating Unity into Windows and UWP applications
    • Windows General
      • Windows standalone Player build binaries
      • Visual Studio project generation for Windows Standalone
      • Windows Debugging
      • WindowsLowIntegrity
      • Windows Player: IL2CPP Scripting Backend
        • Windows Player: IL2CPP build files
      • Windows Player: C++ source code plugins for IL2CPP
    • Universal Windows Platform
      • Getting Started
      • Universal Windows Platform: Deployment
      • Universal Windows Platform (UWP) build settings
      • Windows Device Portal Deployment
      • Universal Windows Platform: Profiler
      • Universal Windows Platform: Command line arguments
      • Universal Windows Platform: Association launching
      • AppCallbacks class
      • Universal Windows Platform: WinRT API in C# scripts
      • Universal Windows Platform Player Settings
      • Universal Windows Platform: IL2CPP scripting back end
        • Universal Windows Platform: Generated project with IL2CPP scripting backend
        • Universal Windows Platform: Plugins on IL2CPP Scripting Backend
        • Universal Windows Platform: Debugging on IL2CPP Scripting Backend
      • FAQ
      • Universal Windows Platform: Examples
      • Universal Windows Platform: Code snippets
    • Known issues
  • Mobile Developer Checklist
    • Crashes
    • Profiling
    • Optimizations
    • Practical guide to optimization for mobiles
      • Graphics Methods
      • Scripting and Gameplay Methods
      • Rendering Optimizations
    • Optimizing Scripts
• Legacy Topics
  • Windows Store: Windows SDKs
    • Windows Phone 8.1
    • Windows Phone 8.1: Debugging
    • Windows 8.1 Universal Applications
    • Universal Windows 10 Applications: Getting Started
  • Asset Server (Team License)
    • Setting up the Asset Server
    • Cache Server
  • Legacy Asset Bundles
    • Creating Asset Bundles in Unity 4
    • Managing Asset Dependencies in Unity 4
  • Legacy Animation System
    • Animation
    • Animation Scripting (Legacy)
  • Legacy Unity Analytics (SDK Workflow)
    • Basic Integration (SDK)
      • Import SDK
      • Create Game Script
      • Attach Game Script
      • Play To Validate
    • Advanced Integration (SDK)
      • Custom Events
      • Monetization
        • Receipt Verification
      • User Attributes
• Glossary