Manual
Scripting API
unity3d.com
Legacy Documentation: Version 5.2
Language:
English
English
日本語
Español
한국어
Русский
Unity Manual
Unity Overview
Downloading and Installing Unity
Unity Basics
Getting Started
Learning the Interface
Project Browser
Hierarchy
Toolbar
Scene View
Game View
Inspector
Other Views
Customizing Your Workspace
Asset Workflow
Creating Scenes
Publishing Builds
Unity Hotkeys
Preferences
Saving Your Work
Building Scenes
GameObjects
The GameObject-Component Relationship
Using Components
The Component-Script Relationship
Deactivating GameObjects
Tags
Static GameObjects
Using the Inspector
Editing Properties
Preset Libraries
Inspector Options
Using the Scene View
Scene View Navigation
Positioning GameObjects
Scene View Control Bar
Searching
Prefabs
Lights
Cameras
Creating Gameplay
Instantiating Prefabs at runtime
Input
Conventional Game Input
Mobile Device Input
Mobile Keyboard
Transforms
Gameplay in 2D
Adding Random Gameplay Elements
Trouble Shooting
Editor
Editor Overview
Build Settings
Network Emulation
Visual Studio C# Integration
Analytics
Check For Updates
IME in Unity
Special Folder Names
Version Control
Version control integration (Team License)
Perforce Integration
Plastic SCM Integration
Using External Version Control Systems with Unity
Smart Merge
Troubleshooting Editor
Extending the Editor
Editor Windows
Property Drawers
Custom Editors
Editor Reference
Settings Managers
Audio Manager
Editor settings
Input Manager
Network Manager
Physics Manager
Physics 2D Manager
Player Settings
Quality Settings
Graphics Settings
Script Execution Order Settings
Tags and Layers
Time Manager
Network Group
Network View
Graphics
Graphics Overview
Lighting
Lighting Overview
Using Lights
Cookies
Shadows
Directional Light Shadows
Light Troubleshooting and Performance
Global Illumination
Lighting Window
Light Probes
Lightmap Parameters
Directional Lightmapping
LightmapSnapshot
GI Visualisations in the Scene View
GICache
Linear Rendering
Cameras
Using more than one camera
Camera Tricks
Understanding the View Frustum
The Size of the Frustum at a Given Distance from the Camera
Dolly Zoom (AKA the "Trombone" Effect)
Rays from the Camera
Using an Oblique Frustum
Creating an Impression of Large or Small Size
Occlusion Culling
Materials And Shaders
Creating and Using Materials
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
Accessing and Modifying Material parameters via script
Writing Shaders
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
Terrain Engine
Creating and Editing Terrains
Height Tools
Textures
Trees
Grass and Other Details
Wind Zones
Terrain Settings
Tree Editor
Building Your First Tree
Tree Basics
Branch Group Properties
Leaf Group Properties
Tree - Wind Zones
Particle Systems
What is a Particle System?
Using Particle Systems in Unity
Particle System How-Tos
A Simple Explosion
Exhaust Smoke from a Vehicle
Textures and Videos
Reflection probes
Types of Reflection Probe
Using Reflection Probes
Advanced Reflection Probe Features
Reflection Probe Performance and Optimisation
Sprite Editor
Sprite Packer
Cluster Rendering
Installing the Cluster Renderer
Setting Up A Clustered Scene
Operating The Cluster
Advanced Rendering Features
High Dynamic Range Rendering
Rendering Paths
Level of Detail
Using DirectX 11 in Unity
Compute Shaders
Graphics Command Buffers
Sparse Textures
Graphics Hardware Capabilities and Emulation
CullingGroup API
Procedural Materials
Procedural Materials - Memory Usage and Caching Behaviour
Procedural Mesh Geometry
Anatomy of a Mesh
Using the Mesh Class
Optimizing Graphics Performance
Draw Call Batching
Modeling Characters for Optimal Performance
Rendering Statistics Window
Frame Debugger
Optimizing Shader Load Time
Layers
Layer-Based Collision Detection.
Graphics Reference
Lighting Reference
Light
Light Probe Group
Cameras Reference
Camera
Flare Layer
GUI Layer (Legacy)
Shader Reference
Writing Surface Shaders
Surface Shader Examples
Custom Lighting models in Surface Shaders
Surface Shader Lighting Examples
Surface Shaders with DX11 Tessellation
Writing vertex and fragment shaders
Vertex and Fragment Shader Examples
Accessing shader properties in Cg/HLSL
Providing vertex data to vertex programs
Built-in shader include files
Predefined shader preprocessor macros
Built-in shader variables
Making multiple shader program variants
GLSL Shader Programs
ShaderLab Syntax
ShaderLab: Properties
ShaderLab: SubShader
ShaderLab: Pass
ShaderLab: Culling & 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: Fallback
ShaderLab: CustomEditor
ShaderLab: other commands
Shader Assets
Advanced ShaderLab topics
Unity's Rendering Pipeline
Performance Tips when Writing Shaders
Rendering with Replaced Shaders
Custom Shader GUI
Using Depth Textures
Camera's Depth Texture
Platform Specific Rendering Differences
Shader Level of Detail
Debugging DirectX 11 shaders with Visual Studio
Implementing Fixed Function TexGen in Shaders
Particle Systems Reference
Particle system
Particle System Modules
Main Module
Emission Module
Shape Module
Velocity Over Lifetime Module
Limit Velocity Over Lifetime Module
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
Sub Emitters Module
Texture Sheet Animation Module
Renderer Module
Particle Systems (Legacy, prior to release 3.5)
Ellipsoid Particle Emitter (Legacy)
Mesh Particle Emitter (Legacy)
Particle Animator (Legacy)
Particle Renderer (Legacy)
World Particle Collider (Legacy)
Visual Effects Reference
Halo
Lens Flare
Flare
Line Renderer
Trail Renderer
Projector
Image Effect Reference
Antialiasing
Bloom
Bloom (Optimized)
Bloom and Lens Flares
Blur
Blur (Optimized)
Camera Motion Blur
Color Correction Curves
Color Correction Ramp Texture
Color Correction Lookup Texture
Contrast Enhance
Contrast Stretch
Crease Shading
Depth of Field (Deprecated)
Depth of Field
Edge Detection
Edge Detect Effect Normals
Fisheye
Global Fog
Grayscale
Motion Blur
Noise And Grain
Noise And Scratches
Screen Overlay
Sepia Tone
Sun Shafts
Screen Space Ambient Obscurance
Screen Space Ambient Occlusion
Tilt Shift
Tonemapping
Twirl
Vignetting and Chromatic Aberration
Vortex
Mesh Components
Meshes
Material
Mesh Filter
Mesh Renderer
Skinned Mesh Renderer
Text Mesh
Text Asset
Font
Texture Components
2D Textures
Procedural Material Assets
Render Texture
Movie Texture
3D Textures
Rendering Components
Cubemap
Occlusion Area
Occlusion Portals
Skybox
Reflection Probe
LOD Group
Rendering Pipeline Details
Deferred Shading Rendering Path
Forward Rendering Path Details
Legacy Deferred Lighting Rendering Path
Vertex Lit Rendering Path Details
Hardware Requirements for Unity's Graphics Features
Sprite Renderer
Graphics HOWTOs
How do I Import Alpha Textures?
How do I Make a Skybox?
How do I make a Mesh Particle Emitter? (Legacy Particle System)
How do I make a Spot Light Cookie?
How do I fix the rotation of an imported model?
How do I use Water?
FBX export guide
Art Asset Best Practice Guide
How do I import Models from my 3D app?
Importing Objects From Maya
Importing Objects From Cinema 4D
Importing Objects From 3D Studio Max
Importing Objects From Cheetah3D
Importing Objects From Modo
Importing Objects From Lightwave
Importing Objects From Blender
Importing Objects From SketchUp
How to do Stereoscopic Rendering
Graphics Tutorials
Example - Creating a Billboard Plane
Shaders: ShaderLab & Fixed Function shaders
Shaders: Vertex and Fragment Programs
Physics
Physics Overview
Rigidbodies
Colliders
Joints
Character Controllers
3D Physics Reference
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
2D Physics Reference
Rigidbody 2D
Circle Collider 2D
Box Collider 2D
Polygon Collider 2D
Edge Collider 2D
Physics Material 2D
Spring Joint 2D
Distance Joint 2D
Hinge Joint 2D
Slider Joint 2D
Wheel Joint 2D
Constant Force 2D
Area Effector 2D
Point Effector 2D
Platform Effector 2D
Surface Effector 2D
Physics HOWTOs
Ragdoll Wizard
Joint And Ragdoll Stability
WheelCollider Tutorial
Scripting
Scripting Overview
Creating and Using Scripts
Variables and the Inspector
Controlling GameObjects Using Components
Event Functions
Time and Framerate Management
Creating and Destroying GameObjects
Coroutines
Special Folders and Script Compilation Order
Namespaces
Attributes
Execution Order of Event Functions
Understanding Automatic Memory Management
Platform Dependent Compilation
Generic Functions
Script Serialization
UnityEvents
What is a Null Reference Exception?
Important Classes
Vector Cookbook
Understanding Vector Arithmetic
Direction and Distance from One Object to Another
Computing a Normal/Perpendicular vector
The Amount of One Vector's Magnitude that Lies in Another Vector's Direction
Scripting Tools
Console
MonoDevelop
Attaching MonoDevelop Debugger To An Android Device
Profiler
Profiler window
CPU Usage Area
Rendering Area
Memory Area
Audio Area
Physics Profiler
GPU Area
Log Files
Event System
Messaging System
Input Modules
Supported Events
Raycasters
Event System Reference
Event System Manager
Graphic Raycaster
Physics 2D Raycaster
Physics Raycaster
Standalone Input Module
Touch Input Module
Event Trigger
Multiplayer and Networking
Networking overview
The High Level API
Network System Concepts
Using the NetworkManager
Object Spawning
State Synchronization
Remote Actions
Player Objects
Object Visibility
Network Messages
Matchmaker
Scene Objects
Converting a Single Player Game to Multiplayer
Multiplayer Lobby
Network Clients and Servers
Using the Transport Layer API
Internet Services
Networking Reference
Network Animator
NetworkBehaviour
NetworkClient
NetworkConnection
NetworkDiscovery
NetworkIdentity
Network Lobby Manager
Network Lobby Player
NetworkManager
Network Manager HUD
Network Proximity Checker
NetworkReader
NetworkServer
NetworkStartPosition
NetworkTransform
NetworkTransformChild
NetworkTransformVisualizer
NetworkTransport
NetworkWriter
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
Audio Reference
Audio Components
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 IT 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 IT Echo Effect
Audio Compressor Effect
Audio SFX Reverb Effect
Audio Low Pass Simple Effect
Audio Delay Effect
Audio High Pass Simple Effect
Reverb Zones
Microphone
Audio Settings
Animation
Unity's Animation System
Animation Clips
Animation from External Sources
Working with humanoid animations
Creating the Avatar
Configuring the Avatar
Muscle setup
Asset Preparation and Import
Using Humanoid Characters
Preparing your own character
Generic Animations in Mecanim
Splitting Animations
Looping animation clips
Masking Imported Clips
Animation Curves on Imported Clips
Animation Events on Imported Clips
Selecting a Root Motion Node
Animation View Guide
Using the Animation View
Using Animation Curves
Editing Curves
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
Animation Blend Shapes
Animator Override Controllers
Retargeting of Humanoid animations
Performance and Optimization
Animation Reference
Animation Clip
Animator Component
Animator Controller
Creating an AnimatorController
Animation States
Animation Transitions
Avatar Mask
Human Template files
Importing models
Models
FBX Importer, Rig options
FBX Importer - Animations Tab
3D formats
Animation HOWTOs
Animation FAQ
Using Blender and Rigify
Playable API
Custom Playables
Graph Visualizer
A Glossary of Animation and Mecanim terms
Legacy animation system
Animation
Animation Scripting (Legacy)
UI
UI Overview
Canvas
Basic Layout
Visual Components
Interaction Components
Animation Integration
Auto Layout
Rich Text
Legacy GUI Scripting Guide
GUI Basics (Legacy)
Controls (Legacy)
Customization (Legacy)
Layout Modes (Legacy)
Extending GUI (Legacy)
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
Legacy GUI
UnityGUI Group (Legacy)
GUI Skin (Legacy)
GUI Style (Legacy)
GUI Text (Legacy)
GUI Texture (Legacy)
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 Transitons
Navigation and Pathfinding
Navigation Overview
Navigation System in Unity
Inner Workings of the Navigation System
Building a NavMesh
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
NavMesh 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
Architecture
Architecture Overview
Asset Import and Creation
Primitive Objects
Importing Assets
Asset Store
Asset Store Access and Navigation
Mass Labeler
Asset Store Publisher Administration
Asset Store FAQ
Asset Store Publishing Guide
DeprecateAssetGuide
Asset Store Manual
Setting up Google Analytics
Viewing the status of your Asset store submissions:
Refunding Your Customers.
Removing your Assets from the Store.
Providing Support
How to Promote your Assets (Daily Deals)
Publisher Admin Section Overview
Asset Server (Team License)
Setting up the Asset Server
Cache Server (Team License)
Behind the Scenes
AssetDatabase
Loading Resources at Runtime
Modifying Source Assets Through Scripting
Build Player Pipeline
Reducing the File Size of the Build
Plugins
Plugin Inspector
Managed Plugins
Native Plugins
Building Plugins for Desktop Platforms
Low-level Native Plugin Interface
Textual Scene File Format
Description of the Format
An Example of a YAML Scene File
YAML Class ID Reference
Streaming Assets
Command line arguments
Running Editor Script Code on Launch
Architecture Reference
GameObject
ScriptableObject
Transform
Asset Components
Standalone Plugin Settings
Networking on Mobile devices.
Social API
Legacy Network Reference Guide
High Level Networking Concepts (Legacy)
Networking Elements in Unity (Legacy)
Network Views (Legacy)
RPC Details (Legacy)
State Synchronization Details (Legacy)
Network Instantiate (Legacy)
Network Level Loading (Legacy)
Master Server (Legacy)
Building the Unity Networking Servers on your own (Legacy)
Minimizing Network Bandwidth (Legacy)
Architecture HOWTOs
AssetBundles
AssetBundles FAQ
BuildingAssetBundles in 5.x
Enhanced Asset Bundle Workflow
Downloading AssetBundles
Loading and unloading objects from an AssetBundle
Keeping Track of loaded AssetBundles
Storing and loading binary data in an AssetBundle
Protecting Content
Managing asset dependencies
Including scripts in AssetBundles
Legacy Asset Bundles
Building AssetBundles in 4.x
Mobile Developer Checklist
Crashes
Profiling
Optimizations
Practical Guide to Optimization for Mobiles
Future & High End Devices
Graphics Methods
Scripting and Gameplay Methods
Rendering Optimizations
Optimizing Scripts
Unity Updates and Activation
Using the Automatic API Updater
5.2 Upgrade Guide
Unity 5.0 Upgrade Guide
AI - 5.0 Upgrade Guide
Animation - 5.0 Upgrade Guide
Audio - 5.0 Upgrade Guide
Baked Data format changes - 5.0 Upgrade Guide
Plugins - 5.0 Upgrade Guide
Physics - 5.0 Upgrade Guide
Shaders - 5.0 Upgrade Guide
Miscellaneous Upgrade Notes
Upgrade Guide from Unity 3.5 to 4.0
Unity 5 Activation - Overview
Step-by-Step Guide to Online Activation of Unity
Step-by-Step Guide to Manual Activation of Unity
Managing your Unity license
How do I reuse assets between projects?
How do I install or upgrade Standard Assets?
Porting a Project Between Platforms
Unity Services
Unity Ads
How to use Unity Ads
Best practices on rewarded ads
Important links
Unity Analytics
Integration Overview
Integration
Unity Analytics 4.x - 5.1 (SDK)
Basic Integration (SDK)
Import SDK
Create Game Script
Attach Game Script
Play To Validate
Advanced Integration (SDK)
Custom Events
Monetization
Receipt Verification
User Attributes
Unity Analytics 5.2
Basic Integration
Connect your project
Enable Analytics
Play To Validate
Advanced Integration
Custom Events
Monetization
Receipt Verification
User Attributes
Upgrading Unity Analytics
Upgrade Unity Analytics 4.x-5.1 (SDK) to 5.2
Upgrade Unity Analytics 5.1 to 5.2
Unity Analytics Re-integrate SDK to 5.1
What to Do if Project IDs Don't Match
Virtual Reality
VR Overview
VR Reference
VR Devices
Oculus
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
Platform Specific
Standalone
Standalone Player Settings
Apple Mac
How to deliver an application to the Apple Mac Store
WebGL
WebGL Preview Player Settings
Getting Started with WebGL Development
Building and Running a WebGL Project
WebGL performance considerations
WebGL: Interacting with browser scripting
WebGL Networking
Using WebGL Templates
Using Audio In WebGL
Cursor locking and fullscreen mode in WebGL
Memory Considerations when targeting WebGL
iOS
Getting Started with iOS Development
Unity iOS Basics
Account Setup
Inside the iOS build process
Structure of a Unity XCode Project
Customizing an iOS Splash Screen
iOS Hardware Guide
iOS Player Settings
iOS 2D Texture Overrides
Upgrading to 64 bit iOS
iOS Advanced Topics
Unity Remote 4
Unity Remote 3 (DEPRECATED)
iOS Scripting
iOS Game Controller support
Advanced Unity Mobile Scripting
Optimizing Performance in iOS.
iOS Specific Optimizations
Measuring Performance with the Built-in Profiler
Optimizing the Size of the Built iOS Player
Optimizing Physics Performance
Building Plugins for iOS
Preparing your application for "In App Purchases"
Customising WWW Requests on iOS
Features currently not supported by Unity iOS
Troubleshooting on iOS devices
Reporting crash bugs on iOS
Android
Getting Started with Android Development
Android SDK Setup
Unity Remote 4
Android Remote (DEPRECATED)
Troubleshooting Android development
Inside the Android Build Process
Reporting crash bugs under Android
Features currently not supported by Unity Android
Support for Split Application Binary (.OBB)
Android Scripting
Android-Advanced
Building Plugins for Android
Customizing an Android Splash Screen
Android Player Settings
Android 2D Textures Overrides
Samsung TV
Getting Started with Samsung TV Development
Samsung TV Setup
Samsung TV Input
Samsung TV Debugging
SamsungTV Restrictions
Samsung TV Not Supported
Tizen
Getting Started with Tizen Development
Setting up Unity to Build to Your Tizen Device
Tizen FAQ
Tizen Player Settings
Features currently not supported by Unity Tizen
Building Plugins for Tizen
Windows
Windows General
Windows Debugging
Windows Store Apps
Getting Started
Windows Store Apps: Deployment
Windows Store Apps: Debugging
Windows Store Apps: Profiler
Windows Store Apps: Command line arguments
Windows Store Apps: Plugins
Windows Store Apps: Association launching
Windows Store Apps: Project description
AppCallbacks class
Windows Store Apps: WinRT API in C# scripts
Windows Store Apps: Missing .NET Types
FAQ
Windows Store Apps: Examples
WSA Player Settings
Windows Phone 8
Windows Phone 8: Getting Started
Windows Phone 8: Deployment
Windows Phone 8: Debugging
Windows Phone 8: Profiler
Interaction between Unity and Windows Phone
Windows Phone 8: Plugins
Windows Phone 8: C# Plugins
Windows Phone 8: C++ Plugins
Windows Phone 8: Missing .NET Types
Windows Phone 8: FAQ
WP8 Examples
Windows Phone 8.1
Windows Phone 8.1: Getting Started
Windows Phone 8.1: Debugging
Windows Phone 8.1: FAQ
Windows Universal Applications
Windows Universal Applications: Getting Started
Windows Universal Applications: FAQ
Universal Windows 10 Apps
Universal Windows 10 Applications: Getting Started
Web Player
Web Player Deployment
HTML code to load Unity content
Working with UnityObject2
Customizing the Unity Web Player loading screen
Customizing the Unity Web Player's Behavior
Unity Web Player and browser communication
Using Webplayer Templates
Web Player Streaming
Webplayer Release Channels
Using the Chain of Trust system in the Web Player
Security Sandbox of the Webplayer
Troubleshooting Webplayer
Webplayer Player Settings
Unity Manual
Graphics
Network View
Graphics Overview
Graphics
The visual side of Unity including Cameras and Lighting.
Network View
Graphics Overview