RESUMEN DE LA API DE UNITY EN ESPAÑOL

Behaviour


VARIABLES:
enabled:  var enabled : boolean 
  Habilita/deshabilita el objeto Behaviour (y/o los objetos derivados de éste). 


Bounds


VARIABLES:
center:  var center : Vector3
  El centro de la caja.
size:  var size : Vector3 
  El tamaño total de la caja. Es siempre dos veces más grande que las extensiones 
  (extents)
extents:  var extents : Vector3 
  Las extensiones de la caja. Es siempre la mitad del tamaño (size)
min:  var min : Vector3 
  El punto mínimo de la caja. Es siempre igual a center – extents.
max:  var max : Vector3 
  El punto máximo de la caja. Siempre es igual a center+extents. 

FUNCIONES:
Bounds:  static function Bounds (center : Vector3, size : Vector3) : Bounds 
  Crea una nueva caja de bordes con un centro dado y un tamaño total. Las 
  extensiones deben ser la mitad del tamaño dado.
SetMinMax:  function SetMinMax (min : Vector3, max : Vector3) : void 
  Establece los bordes en los valores mínimos y máximos de la caja. Usar esta 
  función es más rápido que asignar min y max de manera separada. 
Encapsulate:  function Encapsulate (point : Vector3) : void
  Incrementa la caja para incluir el punto que se pasa como parámetro.
Expand:  function Expand (amount : float) : void 
  Expande la caja para incrementar su tamaño en una cantidad a lo largo de cada 
  cara.
Intersects:  function Intersects (bounds : Bounds) : boolean 
  ¿Hay alguna otra caja intersectando nuestra caja? 
Contains:  function Contains (point : Vector3) : boolean
  ¿Está el punto point contenido en la caja? 
sqrDistance:  function SqrDistance (point : Vector3) : float
  El cuadrado de la distancia entre el punto point y la caja.
IntersectRay:  function IntersectRay (ray : Ray) : boolean 
  ¿El rayo ray intersecta esta caja? 


Camera


VARIABLES:
fieldOfView:  var fieldOfView : float 
  Variable que contiene el campo de visión de la cámara en grados. 
nearClipPlane:  var nearClipPlane : float 
  El plano de recorte de cerca. Cualquier cosa que se halle más cerca de la cámara
  de la distancia establecida en esta variable no se mostrará en la cámara.
farClipPlane:  var farClipPlane : float
  El plano de recorte de lejos. Cualquier cosa que se halle más lejos de la cámara 
  de la distancia establecida en esta variable no se mostrará en la cámara.
renderingPath:  var renderingPath : RenderingPath 
  Indica el tipo de renderizado de entre los que contempla la enum RenderingPath.
actualRenderingPath:  var actualRenderingPath : RenderingPath 
  Variable de sólo lectura que contiene el rendering path que se está usando.
orthographicSize:  var orthographicSize : float 
  El campo de visión de la cámara cuando está en modo ortográfico. 
orthographic:  var orthographic : boolean 
  Variable de tipo booleano que indica si la cámara está en modo ortográfico (true)
  o en perspectiva (false) y que permite pasar de uno a otro.
depth:  var depth : float 
  La profundidad de la cámara en el orden de renderizado de las cámaras. Las 
  cámaras con profundidad más baja son renderizadas antes de las cámaras con 
  profundidad más alta. 
aspect:  var aspect : float 
  Variable en la que se guarda/coloca la proporción de aspecto (aspect ratio), que 
  es el nombre con que se conoce a la anchura dividida por la altura de la cámara. 
cullingMask:  var cullingMask : int 
  Es usada para renderizar de manera selectiva partes de la escena. 
backgroundColor:  var backgroundColor : Color 
  Variable que indica el color con el cual la pantalla será completada.
rect:  var rect : Rect 
  Establece qué parte de la pantalla esta la cámara renderizando. 
pixelRect  var pixelRect : Rect 
  Indica/establece qué parte de la pantalla esta la cámara renderizando, pero a 
  diferencia de rect, no lo indica en coordenadas normalizadas, sino en píxeles.
pixelWidth:  var pixelWidth : float 
  Indica la anchura de la cámara en píxeles. (Sólo lectura).
pixelHeight:  var pixelHeight : float 
  Esta variable indica la altura de la cámara en píxeles(sólo lectura)
velocity:  var velocity : Vector3 
  Variable de sólo lectura que indica la velocidad de la cámara en el espacio 
  global.
clearFlags:  var clearFlags : CameraClearFlags 
  Indica cómo la cámara completa el background. 

FUNCIONES:
ResetAspect:  unction ResetAspect () : void
  Revierte el aspect ratio de la cámara al aspect ratio de la pantalla, acabando 
  con el efecto de modificar la variable aspect.
WorldToScreenPoint:  function WorldToScreenPoint (position : Vector3) : 
Vector3 
  Transforma la posición de un transform desde el espacio global al espacio de la
  pantalla. 
WorldToViewportPoint:  function WorldToViewportPoint (position : Vector3) : Vector3 
  Convierte la posición de un transform desde las coordenadas globales al espacio 
  de punto de vista.
ViewportToWorldPoint:  function ViewportToWorldPoint (position : Vector3)
 : Vector3 
  Convierte la posición de un transform medida en el viewport space relativo de la
  cámara  a coordenadas globales. 
ScreenToWorldPoint:  function ScreenToWorldPoint (position : Vector3) :
 Vector3 
  Convierte la posición de un transform desde el espacio de pantalla en píxeles a 
  coordenadas globales.
ScreenToViewportPoint:  function ScreenToViewportPoint (position : 
Vector3) : Vector3 
  Convierte la posición de un transform de espacio de pantalla en píxeles a 
  viewport space relativo al espacio de cámara. 
ViewportToScreenPoint:  function ViewportToScreenPoint (position : 
Vector3) : Vector3 
  Convierte la posición del transform de viewport space relativo al espacio de 
  cámara en espacio de pantalla en píxeles.
ViewportPointToRay:  function ViewportPointToRay (position : Vector3) : 
Ray 
  Devuelve un rayo que sale de la cámara en coordenadas relativas a ésta.
ScreenPointToRay:  function ScreenPointToRay (position : Vector3) : ray
  Devuelve un rayo que va de la cámara a través de un punto de la pantalla.
Render:  function Render () : void 
  Renderiza la cámara manualmente, usando el clear flags de la cámara, target 
  texture y otras propiedades. 
RenderWithShader:  function RenderWithShader (shader : Shader, 
replacementTag : String) : void 
  Hace que la cámara renderice con reemplazo de sombreado (shader) . 
SetReplacementShader:  function SetReplacementShader (shader : Shader, 
replacementTag : String) : void 
  Hace que la cámara renderice con shader replacement.
ResetReplacementShader:  function ResetReplacementShader () : void 
  Borra el shader replacement de la cámara provocado por la función anterior. 
RenderToCubemap:   function RenderToCubemap (cubemap : Cubemap, faceMask
 : int = 63) : boolean 
  Renderiza un cubemap desde la cámara que llama a esta función. 
CopyFrom:  function CopyFrom (other : Camera) : void 
  Permite copiar para una cámara todas las variables de otra cámara (campo de 
  vision, clear flags, culling mask…).

VARIABLES DE CLASE:
main:  static var main : Camera
  Variable de sólo lectura que se refiere a la cámara que esté habilitada y con el
  tag “Main Camera”.
allCameras:  static var allCameras : Camera[]
  Devuelve todas las cámaras habilitadas en la escena.



CharacterController


VARIABLES:
isGrounded:  var isGrounded : boolean 
  Bool que devuelve true si nuestro character controller estaba tocando el suelo 
  durante el último movimiento.
velocity:  var velocity : Vector3 
  Esta variable nos indicá qué parte de la cápsula de nuestro character controller
  colisionó con el entorno durante la última llamada a CharacterController.Move. 
radius:  var radius : float 
  El radio de la cápsula del character controller. 
height:  var height : float 
  La altura de la cápsula del character controller. 
center:  var center : Vector3 
  El centro de la cápsula del character relativo a la posición del transform.
slopeLimit:  var slopeLimit : float 
  El límite de pendiente en grados por el que puede ascender nuestro character 
  controller. 
stepOffset:  var stepOffset : float 
  Los límites de altura que el character controller podrá superar, fijados en 
  metros.
detectCollisions:  var detectCollisions : boolean 
  Determina si otros rigidbodies o character controllers colisionan con nuestro 
  character Controller

FUNCIONES:
Move:  function Move (motion : Vector3) : CollisionFlags 
  Esta función mueve un character controller en la dirección y velocidad 
  establecida por el parámetro de tipo vector tres. Dicho movimiento sólo será 
  restringido por las colisiones que sufra el character.
SimpleMove: function SimpleMove (speed : Vector3) : boolean 
  Mueve un character controller con una velocidad dada y asignándole gravedad.



CharacterJoint


VARIABLES:
swingAxis:  var swingAxis : Vector3 
  El eje secundario alrededor del cual el joint puede rotar.
lowTwistLimit:  var lowTwistLimit : SoftJointLimit 
  El límite menor del ángulo permitido alrededor del eje primario del 
  characterjoint. 
highTwistLimit:  var highTwistLimit : SoftJointLimit 
  El límite superior altededor del eje primario del characterjoint.
swing1Limit:  var swing1Limit : SoftJointLimit
  El límite alrededor del eje primario del characterjoint. 
swing2Limit:  var swing2Limit : SoftJointLimit 
  El límite alrededor el eje primario del joint del character.


Collider


VARIABLES:
enabled:  var enabled : boolean 
  Si el collider está habilitado (true), colisionará con otros colliders. 
attachedRigidbody:  var attachedRigidbody : Rigidbody 
  Esta variable hace referencia al rigidbody vinculado a este collider, y permite 
  acceder a él. Devuelve nulo si el collider no tiene rigidbody.
isTrigger:  var isTrigger : boolean 
  Si esta variable está habilitada (true) el collider se convierte en un trigger
  (lo podríamos traducir por "desencadenante" o "disparador"). Un trigger no 
  colisiona con rigidbodies, y en su lugar envía los mensajes OnTriggerEnter, 
  OnTriggerExit y OnTriggerStay.
material:  var material : PhysicMaterial 
  El material usado por el collider.
sharerMaterial:  var sharedMaterial : PhysicMaterial 
  El material compartido de este collider. Modificando este material cambiaremos 
  las propiedades de la superficie de todos los colliders que estén usando el mismo
  material.
bounds:  var bounds : Bounds 
  Los límites/bordes del collider en coordenadas globales.

FUNCIONES:
ClosestPointOfBounds:  function ClosestPointOnBounds (position : Vector3) : Vector3 
  Devuelve el punto más cercano de nuestro Collider con respecto a un punto dado.
Raycast:  function Raycast (ray : Ray, hitInfo : RaycastHit, distance : float) 
: boolean 
  Proyecta un rayo que devuelve true si tropieza con algún collider en la dirección 
  y distancia indicadas. En este caso, además, nos provee de información sobre 
  dicho collider.
OnTriggerEnter:  function OnTriggerEnter (other : Collider) : void 
  Es llamada cuando nuestro trigger entra en contacto con el collider "other".
OnTriggerExit:  function OnTriggerExit (other : Collider) : void  
  Es llamada cuando el collider "other" deja de tocar con nuestro trigger.
OnTriggerStay:  function OnTriggerStay (other : Collider) : void 
  Es llamada casi todos los frames que el collider other esté tocando nuestro 
  trigger.
OnCollisionEnter:  function OnCollisionEnter (collisionInfo : Collision) : void
  Es llamada cuando nuestro collider/rigidbody empiece a tocar otro 
  rigidbody/collider.
OnCollisionExit:  function OnCollisionExit (collisionInfo : Collision) : void
  Es llamada cuando nuestro collider/rigidbody deja de tocar otro 
  rigidbody/collider.
OnCollisionStay:  function OnCollisionStay (collisionInfo : Collision) : void 
  Es llamada una vez por frame por cada collider/rigidbody que esté tocando nuestro 
  rigidbody/collider.


Collision


VARIABLES:
relativeVelocity:  var relativeVelocity : Vector3 
  Variable de sólo lectura que devuelve la velocidad lineal relativa de los dos 
  objetos que colisionan.
rigidbody:  var rigidbody : Rigidbody 
  Variable de sólo lectura que hace referencia al rigidbody que golpeamos. 
collider:  var collider : Collider 
  El collider que golpeamos (sólo lectura).
transform:  var transform : Transform
  El transform del objeto que golpeamos (read only).
gameObject:  var gameObject : GameObject 
  Variable de sólo lectura que devuelve el objeto con el que chocamos.
contacts:  var contacts : ContactPoint[] 
  El punto de contacto generado por el engine de físicas. 


ControllerColliderHit


VARIABLES:
controller:  var controller : CharacterController 
  El controller que golpea el collider.
collider:  var collider : Collider 
  El collider que fue golpeado por el controller.
rigidbody:  var rigidbody : Rigidbody 
  El rigidbody que fue golpeado por el controller. 
gameObject:  var gameObject : GameObject 
  El game object que fue golpeado por el controller.
transform:  var transform : Transform 
  El transform que fue golpeado por el controller. 
point:  var point : Vector3 
  El punto de impacto en coordenadas globales.
normal:  var normal : Vector3
  El normal de la superficie con la que colisionamos en coordenadas globales.
moveDirection:  var moveDirection : Vector3 
  Aproximadamente la dirección desde el centro de la cápsula al punto que tocamos. 
moveLenght:  var moveLength : float
  Indica lo lejos que el character controller ha viajado hasta golpear al collider.


Cubemap


VARIABLES:
format:  var format : TextureFormat 
  El formato de los datos de los píxeles en la textura. Sólo lectura.

FUNCIONES:
Cubemap:  static function Cubemap (size : int, format : TextureFormat, 
mipmap : boolean) : Cubemap 
  Crea una nueva textura de cubemap. La textura puede tener tamaño en cada lado y 
  con o sin mipmaps.
SetPixel:  function SetPixel (face : CubemapFace, x : int, y : int, color
 : Color) : void 
  Coloca el color del pixel en las coordenadas (face, x, y)
GetPixel:  function GetPixel (face : CubemapFace, x : int, y : int) : 
Color 
  Devuelve el color del pixel en las coordenadas (face, x, y) 
GetPixels:  function GetPixels (face : CubemapFace, miplevel : int = 0) :
 Color[] 
  Devuelve el color del pixel de una cara del cubemap. Devuelve un array de colores 
  de píxeles de una cara del cubemap.
SetPixels:  function SetPixels (colors : Color[], face : CubemapFace, 
miplevel : int = 0) : void 
  Establece colores de pixeles de una cara del cubemap. Esta función toma un array
  de color y cambia los colores de los píxeles de la cara completa del cubemap.
Apply:  function Apply (updateMipmaps : boolean = true) : void 
  Aplica en realidad todos los previos cambios de SetPixel y Setpixels.


Debug


VARIABLES DE CLASE:
isDebugBuild:  static var isDebugBuild : boolean 
  En el diálogo Build Settings, que podemos encontrar en el menú=>File, hay un 
  check box llamado “Development Build”. Si dicho check box está marcado, entonces 
  isDebugBuild será true.

FUNCIONES DE CLASE:
DrawLine:  static function DrawLine (start : Vector3, end : Vector3, color : 
Color = Color.white, duration : float = 0.0f) : void
  Dibuja una línea desde el punto que le pasemos como parámetro start hasta el 
  establecido como end con el color que le establezcamos como tercer parámetro y 
  durante un tiempo fijado en duration.
DrawRay:  static function DrawRay (start : Vector3, dir : Vector3, color : Color = 
Color.white, duration : float = 0.0f) : void
  Dibuja una línea desde start a start+dir con el color que especifiquemos por una 
  duración de tiempo también establecida.
Break:  static function Break () : void 
  Pausa el editor. 
Log:  static function Log (message : object) : void
  static function Log (message : object) : void
LogError:  static function LogError (message : object) : void 
  Una variable de Debug.Log que anota un mensaje de error en la consola (en color
  rojo)
LogWarning:  static function LogWarning (message : object) : void


Event


VARIABLES:
type:  var type : EventType 
  Variable que indica el tipo de evento. 
mousePosition:  var mousePosition : Vector2 
  La posición del ratón. 
delta:  var delta : Vector2 
  El movimiento relativo del ratón comparado con el último evento. 
button:  var button : int 
  Qué botón del ratón ha sido presionado.
modifiers:  var modifiers : EventModifiers 
  Qué tecla modificadora está siendo pulsada( ahift, ctrl, alt...)
clickCount:  var clickCount : int 
  Cuántos clicks de ratón consecutivos hemos recibido. 
character:  var character : char 
  El tipo de caracter. 
commandName:  var commandName : String 
  El nombre de un evento de tipo ExecuteCommand o Validate Command ("Copy", "Cut", 
  "Paste", "Delete", "FrameSelected", "Duplicate", "SelectAll", etc) 
keyCode:  var keyCode : KeyCode
  El key code para eventos de teclado. 
shift:  var shift : boolean 
  ¿Está shift pulsado? (sólo lectura)
control:  var control : boolean 
  ¿Está control pulsado? (sólo lectura)
alt:  var alt : boolean
  ¿Está alt pulsado? (Sólo lectura)
capsLock:  var capsLock : boolean
  ¿Está el bloqueo de mayúsculas pulsado? (sólo lectura)
numeric:   var numeric : boolean
  ¿Se está presionando alguna tecla del teclado numérico) (sólo lectura)
functionKey:  var functionKey : boolean
  ¿Es la tecla presionada una tecla de función (alt, ctrl, shift, etc)? (Sólo 
 lectura)
isKey:  var isKey : boolean
  ¿Es este evento un evento de teclado? (sólo lectura)
isMouse:  var isMouse : boolean
  ¿Es este evento un evento de ratón? (sólo lectura)

FUNCIONES:
GetTypeForControl:  function GetTypeForControl (controlID : int) : EventType 
  Esta función devuelve un tipo de evento que es filtrado para un determinado 
  control cuya id pasamos como parámetro. 
Use:  function Use () : void 
  Evento ya utilizado. deberíamos llamar a este método cuando ya hemos usado un 
  evento.

VARIABLES DE CLASE:
current:  static var current : Event 
  El evento actual/corriente que está siendo procesado en este mismo momento.


GameObject


VARIABLES:
isStatic:  var isStatic : boolean 
  Variable sólo utilizable vía interface que especifica si un objeto es estático.
transform:  var transform : Transform 
  El transform del gameobject, si lo tiene. Null si no tiene ningún transform 
  vinculado. 
rigidbody:  var rigidbody : Rigidbody 
  El rigidbody vinculado a nuestro gameobject, o null si éste no tiene rigidbody.
camera:  var camera : Camera 
  La cámara vinculada a nuestro gameobject, o null si éste no tiene una cámara. 
light:  var light : Light 
  La luz vinculada al gameobject. Null si no tiene.
animation:  var animation : Animation 
  La animación vinculada al gameobject. Null si no tiene.
constantForce:  var constantForce : ConstantForce 
  La constantForce vinculada a este gameobject. Null si no tiene ninguna vinculada.
renderer:  var renderer : Renderer 
  El renderer vinculado al gameobject. Null si no tiene.
audio:  var audio : AudioSource 
  El audiosource vinculado al gameobject. Null si no tiene.
guiText:  var guiText : GUIText 
  El guiText vinculado al gameobject. Null si no existe.
networkView:  var networkView : NetworkView 
  El networkView vinculado al gameobject. Null si no existe.
guiTexture:  var guiTexture : GUITexture 
  El guiTEXture vinculado al gameobject. Null si carece de él.
collider:  var collider : Collider 
  El collider vinculado al gameobject, si lo tiene. Null en caso contrario.
hingeJoint:  var hingeJoint : HingeJoint 
  El hingeJoint vinculado al gameobject, o null.
particleEmitter:  var particleEmitter : ParticleEmitter 
  El particleEmitter vinculado al gameobject, null si no tiene.
layer:  var layer : int 
  Es una variable de tipo int comprendida entre el rango 0 y 31 que indica/coloca 
  la capa en la que el gameobject se encuentra.
active:  var active : boolean 
  ¿Está el gameobject activo?. Podemos habilitarlo/deshabilitarlo cambiando a true 
  o false este booleano.
tag:  var tag : String 
  El tag (etiqueta) de este game object. 

FUNCIONES:
GameObject:  static function GameObject (name : String) : GameObject 
  Nos permite crear un nuevo gameobject y pasarle un parámetro que constituirá el 
  nombre de dicho gameobject.   
GetComponent:  function GetComponent (type : Type) : Component
  Esta función devuelve el componente de tipo Type que tenga el gameobject. En caso 
  de que el gameobject que lanza el mensaje no tenga ningún componente de ese tipo,
  devuelve null.
GetComponentInChildren:  function GetComponentInChildren (type : Type) : 
Component
  Devuelve un componente activo de tipo que le pasamos como parámetro que pueda 
  tener o bien el Gameobject que lanza el mensaje o bien sus hijos.
GetComponents:  function GetComponents (type : Type) : Component[] 
  Esta función devuelve todos los componentes del tipo Type y los devuelve en forma
  de array del tipo de componente solicitado.
GetComponentsInChildren:  function GetComponentsInChildren (type : Type, 
includeInactive : boolean = false) : Component[]
  Devuelve todos los componentes del tipo pasado como primer parámetro que tenga 
  ese gameobjects y sus hijos. La peculiaridad es que la función incluye un segundo 
  parámetro opcional de tipo booleano que si establecemos en true nos permite 
  recuperar también los componentes inactivos de ese tipo.
SetActiveRecursively:  function SetActiveRecursively (state : boolean) : 
void 
  Función que activa o desactiva el estado del gameobject que la invoca y de todos 
  sus hijos, en función de si el bolean que tiene como parámetro está en true o 
  false.
CompareTag:  function CompareTag (tag : String) : boolean
  Esta función nos permite averiguar si un determinado gameobjet tiene como tag el 
  string colocado como parámetro de la función. Si lo tiene, la función devuelve 
  true. 
SendMessageUpwards:  function SendMessageUpwards (methodName : String, 
value : object = null, options : SendMessageOptions = 
SendMessageOptions.RequireReceiver) : void 
  Esta función llama a una función cuyo nombre pasamos en el parámetro methodName y
  que se encuentre en cualquier script que tengamos vinculado al gameobject que 
  hace la llamada o en los "padres" de dicho gameobject.
SendMessage:  function SendMessage (methodName : String, value : object = 
null, options : SendMessageOptions = SendMessageOptions.RequireReceiver) : void 
  Igual que la función anterior, con la diferencia de que en esta sólo podemos 
  llamar a funciones que estén en scripts vinculados al gameobject, pero no en sus 
  ancestros.
BroadcastMessage:  function BroadcastMessage (methodName : String, 
parameter : object = null, options : SendMessageOptions = 
SendMessageOptions.RequireReceiver) : void
  Llama a un método con nombre methodName que esté en cualquier script vinculado a 
  ese game object o a cualquiera de sus hijos, a diferencia de las funciones
  anteriores.
AddComponent:  function AddComponent (className : String) : Component 
  Añade un componente a nuestro gameobject. Ese componente ha de ser una instancia 
  de la clase que ponemos en el parámetro className, o bien puede ser el nombre de 
  un script. 

FUNCIONES DE CLASE:
CreatePrimitive:  static function CreatePrimitive (type : PrimitiveType) 
: GameObject 
  Crea un gameobject con una malla de tipo primitivo y el apropiado collider.
FindWithTag:  static function FindWithTag (tag : String) : GameObject
  Devuelve un gameobject con el tag que le pasamos a la función como string en su 
  único parámetro. Si no existe ninguno. Devuelve null. 
FindGameObjectWithTag:  static function FindGameObjectsWithTag (tag : 
String) : GameObject[] 
  Esta función de clase devuelve una lista de gameobjects activos que tengan el tag
  requerido.
Find:  static function Find (name : String) : GameObject 
  Busca un gameobject por nombre y lo devuelve. 


Gizmos


VARIABLES DE CLASE:
color:  static var color : Color 
  Establece el color para los gizmos que serán dibujados a continuación. 


FUNCIONES DE CLASE:
DrawRay:  static function DrawRay (r : Ray) : void 
  Dibuja un rayo que empieza desde from hasta from + direction. 
DrawWireSphere:  static function DrawWireSphere (center : Vector3, radius : float)
 : void 
  Dibuja una esfera de alambre con centro y radio. 
DrawSphere:  static function DrawSphere (center : Vector3, radius : float) : void
  Dibuja una esfera sólida con centro y radio. 
DrawWireCube:  static function DrawWireCube (center : Vector3, size : Vector3) : void
  Dibuja una caja de alambre con centro y tamaño. 
DrawCube:  static function DrawCube (center : Vector3, size : Vector3) : void 
  Dibuja una caja sólida con centro y tamaño. 
DrawIcon:  static function DrawIcon (center : Vector3, name : String) : void 
  Dibuja un icono en posición global en la vista de escena. 
DrawGUITexture:  static function DrawGUITexture (screenRect : Rect, texture : 
Texture, mat : Material = null) : void 
  static function DrawGUITexture (screenRect : Rect, texture : Texture, mat : 
  Material = null) : void 


GUI


VARIABLES DE CLASE:
skin:  static var skin : GUISkin 
  La skin (que podemos traducir por "piel" o "aspecto") en uso. Cambiando esta 
  variable podemos cambiar el look de nuestra GUI. 
color:  static var color : Color 
  Color del tintero global de la GUI. Afectará tanto a la parte trasera de los 
  elementos (background) como a los colores del texto que escribamos sobre 
  cualquier superficie.
backgroundColor:  static var backgroundColor : Color 
  Color del tintero para todas las partes traseras (background) de los elementos 
  renderizados para la GUI. 
contentColor:  static var contentColor : Color
  Color de tinta para todo el texto renderizado en la GUI. 
changed:  static var changed : boolean 
  Devuelve true si algún control cambia el valor de los datos de entrada de la GUI. 
enabled:  static var enabled : boolean 
  Habilita/deshabilita la GUI.Si establecemos esta variable en false se 
  deshabilitan todas las interacciones de la GUI. 
tooltip:  static var tooltip : String 
  Un tooltip es ese pequeña nota emergente que aparece a veces con determinada 
  información cuando colocamos un ratón sobre un control, o dicho control tiene el
  foco del teclado. 
depth:  static var depth : int 
  El orden de profundidad que tendrá cada actividad GUI en ejecución. 

FUNCIONES DE CLASE:
Label:  static function Label (position : Rect, text : String) : void
  Crea una etiqueta (label) de texto o de imagen en la pantalla.
DrawTexture:  static function DrawTexture (position : Rect, image : 
Texture, scaleMode : ScaleMode = ScaleMode.StretchToFill, alphaBlend : boolean = 
true, imageAspect : float = 0) : void
  Dibuja una textura dentro de un rectángulo. 
Box:  static function Box (position : Rect, text : String) : void
  Como su nombre indica, crea un cuadro o caja.
Button:  static function Button (position : Rect, text : String) : 
boolean
  Función que crea un botón que, al ser pulsado por un usuario, dispara algún tipo
  de evento.
RepeatButton:  static function RepeatButton (position : Rect, text : 
String) : boolean
  Función que crea un botón que está activo mientras el usuario lo presiona.
TextField:  static function TextField (position : Rect, text : String) : 
String
  Crea un campo de texto de una línea donde el usuario puede editar un string. 
  Devuelve un string con el texto editado.
PasswordField:  static function PasswordField (position : Rect, password 
: String, maskChar : char) : String
  Crea un campo de texto donde el usuario puede introducir una contraseña. Devuelve 
  un string con la contraseña editada.
TextArea:  static function TextArea (position : Rect, text : String) : 
String
  Crea un área de texto de varias líneas donde el usuario puede editar un string. 
  Devuelve el string editado. 
SetNextControlName:  static function SetNextControlName (name : String) : 
void 
  Función que establece el nombre del siguiente control. Esto hace que el siguiente
  control sea registrado con un nombre dado. 
GetNameOfFocusedControl:  static function GetNameOfFocusedControl () : 
String 
  Obtiene el nombre del control que tiene el foco. 
FocusControl:  static function FocusControl (name : String) : void 
  Mueve el foco del teclado a un control nombrado.
Toggle:  static function Toggle (position : Rect, value : boolean, text :
 String) : boolean
  Crea un botón de tipo interruptor (on/off). Devuelve el nuevo valor del 
  botón(true/false).
Toolbar:  static function Toolbar (position : Rect, selected : int, texts
 : string[]) : int
  Función que crea una barra de herramientas. Devuelve -un int- el índice de la 
  toolbar seleccionado.
SelectionGrid:  static function SelectionGrid (position : Rect, selected
 : int, texts : string[], xCount : int) : int
  Hace una cuadrícula (grid) de botones. Devuelve un int con el índice del botón 
  seleccionado.
HorizontalSlider:  static function HorizontalSlider (position : Rect, 
value : float, leftValue : float, rightValue : float) : float
  Crea una barra de desplazamiento horizontal que el usuario puede arrastrar para 
  cambiar un valor entre un mínimo y un máximo.
VerticalSlider:  static function VerticalSlider (position : Rect, value :
 float, topValue : float, bottomValue : float) : float
  Crea una barra de deslizamiento vertical que el usuario puede arrastrar para 
  cambiar un valor entre un mínimo y un máximo. 
HorizontalScrollbar:  static function HorizontalScrollbar (position : 
Rect, value : float, size : float, leftValue : float, rightValue : float) : 
float
  Crea una barra de desplazamiento (scrollbar) horizontal. 
VerticalScrollbar:  static function VerticalScrollbar (position : Rect,
 value : float, size : float, topValue : float, bottomValue : float, style : 
GUIStyle) : float
  Crea una barra de desplazamiento (scrollbar) vertical.
BeginGroup:  static function BeginGroup (position : Rect) : void
  Comienza un grupo. Esta función debe emparejarse con una llamada a EndGroup.
EndGroup:  static function EndGroup () : void 
  Finaliza un grupo.
BeginScrollView:  static function BeginScrollView (position : Rect,
 scrollPosition : Vector2, viewRect : Rect) : Vector2
  Inicia una vista de desplazamiento (scrollview) dentro de la GUI.
EndScrollView:  static function EndScrollView () : void 
  Acaba un scrollview iniciado con una llamada a BeginScrollView.
ScrollTo:  static function ScrollTo (position : Rect) : void
  Desplaza todos los scrollviews incluidos para tratar de hacer visible una 
  determinada posición.
Window:  static function Window (id : int, clientRect : Rect, func : 
WindowFunction, text : String) : Rect
  Crea una ventana emergente y devuelve el rectángulo en el que dicha ventana se 
  ubica.
DragWindow:  static function DragWindow (position : Rect) : void 
  Crea una ventana que puede arrastrarse.
BringWindowToFront:  static function BringWindowToFront (windowID : int) 
: void 
  Trae una ventana determinada al frente del resto de ventanas flotantes. 
BringWindowToBack:  static function BringWindowToBack (windowID : int) : 
void 
  Coloca una ventana determinada al fondo de las ventanas flotantes.
FocusWindow:  static function FocusWindow (windowID : int) : void 
  Hace que una ventana se convierta en la ventana activa.
UnFocusWindow:  static function UnfocusWindow () : void 
  Quita el foco de todas las ventanas.


GUIElement


FUNCIONES:
HitTest:  function HitTest (screenPosition : Vector3, camera : Camera = 
null) : boolean
  Es un punto en la pantalla dentro del elemento. Devuelve true si la posición 
  pasada como parámetro screenPosition está contenida en este GUIElement. 
GetScreenRect:  function GetScreenRect (camera : Camera = null) : Rect
  Devuelve lo bordes del rectángulo del GUIElement en coordenadas de pantalla.


GUILayout


FUNCIONES DE CLASE:
Label:  static function Label (image : Texture, params options : 
GUILayoutOption[]) : void 
  Hace una etiqueta de distribución automática. 
Box:  static function Box (image : Texture, params options : 
GUILayoutOption[]) : void
  crea una caja de distribución automática.
Button:  static function Button (image : Texture, params options : 
GUILayoutOption[]) : boolean 
  Crea un botón con distribución automática que devuelve true cuando el usuario lo
  presiona. 
RepeatButton:  static function RepeatButton (image : Texture, params 
options : GUILayoutOption[]) : boolean 
  Crea un botón que devuelve true tanto tiempo como el usuario lo mantiene pulsado.
TextField:  static function TextField (text : String, params options : 
GUILayoutOption[]) : String 
  Crea un campo de texto de una linea donde el usuario puede editar un string. 
PasswordField:  static function PasswordField (password : String, 
maskChar : char, params options : GUILayoutOption[]) : String 
  Crea un campo de texto donde el usuario puede entrar una contraseña. Devuelve la 
  contraseña editada. 
TextArea:  static function TextArea (text : String, params options : 
GUILayoutOption[]) : String 
  Crea un campo de texto multilínea donde el user puede editar un string, y 
  devuelve dicho string.
Toggle: static function Toggle (value : boolean, image : Texture, params 
options : GUILayoutOption[]) : boolean 
  Crea un botón que alterna on/off. Devuelve un booleano que indica el estado de 
  dicho botón.
Toolbar: static function Toolbar (selected : int, images : Texture[], 
params options : GUILayoutOption[]) : int 
  Crea un toolbar (barra de herramientas). Devuelve un int que contiene el índice 
  del botón seleccionado. 
SelectionGrid: static function SelectionGrid (selected : int, texts :
 string[], xCount : int, params options : GUILayoutOption[]) : int 
  Crea una cuadrícula de selección, devolviendo el int con el índice del botón 
  seleccionado. 
HorizontalSlider:  tatic function HorizontalSlider (value : float, 
leftValue : float, rightValue : float, params options : GUILayoutOption[]) : float 
  Crea una barra de desplazamiento horizontal que el usuario puede arrastrar desde 
  un mínimo hasta un máximo. Devuelve un float con el valor que ha sido escogido 
  por el usuario. 
VerticalSlider:  static function VerticalSlider (value : float, leftValue
 : float, rightValue : float, params options : GUILayoutOption[]) : float
  Crea una barra de desplazamiento vertical que el usuario puede arrastrar desde un 
  mínimo hasta un máximo.
HorizontalScrollbar: static function HorizontalScrollbar (value : float, 
size : float, leftValue : float, rightValue : float, params options : 
GUILayoutOption[]) : float 
  Crea un scrollbar horizontal. Devuelve el valor modificado en float, que puede 
  ser cambiado por el usuario arrastrando el scrollbar o haciendo click en las 
  flechas al final. 
VerticalScrollbar:  static function VerticalScrollbar (value : float, 
size : float, topValue : float, bottomValue : float, params options : 
GUILayoutOption[]) : float
  Crea un scrollbar vertical.
Space:  static function Space (pixels : float) : void 
  Inserta un espacio en el actual grupo de distribución. La dirección de dicho 
  espacio dependerá del la dirección del grupo de distribución en el que estemos 
  trabajando. 
FlexibleSpace:  static function FlexibleSpace () : void 
  Inserta un elemento de espacio flexible. Esta función utiliza cualquier espacio 
  que sobra en un diseño.
BeginHorizontal:  static function BeginHorizontal (params options : 
GUILayoutOption[]) : void 
  Empieza un grupo de controles horizontal. Todos los controles dentro de este
  elemento serán colocados horizontalmente uno junto a otro. El grupo debe cerrarse
  con una llamada a EndHorizontal. 
EndHorizontal:  static function EndHorizontal () : void 
  Cierra el grupo abierto por BeginHorizontal. 
BeginVertical:  static function BeginVertical (params options : 
GUILayoutOption[]) : void 
  Empieza un grupo de controles vertical. Todos los controles dentro de este 
  elemento serán situados verticalmente uno debajo del otro. El grupo debe cerrarse
  con EndVertical.
EndVertical:  static function EndVertical () : void 
  Cierra un grupo iniciado por BeginVertical.
BeginArea:  static function BeginArea (screenRect : Rect) : void 
  Comienza un bloque GUILayout de controles GUI en un determinado área de la 
  pantalla. 
EndArea:  static function EndArea () : void 
  Cierra un área de controles abierto con BeginArea.
BeginScrollView:  static function BeginScrollView (scrollPosition : 
Vector2, params options : GUILayoutOption[]) : Vector2 
  Comienza un scrollview (o vista de desplazamiento) automáticamente distribuído.
EndScrollView:  static function EndScrollView () : void 
  Finaliza un scroll view empezado con una llamada a BeginScrollView.
Window:  static function Window (id : int, screenRect : Rect, func : 
GUI.WindowFunction, text : String, : ) : Rect 
  Crea una ventana emergente que distribuye su contenido automáticamente. 
Width:  static function Width (width : float) : GUILayoutOption 
  Opción pasada a un control para darle una anchura absoluta. 
MinWidth:  static function MinWidth (minWidth : float) : GUILayoutOption 
  Opción pasada a un control para especificar una anchura mínima. 
MaxWidth:  static function MaxWidth (maxWidth : float) : GUILayoutOption 
  Opción pasada a un control para especificar una anchura máxima. 
Height:  static function Height (height : float) : GUILayoutOption 
  Opción pasada a un control para darle una altura absoluta.
MinHeight:  static function MinHeight (minHeight : float) : 
GUILayoutOption 
  Opción pasada a un control para especificar una altura mínima.
MaxHeight:  static function MaxHeight (maxHeight : float) : 
GUILayoutOption 
  Opción pasada a un control para especificar una altura máxima.
ExpandWidth:  static function ExpandWidth (expand : boolean) : 
GUILayoutOption 
  Opción pasada a un control para habilitar o deshabilitar la expansión horizontal.
ExpandHeight:  static function ExpandHeight (expand : boolean) :
GUILayoutOption
  Opción pasada a un control para habilitar o deshabilitar la expansión vertical.


GUIText


VARIABLES:
text:  var text : String 
  Variable que contiene el texto que se muestra en el GUI. 
material:  var material : Material 
  El material usado para renderizar el texto.
pixelOffset:  var pixelOffset : Vector2 
  El desplazamiento en píxeles del texto desde su posición inicial (marcada por su 
  transform) en base a los valores contenidos en un Vector2.
font:  var font : Font 
  La fuente usada para el texto. Podemos asignar una de entre las que tengamos 
  disponibles.
alignment:  var alignment : TextAlignment 
  La alineación del texto.
anchor:  var anchor : TextAnchor 
  El ancla del texto. TextAnchor es una enumeración que permite indicar dónde se
  colocará el ancla o fijación del texto.
lineSpacing:  var lineSpacing : float
  El multiplicador del espacio de interlineado. Esta cantidad será multiplicada por
  el espacio de línea definido en la fuente. 
tabSize:  var tabSize : float 
  El multiplicador de la anchura del tab. Esta cantidad se multiplicará con la 
  anchura de tab definida en la fuente. 
fontSize:  var fontSize : int 
  El tamaño de fuente a usar (para fuentes dinámicas).
fontStyle:  var fontStyle : FontStyle
  Lo mismo que la anterior para el estilo de Fuentes dinámicas.


GUITexture


VARIABLES:
color:  var color : Color 
  El color de la textura de la GUI. 
texture:  var texture : Texture 
  La textura usada para el dibujo. 
pixelInset:  var pixelInset : Rect 
  Inserción de pixels usada para ajustar píxeles para tamaño y posición


HingeJoint


VARIABLES:
motor:  var motor : JointMotor 
  La variable motor aplicará una fuerza en aumento hasta conseguir la velocidad 
  deseada en grados por segundo. 
limits:  var limits : JointLimits 
  Variable que establece/indica los límites de nuestro hingejoint.
spring:  var spring : JointSpring 
  Esta variable intenta alcanzar un ángulo que es su objetivo a base de añadir 
  fuerzas de resorte y amortiguación.
useMotor:  var useMotor : boolean
  Habilita/deshabilita el motor del joint.
useLimits:  var useLimits : boolean 
  Habilita/deshabilita los límites del joint.
useSpring:  var useSpring : boolean 
  Habilita/deshabilita el resorte del joint.
velocity:  var velocity : float 
  Devuelve la velocidad actual del joint en grados por segundo.
angle:  var angle : float 
  Devuelve el ángulo actual en grados del joint con respecto a la posición inicial.
  Es una variable de solo lectura.


Input


VARIABLES DE CLASE:
mousePosition:  static var mousePosition : Vector3 
  Variable de sólo lectura que indica la posición actual del ratón en coordenadas 
  de píxeles, donde la esquina inferior izquierda de la pantalla o ventana está en 
  (0, 0) y la superior derecha en (Screen.width, Screen.height).
anyKey:  static var anyKey : boolean 
  Booleano de sólo lectura que comprueba si hay alguna tecla o botón del ratón 
  apretada en ese momento. 
anyKeyDown:  static var anyKeyDown : boolean 
  Variable de sólo lectura que devuelve true el primer frame en que el usuario 
  golpea cualquier tecla o botón del ratón.
inputString:  static var inputString : String 
  Variable de sólo lectura que devuelve la entrada de teclado introducida este 
  frame. 
acceleration:  static var acceleration : Vector3 
  Ultima medicion de aceleración lineal de un dispositimo en espacio 
  tridimensional. Sólo lectura
accelerationEvents:  static var accelerationEvents : AccelerationEvent[]
  Variable de sólo lectura que devuelve una lista de mediciones de aceleración 
  ocurridas durante el último frame. 
accelerationEventCount:  static var accelerationEventCount : int
  Número de mediciones de aceleración ocurrida durante el último frame.
eatKeyPressOnTextFieldFocus:  static var eatKeyPressOnTextFieldFocus : boolean 
  Propiedad que indica si las teclas impresas son comidas por la entrada de texto 
  si esta tiene el foco (por defecto true).

FUNCIONES DE CLASE:
GetAxis:  static function GetAxis (axisName : String) : float 
  Devuelve el valor del eje virtual identificado por el parámetro axisName.
GetAxisRaw:  static function GetAxisRaw (axisName : String) : float 
  Devuelve el valor del eje virtual identificado por el parámetro axisName sin 
  ningún filtro de suavizado aplicado.
GetButton:  static function GetButton (buttonName : String) : boolean 
  Devuelve true mientras el botón virtual que le pasemos como parámetro en formato 
  string esté presionado.
GetButtonDown:  static function GetButtonDown (buttonName : String) : boolean
  Devuelve true durante el frame en que el jugador aprieta el botón virtual 
  identificado como buttonName.  
GetButtonUp:  static function GetButtonUp (buttonName : String) : boolean 
  Devuelve true el primer frame en que el jugador libera el botón virtual 
  identificado como buttonName. 
GetKey:  static function GetKey (name : String) : boolean 
  Devuelve true mientras el jugador aprieta la tecla identificada como name.
GetKeyDown:  static function GetKeyDown (name : String) : boolean
  Devuelve true durante el frame en que el usuario empieza a presionar la tecla 
  identificada como name. 
GetKeyUp:  static function GetKeyUp (name : String) : boolean 
  Devuelve true durante el frame en que el jugador libera la tecla identificada por 
  name. 
GetJoystickNames:  static function GetJoystickNames () : string[] 
  Devuelve un array de strings describiendo los joysticks conectados.
GetMouseButton:  static function GetMouseButton (button : int) : boolean
  Devuelve true si el botón indicado del ratón es apretado. La variable button es 
  un int que representa 0 para el botón izquierdo, 1 para el derecho y 2 para el 
  central. 
GetMouseButtonDown:  static function GetMouseButtonDown (button : int) : boolean 
  Devuelve true durante el frame en que el usuario aprieta el botón del ratón 
  indicado. 
GetMouseButtonUp:  static function GetMouseButtonUp (button : int) : boolean
  Devuelve true durante el frame en que el usuario libera el botón del ratón 
  indicado.
ResetInputAxes:  static function ResetInputAxes () : void 
  Resetea todos los inputs, con lo que todos los axes y botones retornan a 0.
GetAccelerationEvent:  static function GetAccelerationEvent (index : int)
 : AccelerationEvent
  Devuelve mediciones de aceleración que ocurrieron durante el último frame.


Joint


VARIABLES:
connectedBody:  var connectedBody : Rigidbody 
  Esta variable referencia a otro rigidbody con el que nuestr joint conecta. 
axis:  var axis : Vector3 
  El eje altededor del cual el rigidbody está constreñido, indicado en coordenadas 
  locales. 
anchor:  var anchor : Vector3 
  La posición del ancla alrededor de la cual el movimiento de los joints está 
  constreñido. La posición es definida en espacio local. 
breakForce:  var breakForce : float 
  La fuerza que es necesario aplicarle a este joint para romperlo. La fuerza podría
  venir por colisiones con otros objetos, fuerzas aplicadas con rigidbody.AddForce 
  o por otros joints. 
breakTorque:  var breakTorque : float 
  La torsión que es necesario aplicar a este joint para romperlo. 

FUNCIONES:
OnJointBreak:  function OnJointBreak (breakForce : float) : void 
  Función que es llamada cuando un joint vinculado al mismo game object se rompe.


Light


VARIABLES:
type:  var type : LightType 
  El tipo de luz. 
color:  Var color : Color 
  El color de la luz.
intensity:  var intensity : float 
  La intensidad de la luz.
shadows:  var shadows : LightShadows 
  Indica cómo proyecta sombras la luz.
shadowStrenght:  var shadowStrength : float 
  Establece/indica la fuerza de las sombras.
shadowBias:  var shadowBias : float 
  Vendría a ser la perpendicular de la sombra respecto del objeto que la emite.
shadowSoftness:  var shadowSoftness : float 
  Suavidad de las sombras de las luces direccionales. 
shadowSoftnessFade:  var shadowSoftnessFade : float 
  Velocidad de fadeout de las sombras de las luces direccionales.
range:  var range : float 
  El diámetro del rango o haz de luz, en luces de tipo spot y point. 
spotAngle:  var spotAngle : float 
  El ángulo en grados de las luces de tipo spotlight. 
cookie:  var cookie : Texture 
  Variable de tipo textura que establece la textura de la galleta proyectada por la
  luz. 
flare:  var flare : Flare 
  Selecciona un halo para la luz. Este ha de ser previamente asignado en el 
  inspector.
renderMode:  var renderMode : LightRenderMode 
  Establece cómo renderizar la luz.
cullingMask:  var cullingMask : int 
  Es usado para separar luces de la escena de manera selectiva.


LightmapSettings


VARIABLES DE CLASE:
lightmaps:  static var lightmaps : LightmapData[] 
  Es un array de tipo LightmapData que puede almacenar diferentes lightmaps.
lightmapsMode:  static var lightmapsMode : LightmapsMode 
  Modo de renderizado de lightmaps. 



Material


VARIABLES:
shader:  var shader : Shader 
  Es el shader del material. En modelado 3d, un shader vendría a ser el algoritmo
  que indica cómo una superficie ha de responder ante la luz.
color:  var color : Color 
  El color principal del material. 
mainTexture:  var mainTexture : Texture 
  La textura principal del material. 
mainTextureOffset:  var mainTextureOffset : Vector2 
  Nos permite desplazar la textura principal.
mainTextureScale:  var mainTextureScale : Vector2 
  La escala de la textura principal. 

FUNCIONES:
Material:  static function Material (contents : String) : Material 
  Crea un material temporal a partir de un shader descrito por un string.
SetColor:  function SetColor (propertyName : String, color : Color) : 
void 
  Nos permite indicar el nombre para un determinado color. 
GetColor:  function GetColor (propertyName : String) : Color 
  Obtiene el valor de un color con nombre.
SetTexture:  function SetTexture (propertyName : String, texture : 
Texture) : void 
  Establece el nombre de una textura. 
GetTexture:  function GetTexture (propertyName : String) : Texture 
  Obtiene el nombre de una textura.
SetTextureOffset:  function SetTextureOffset (propertyName : String, 
offset : Vector2) : void
  Establece el lugar de desplazamiento de la textura pasada como primer parámetro.
GetTextureOffset  function GetTextureOffset (propertyName : String) : 
Vector2
  Obtiene la ubicación del desplazamiento de la textura pasada como parámetro.
SetTextureScale:  function SetTextureScale (propertyName : String, scale :
 Vector2) : void 
  Establece la escala de la textura pasada como primer parámetro.
GetTextureScale:  function GetTextureScale (propertyName : String) : 
Vector2 
  Obtiene la escala de la textura pasada como parámetro.
SetFloat:  function SetFloat (propertyName : String, value : float) : 
void 
  Establece un valor tipo float con nombre.
GetFloat:  function GetFloat (propertyName : String) : float 
  Obtiene un valor de tipo float con nombre.
HasProperty:  function HasProperty (propertyName : String) : boolean 
  Comprueba si el shader del material tiene una propiedad con un nombre 
  determinado. 
GetTag:  function GetTag (tag : String, searchFallbacks : boolean, 
defaultValue : String = "") : String 
  Obtiene el valor del tag del shader del material. 
Lerp:  function Lerp (start : Material, end : Material, t : float) : void 
  Interpola propiedades entre dos materiales. Hace que todos los colores y valores 
  del primer material sean convertidos en los valores del segundo material en el 
  tiempo t. 
CopyPropertiesFromMaterial:  function CopyPropertiesFromMaterial (mat : 
Material) : void 
  Copia propiedades de otro material en este material.


Mathf


VARIABLES DE CLASE:
PI:  static var PI : float 
  El famoso 3.141592. (sólo lectura)
Infinity:  static var Infinity : float 
  Representación del infinito positivo (sólo lectura) 
NegativeInfinity:  static var NegativeInfinity : float 
  Una representación del infinito negativo (sólo lectura) 
Deg2Rad:  static var Deg2Rad : float 
  Conversión constante de grados a radianes (sólo lectura) 
Rad2Deg:  static var Rad2Deg : float 
  Conversión constante de radianes a grados (sólo lectura)
Epsilon:  static var Epsilon : float 

FUNCIONES DE CLASE:
Sin:  static function Sin (f : float) : float 
  Devuelve el seno del ángulo f en radianes.
Cos:  static function Cos (f : float) : float 
  Devuelve el coseno del ángulo f en radianes.
Tan:  static function Tan(f : float) : float 
  Devuelve la tangente del ángulo f en radianes.
Asin:  static function Asin (f : float) : float 
  Devuelve el arco seno de f menos el ángulo en radianes cuyo seno es f.
Acos:  static function Acos (f : float) : float
  Devuelve el arco coseno de f menos el ángulo en radianes cuyo coseno es f.
Atan:  static function Atan (f : float) : float
  Devuelve el arco tangente de f menos el ángulo en radianes cuya tangente es f.
Atan2:  static function Atan2 (y : float, x : float) : float 
  Devuelve el ángulo en radianes cuya tangente es y/x. 
Sqrt:  static function Sqrt (f : float) : float 
  Devuelve la raíz cuadrada de f.
Abs: static function Abs (value : float) : float   
  Devuelve el valor absoluto de value.
Min:  static function Min (a : float, b : float) : float 
  Devuelve el valor mínimo de dos o más valores dados.
Max:  static function Max (a : float, b : float) : float 
  Devuelve el valor máximo de dos o más valores.
Pow:  static function Pow (f : float, p : float) : float  
  Devuelve f elevado a la potencia p. 
Exp:  static function Exp (power : float) : float 
  Devuelve la potencia natural de un determinado número.
Log:  static function Log (f : float, p : float) : float 
  Devuelve el logaritmo de un determinado número en una base especificada.
Log10:  static function Log10 (f : float) : float 
  Devuelve el logaritmo en base diez de un determinado número.
Ceil:  static function Ceil (f : float) : float
  Devuelve el integer más pequeño igual o mayor que f.
Floor:  static function Floor (f : float) : float
  Devuelve el mayor integer igual o más pequeño que f. 
Round:  static function Round (f : float) : float 
  Devuelve f redondeado al integer más cercano. 
CeilToInt:  static function CeilToInt (f : float) : int 
  Devuelve el integer más pequeño igual o mayor que f.
FloorToInt:  static function FloorToInt (f : float) : int 
  Devuelve el mayor integer menor o igual que f.
RoundToInt:  static function RoundToInt (f : float) : int 
  Devuelve f rendondeada al integer más cercano. 
Sign:  static function Sign (f : float) : float
  Devuelve el signo de f. Devuelve 1 si es positivo o cero, y -1 si f es negativo.
Clamp:  static function Clamp (value : float, min : float, max : float) : float 
  Restringe un valor entre un mínimo y un máximo, sean floats o ints.
Clamp01:  static function Clamp01 (value : float) : float 
  Fija un valor entre 0 y 1 y lo devuelve.
Lerp:  static function Lerp (from : float, to : float, t : float) : float
  Interpola a hacia b pasando por t. t queda fijada entre 0 y 1. Cuando t = 0 
  devuelve from. Cuando t = 1 devuelve to. Cuando t = 0.5 devuelve la media de a y 
  b.
LerpAngle:  static function LerpAngle (a : float, b : float, t : float) : float 
  Lo mismo que lerp, pero asegurándonos de interpolar valores correctamente cuando 
  dé un giro de 360 grados. 
MoveTowards:  static function MoveTowards (current : float, target : float, maxDelta
 : float) : float
  Mueve el valor que indicamos en el parámetro current hacia el que indicamos en 
  target. 
MoveTowardsAngle:  static function MoveTowardsAngle (current : float,
 target : float, maxDelta : float) : float
  Lo mismo que MoveTowards pero estando seguros de que los valores se interpolarán 
  correctamente cuando gire 360 grados. 
SmoothStep:  static function SmoothStep (from : float, to : float, t : float) 
: float 
  Interpola entre mínimo y máximo y facilita entrada y salida de los límites. 
Approximately:  static function Approximately (a : float, b : float) : boolean
  Compara si dos valores en punto flotante son similares. 
SmoothDamp:  static function SmoothDamp (current : float, target : float, ref 
currentVelocity : float, smoothTime : float, maxSpeed : float = Mathf.Infinity, 
deltaTime : float = Time.deltaTime) : float
  Gradualmente cambia un valor hacia un objetivo en un determinado tiempo.
SmoothDampAngle:  static function SmoothDampAngle (current : float, target : 
float, ref currentVelocity : float, smoothTime : float, maxSpeed : float = 
Mathf.Infinity, deltaTime : float = Time.deltaTime) : float
  Cambia gradualmente un ángulo dado en grados hacia el ángulo que constituye el 
  objetivo en un tiempo determinado.
Repeat:  static function Repeat (t : float, length : float) : float 
  Introduce en un bucle el valor t, de tal manera que nunca sea más grande que
  length y nunca más pequeño que 0.
PingPong:  static function PingPong (t : float, length : float) : float
  Hace rebotar el valor t, de tal manera que nunca sea mayor que length y nunca 
  mayor que 0. El valor retornado se moverá atrás y adelante entre 0 y length.
InverseLerp:  static function InverseLerp (from : float, to : float, value : float) 
: float 
  Calcula el parámetro Lerp entre dos valores. 
ClosestPowerOfTwo:  static function ClosestPowerOfTwo (value : int) : int
  Retorna la potencia de dos más cercana. 
IsPowerOfTwo:  static function IsPowerOfTwo (value : int) : boolean 
  Devuelve true si el valor es potencia de dos
NextPowerOfTwo:  static function NextPowerOfTwo (value : int) : int 
  Devuelve el valor de la siguiente potencia de dos. 
DeltaAngle:  static function DeltaAngle (current : float, target : float) : float 
  Calcula la diferencia más corta entre dos ángulos dados.


Mesh


FUNCIONES:
vertices:  var vertices : Vector3[] 
  Devuelve una copia de la posición del vértice o asigna un nuevo array de 
  posiciones de vértices.
normals:  var normals : Vector3[] 
  Los normales de la malla. Si la malla no contiene normales un array vacío es 
  retornado. 
tangents:  var tangents : Vector4[] 
  Las tangentes de la malla. 
uv:  var uv : Vector2[] 
  Las coordenadas de la textura base de la malla. 
uv2:  var uv2 : Vector2[] 
  El segundo conjunto de coordenadadas de textura de la malla, si lo hubiere.
bounds:  var bounds : Bounds
  El volumen de bordes de la malla. 
colors:  var colors : Color[] 
  Devuelve los colores del vértice de la malla. Si no hay colores devuelve un array
  vacío. 
triangles:  var triangles : int[]
  Un array conteniendo todos los triángulos de la malla. 
vertexCount:  var vertexCount : int 
  Variable de sólo lectura que devuelve el número de vértices en la malla.
subMeshCount:  var subMeshCount : int 
  El número de submallas. Cada material tiene una lista de triángulos separada. 
boneWeights:  var boneWeights : BoneWeight[] 
  La pintura de pesos de cada vértice. 

FUNCIONES:
Mesh:  static function Mesh () : Mesh 
  Crea una malla vacía.
Clear:  function Clear () : void
  Limpia todos los datos de los vértices y todos los índices de los triángulos. 
RecalculateBounds:  function RecalculateBounds () : void 
  Recalcula el volumen de bordes de la malla desde los vértices.
RecalculateNormals:  function RecalculateNormals () : void
  Recalcula los normales de la malla desde los triángulos y vértices. 
Optimize:  function Optimize () : void
  Optimiza la malla para mostrarla.
GetTriangles:  function GetTriangles (submesh : int) : int[]
  Devuelve la lista de triángulos de la submalla.
SetTriangles:  function SetTriangles (triangles : int[], submesh : int) :
 void 
  Establece la lista de triángulos para la submalla. 
CombineMeshes:  
function CombineMeshes (combine : CombineInstance[], mergeSubMeshes : boolean = 
true, useMatrices : boolean = true) : void
  Combina varias mallas dentro de la malla. 


MeshCollider


VARIABLES:
sharedMesh:  var sharedMesh : Mesh 
  Hace referencia al objeto malla que nuestro gameobject está usando como detector
  de colisiones, si lo hay. 
convex:  var convex : boolean 
  Con esta variable establecida en true nuestro collider de malla automáticamente 
  pasa a ser convexo y todas las entradas y agujeros que pudiera tener nuestra 
  malla desaparecen, permitiendo una detección de colisiones mucho más completa.
smoothSphereCollisions:  var smoothSphereCollisions : boolean
  Usa normales interpolados para colisiones de esferas en lugar de normales planos
  poligonales. Esto suaviza los baches para rodamientos de esferas sobre 
  superficies suaves.


MeshFilter


VARIABLES:
mesh:  var mesh : Mesh 
  Devuelve la instancia de malla asignada al mesh filter. Si no se ha asignado 
  ninguna malla al mesh filter se creará y asignará una nueva.
sharedMesh:  var sharedMesh : Mesh 
  Devuelve la malla compartida del mesh filter. 



MonoBehaviour


FUNCIONES:
Invoke:  
function Invoke (methodName : String, time : float) : void 
  Llama a la función que le pasemos como primer parámetro en el tiempo contado en 
  segundos que le indiquemos como segundo parámetro.
InvokeRepeating:  function InvokeRepeating (methodName : String, time : 
float, repeatRate : float) : void 
  Invoca la función que le pasamos como string para dentro del número de segundos 
  que le pasamos como segundo parámetro, y una vez se ejecuta, lo vuelve a hacer 
  cada repeatRate segundos (el tercer parámetro).
CancelInvoke:  function CancelInvoke () : void 
  CancelInvoke cancela las funciones que hayan sido invocadas por las dos funciones 
  anteriores para un determinado script. 
IsInvoking:  function IsInvoking (methodName : String) : boolean 
  Devuelve true si hay algún invoke pendiente de la función que se introduce como
  parámetro.
StartCoroutine:  function StartCoroutine (routine : IEnumerator) : 
Coroutine 
  Inicia una corrutina cuya ejecución puede ser pausada en cualquier momento usando 
  una instrucción yield.
StopCoroutine:  function StopCoroutine (methodName : String) : void 
  Detiene las corrutinas con el nombre que le suministramos como parámetro 
  iniciadas en este script.
StopAllCoroutines:  function StopAllCoroutines () : void 
  Detiene todas las corrutinas que estén corriendo en ese script.
Update:  function Update () : void 
  Esta función es llamada cada frame, si el Monobehaviour (script que la invoca) 
  está activo.
LateUpdate:  function LateUpdate () : void 
  LateUpdate es llamado una vez todas las funciones Update han sido llamadas.
FixedUpdate:  function FixedUpdate () : void 
  Esta función se ejecuta cada cierto número preestablecido y fijo de frames.
Awake:  function Awake () : void 
  Awake es llamada cuando se inicia el script, osea, cuando se carga la escena, y 
  justo después de que se carguen los objects (gameobjects y components) a que el 
  script hace referencia. 
Start:  function Start () : void 
  Es llamada después de Awake y antes de Update. Al igual que awake, sólo es 
  llamada una vez a lo largo de toda la vida del script. 
Reset:  function Reset () : void 
  Resetea a los valores por defecto, restaurando los valores originales. Esta 
  función es llamada cuando se pulsa reset en el inspector o cuando se añade un 
  componente por primera vez.
OnMouseEnter:  function OnMouseEnter () : void 
  Esta función es llamada cuando el cursor entra en un collider o un GUIElement.
OnMouseOver:  function OnMouseOver () : void 
  Esta función es llamada cada frame en la que el mouse permanezca sobre el 
  Collider o GUIElement, a diferencia de onMouseEnter, que sólo se dispara cuando 
  entra el mouse.
OnMouseExit:  function OnMouseExit () : void 
  Esta función es llamada cuando el ratón ya no esta sobre un GUIElement o un 
  Collider. 
OnMouseDown: function OnMouseDown () : void 
  Es llamada cuando el usuario pulsa el botón del mouse sobre un GUIElement o 
  Collider.
OnMouseUp:  function OnMouseUp () : void 
  Esta función es llamada cuando el usuario libera/suelta el botón del ratón. Es 
  llamada incluso si el mouse no está al soltar el botón sobre el mismo GUIElement
  o Collider en que estaba cuando el botón fue presionado. 
OnMouseUpAsButton:  function OnMouseUpAsButton () : void 
  Es llamada sólo cuando el mouse es liberado estando sobre el mismo GUIElement o
  Collider en el que fue presionado.  
OnMouseDrag:  function OnMouseDrag () : void 
  Es llamada esta función cuando el usuario presiona el botón del mouse sobre un
  GUIElement o un Collider y todavía lo mantiene presionado. Es llamada cada frame
  mientras el botón siga presionado. 
OnControllerColliderHit:  function OnControllerColliderHit (hit : 
ControllerColliderHit) : void 
  Es llamada cuando nuestro character controller golpea un collider mientras 
  realiza un movimiento.
OnParticleCollision:  unction OnParticleCollision (other : GameObject) : void 
  Esta función es llamada cuando una partícula choca con un collider. 
OnBecameVisible:  function OnBecameVisible () : void 
  Se llama a esta función cuando el renderer se convierte en visible por alguna 
  cámara.
OnBecameInvisible:  function OnBecameInvisible () : void 
  Es llamada cuando el renderer ya no es visible por ninguna cámara. 
OnLevelWasLoaded:  function OnLevelWasLoaded (level : int) : void 
  Esta función es llamada después de que un nuevo level ha sido cargado.
OnEnable:  function OnEnable () : void 
  Es llamada cuando el objeto pasa a estar habilitado y activo.
OnDisable:  function OnDisable () : void 
  Es llamada cuando el objeto se convierte en deshabilitado o inactivo.
OnDestroy:  function OnDestroy () : void
  Es llamada cuando el MonoBehaviour (script) es destruido. Sólo puede ser llamada
  para gameobjects que previamente hayan estado activos.
OnPreCull:  function OnPreCull () : void
  Es llamada antes de que la cámara deseche la escena.
OnPreRender:  function OnPreRender () : void 
  Es llamada antes de que la cámara empiece a renderizar la escena. Sólo se llama 
  si el script está vinculado a la cámara y activo.
OnPostRender:  function OnPostRender () : void 
  Es llamada después de que la cámara acaba de renderizar la escena, siempre que el
  script esté vinculado con la cámara y activo.
OnRenderObject:  function OnRenderObject () : void 
  Es llamada después de que la cámara renderiza la escena. 
OnWillRenderObject:  function OnWillRenderObject () : void 
  Esta función es llamada una vez por cada cámara si el objeto es visible. 
OnGUI:  function OnGUI () : void 
  Es llamada para renderizar y manejar eventos GUI. 
OnRenderImage:  function OnRenderImage (source : RenderTexture, 
destination : RenderTexture) : void
  Es llamada cuando se tiene toda la información de renderizado de una imagen, 
  permitiendo modificar la imagen final procesándola con filtros. 
OnDrawGizmosSelected:  function OnDrawGizmosSelected () : void 
  Implementa esta function si quieres dibujar gizmos sólo si el objeto está 
  seleccionado. 
OnDrawGizmos:  function OnDrawGizmos () : void 
  Implementa esta función si quieres dibujar gizmos que aparezcan siempre  
  dibujados. 
OnApplicationPause:  function OnApplicationPause (pause : boolean) : void 
  Es enviada a todos los gameobjects cuando el jugador presiona la pausa. 
OnApplicationFocus:  function OnApplicationFocus (focus : boolean) : void 
  Función enviada a todos los gameobjects cuando el jugador obtiene o pierde el 
  foco.
OnApplicationQuit:  function OnApplicationQuit () : void 
  Función que se envía a todos los gameobjects antes de que la aplicación se 
  cierre. En el editor es llamada cuando el usuario detiene el play, en la web es 
  llamada cuando la página se cierra. 
OnPlayerConnected:  unction OnPlayerConnected (player : NetworkPlayer) : 
void 
  Es llamada en el servidor cada vez que un nuevo jugador se conecta con éxito.
OnServerInitialized:  function OnServerInitialized () : void 
  Llamada en el server cada vez que Network.InitializeServer es invocada y 
  completada.
OnConnectedToServer:  function OnConnectedToServer () : void
  Es llamada esta función en el cliente cuando consigues conectarte con éxito al 
  servidor.
OnPlayerDisconnected:  function OnPlayerDisconnected (player : 
NetworkPlayer) : void 
  Llamada en el server cada vez que un jugador se desconecta del server.
OnDisconnectedFromServer:  function OnDisconnectedFromServer (mode : 
NetworkDisconnection) : void 
  Llamada en el cliente cuando la conexión se pierde o desconectas del servidor. 
OnFailedToConnect:  function OnFailedToConnect (error : 
NetworkConnectionError) : void
  Llamada en el cliente cuando un intento de conexión falla por alguna razón. La 
  razón por la que falla es pasada como una enumeración de tipo 
  Network.ConnectionError.
OnFailedToConnectToMasterServer:  unction OnFailedToConnectToMasterServer
 (error : NetworkConnectionError) : void 
  Llamada en clientes o servidores cuando hay un problema conectando con el 
  MasterServer. La razón del error es pasada como una enumeración de tipo 
  Network.ConnectionError.
OnMasterServerEvent:  function OnMasterServerEvent (msEvent : 
MasterServerEvent) : void 
  Llamada en clientes o servidores cuando informan de eventos desde el 
  MasterServer, como por ejemplo que haya tenido éxito el registro en el host.
OnNetworkInstantiate:  Function OnNetworkInstantiate (info : 
NetworkMessageInfo) : void 
  Llamada en objetos que han sido instanciados en red con Network.Instantiate. 
OnSerializeNetworkView:  function OnSerializeNetworkView (stream : 
BitStream, info : NetworkMessageInfo) : void 
  Usada para personalizar la sincronización de variables en un script controlado 
  por una network view.


Object


VARIABLES:
name:  var name : String 
  El nombre del objeto. Lo comparten el objeto y sus componentes.
hideFlags:  var hideFlags : HideFlags 
  Permite que un objeto desaparezca del inspector o de la jerarquía.

FUNCIONES:
GetInstanceID:  function GetInstanceID () : int 
  Unity asigna a cada objeto un identificador único. Esta función devuelve ese 
  identificador.
ToString:  function ToString () : String 
  Devuelve un string con el nombre del gameobject que hace la consulta.

FUNCIONES DE CLASE:
Operator bool:  static implicit function bool (exists : Object) : boolean 
  ¿Existe este objeto?
Instantiate:  static function Instantiate (original : Object, position : Vector3, 
rotation : Quaternion) : Object 
  Esta función lo que hace es clonar el objeto que le pasamos como primer 
  parámetro, y devolver ese clon del objeto original, ubicándolo en posición y 
  rotación determinadas.

Destroy:  static function Destroy (obj : Object, t : float = 0.0F) : void 
  Esta función borra del juego un gameobject, un componente o un asset. 
DestroyImmediate:  static function DestroyImmediate (obj : Object, 
allowDestroyingAssets : boolean = false) : void   
  Esta función destruye inmediatamente un objeto.
FindObjectsOfType:  static function FindObjectsOfType (type : Type) : Object[] 
  Función que devuelve un array con todos los objetos activos del tipo indicado.  
FindObjectOfType:  static function FindObjectOfType (type : Type) : Object 
  Esta función devuelve el primer objeto activo que Unity encuentre que sea del 
  tipo que le pasamos como parámetro. 
Operator ==:  static operator == (x : Object, y : Object) : boolean 
  Compara si dos objetos son iguales.
Operator !=:  static operator != (x : Object, y : Object) : boolean 
  Compara si dos objetos son diferentes. 
DontDestroyOnLoad:  tatic function DontDestroyOnLoad (target : Object) : void
  Con esta función conseguimos que el objeto que colocamos como parámetro no se 
  destruya cuando se cargue una nueva escena. 


ParticleEmitter


VARIABLES:
emit:  var emit : boolean 
  Booleano que indica si deben las partículas ser automáticamente emitidas cada 
  frame o no.
minSize:  var minSize : float 
  El tamaño mínimo que cada partícula puede tener cuando se genera. 
maxSize:  var maxSize : float
  El tamaño máximo que cada particular puede tener al tiempo de ser generada.
minEnergy:  var minEnergy : float 
  El mínimo tiempo de vida de cada particular, medido en segundos. 
maxEnergy:  var maxEnergy : float 
  El máximo tiempo de vida de cada partícula, medido en segundos. 
minEmission:  var minEmission : float 
  El mínimo número de partículas que serán generadas cada segundo.
maxEmission:  El máximo número de partículas que serán generadas cada 
  segundo. 
emitterVelocityScale:  var emitterVelocityScale : float 
  La cantidad de la velocidad de emisión que las partículas heredan. 
worldVelocity:  var worldVelocity : Vector3 
  La velocidad inicial de las partículas en el mundo global, a lo largo de x,y,z. 
localVelocity:  var localVelocity : Vector3 
  Es como la anterior, pero el desplazamiento se efectúa en las coordenadas locales 
  del propio sistema de partículas.
rndVelocity:  var rndVelocity : Vector3 
  Una velocidad aleatoria con relación a los ejes x,y,z que es añadida a la 
  velocidad.
useWorldSpace:  var useWorldSpace : boolean 
  Si está habilitado, las partículas no se mueven cuando el emitter se mueve. Si 
  está en false, cuando muevas el emitter, las partículas lo siguen.
rndRotation:  var rndRotation : boolean 
  Si está habilitado, las partículas serán generadas con rotaciones aleatorias. 
angularVelocity:  var angularVelocity : float 
  La velocidad angular de las nuevas partículas en grados por segundo.
rndAngularVelocity:  var rndAngularVelocity : float 
  Un modificador aleatorio de velocidad angular para nuevas partículas.
particles:  var particles : Particle[] 
  Devuelve una copia de todas las partículas y asigna un array de todas las 
  partículas.
particleCount:  var particleCount : int 
  El corriente número de partículas. Variable de sólo lectura.
enabled:  var enabled : boolean 
  Establece el ParticleEmitter en on o off. Un ParticleEmitter que no está 
  habilitado no emitirá ninguna partícula, y las partículas emitidas no se 
  animarán. Así, este valor nos permite pausar un sistema de partículas. 

FUNCIONES:
ClearParticles:  function ClearParticles () : void 
  Borra todas las partículas del sistema de partículas. 
Emit:  function Emit () : void 
  Emite un número de partículas.
Simulate:  function Simulate (deltaTime : float) : void 
  Avanzado sistema de simulación de partículas por un tiempo dado. Es útil para 
  precalentar un sistema de partículas.



PhysicMaterial


VARIABLES:
dynamicFriction:  var dynamicFriction : float 
  La fricción usada cuando ya hay movimiento. Este valor ha de estar entre 0 y 1, 
  siendo 0 la fricción del hielo y 1 la del caucho. 
staticFriction:  var staticFriction : float 
  La fricción usada cuando un objeto está reposando en una superficie. 
bounciness:  var bounciness : float 
  Qué capacidad de rebote tiene la superficie. 0 es no rebote. Un valor de 1 
  implica rebote sin pérdida de energía. 
frictionDirection2:  var frictionDirection2 : Vector3 
  Se refiere a la dirección de anisotropía. La fricción anisotrópica está 
  habilitada salvo que su vector esté a cero. 
dynamicFriction:  var dynamicFriction2 : float
  Si la fricción anisotrópica está habilitada (frictionDirection2 no vale cero), 
  dynamicFriction2 será aplicada a lo largo del eje/s de frictionDirection2 que no 
  valga cero.
staticFriction2:  var staticFriction2 : float 
  Si la fricción anisotrópica está habilitada, staticFriction2 será aplicada a lo 
  largo de frictionDirection2.
frictionCombine:  var frictionCombine : PhysicMaterialCombine 
  Determina cómo se combina la fricción.
bounceCombine:  var bounceCombine : PhysicMaterialCombine 
  Determina cómo la capacidad de rebote es combinada. 

FUNCIONES:
PhysicMaterial:  static function PhysicMaterial () : PhysicMaterial 
  Función constructora que crea un nuevo material. 


Physics


VARIABLES DE CLASE:
gravity:  static var gravity : Vector3 
  La gravedad aplicada a todos los rigidbodies en la escena. 

FUNCIONES DE CLASE:
Raycast:  static function Raycast (origin : Vector3, direction : Vector3, distance 
: float = Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : boolean 
  Lanza un rayo contra todos los colliders en la escena. Devuelve true cuando el 
  rayo intersecta algún collider.
RaycastAll:  static function RaycastAll (ray : Ray, distance : float = 
Mathf.Infinity, layerMask : int = kDefaultRaycastLayers) : RaycastHit[] 
  Lanza un rayo a través de la escena y devuelve todos los choques. 
LineCast:  static function Linecast (start : Vector3, end : Vector3, layerMask
 : int = kDefaultRaycastLayers) : boolean
  Devuelve true si hay algún collider intersectando la línea entre start y end. 
OverlapSphere:  static function OverlapSphere (position : Vector3, radius 
: float, layerMask : int = kAllLayers) : Collider[] 
  Devuelve un array con todos los colliders que toquen o estén dentro de la esfera 
  cuya posición y radio pasamos como parámetros.
CapsuleCast:  static function CapsuleCast (point1 : Vector3, point2 : Vector3, 
radius : float, direction : Vector3, distance : float = Mathf.Infinity, layerMask :
 int = kDefaultRaycastLayers) : boolean 
  Lanza una cápsula contra todos los colliders de la escena y devuelve información 
  de contra qué ha chocado. Devuelve true cuando el sweep (barrido) de la cápsula 
  choca con algún collider. 
SphereCast:  static function SphereCast (origin : Vector3, radius : float, 
direction : Vector3, out hitInfo : RaycastHit, distance : float = Mathf.Infinity, 
layerMask : int = kDefaultRaycastLayers) : boolean 
  Proyecta una esfera contra todos los colliders de la escena y proporciona 
  información sobre los que colisionan. Devuelve true si topa con alguno en su 
  barrido.
CapsuleCastAll:  static function CapsuleCastAll (point1 : Vector3, point2 : Vector3, 
radius : float, direction : Vector3, distance : float = Mathf.Infinity, layermask :
 int = kDefaultRaycastLayers) : RaycastHit[] 
  Es como Physics.CapsuleCast, pero devolviendo todos los colliders que la cápsula
  intercepta en su barrido e información sobre los mismos. Devuelve un array con 
  todos esos colliders. 
SphereCastAll:  static function SphereCastAll (origin : Vector3, radius : float, 
direction : Vector3, distance : float = Mathf.Infinity, layerMask : int = 
kDefaultRaycastLayers) : RaycastHit[] 
  Como physics.SphereCast, pero devolviendo todos los colliders que colisionen. 
CheckSphere:  static function CheckSphere (position : Vector3, radius : float, 
layerMask : int = kDefaultRaycastLayers) : boolean 
  Devuelve true si hay algún collider tocando la esfera definida por position y 
  radius en coordenadas globales. 
CheckCapsule:  static function CheckCapsule (start : Vector3, end : 
Vector3, radius : float, layermask : int = kDefaultRaycastLayers) : boolean 
  Devuelve true si hay algún collider tocando la cápsula definida por el eje que va 
  de start a end y que tiene el radio radius, en coordenadas globales.
IgnoreCollision:  static function IgnoreCollision (collider1 : Collider, collider2 
: Collider, ignore : boolean = true) : void 
  Hace que el sistema de detección de colisiones ignore todas las colisiones entre 
  collider1 y collider2.
IgnoreLayerCollision:  
static function IgnoreLayerCollision (layer1 : int, layer2 : int, ignore : boolean 
= true) : void
  Hace que el sistema de detección de colisiones ignore todas las colisiones entre 
  cualquier collider en layer1 y otros en layer2.
GetIgnoreLayerCollision:  static function GetIgnoreLayerCollision (layer1 : int, 
layer2 : int) : boolean
  Booleano que indica si las colisiones entre layer1 y layer2 están siendo 
  ignoradas.


Quaternion


VARIABLES
eulerAngles:  var eulerAngles : Vector3 
  Devuelve la representacion en ángulos euler de la rotacion. 

FUNCIONES:
ToAngleAxis:  function ToAngleAxis (out angle : float, out axis : Vector3): 
void 
  Convierte una rotación en una representación de angle-axis (ángulo de eje) 
SetFromRotation:  
function SetFromToRotation (fromDirection : Vector3, toDirection : Vector3) : void
  Crea una rotación que rota desde fromDirection hasta toDirection. 
ToString:  function ToString () : String 
  Devuelve un string formateado del Quaternion.

VARIABLES DE CLASE:
identity:  static var identity : Quaternion 
  Sería el equivalente a no rotation. El transform quedará perfectamente alineado 
  con el mundo o con los ejes del padre. 

FUNCIONES DE CLASE:
AngleAxis:  static function AngleAxis (angle : float, axis : Vector3) : Quaternion 
  Crea una rotación que rota los ángulos que le pasemos como primer parámetro con 
  respecto al eje que le pasamos como segundo.
FromToRotation:  static function FromToRotation (fromDirection : Vector3, toDirection :
 Vector3) : Quaternion 
  Crea una rotación que rota desde el primer parámetro al segundo.
Slerp:  static function Slerp (from : Quaternion, to : Quaternion, t : float)
 : Quaternion
  Interpola esfériamente del primer al segundo parámetro durante el tercero. 
RotateTowards:  static function RotateTowards (from : Quaternion, to : 
Quaternion, maxDegreesDelta : float) : Quaternion
  Efectúa una rotación entre el primer parámetro y el segundo. Esto es 
  esencialmente lo mismo que Quaternion.Slerp, pero aquí la función se aregura de 
  que la velocidad angular nunca exceda de la marcada en maxDegreesDelta.
Angle: static function Angle (a : Quaternion, b : Quaternion) : float 
  Devuelve el ángulo en grados entre dos rotaciones dadas.
Euler:  static function Euler (x : float, y : float, z : float) : Quaternion
  Devuelve en quaterniones una rotación pasada como parámetro en grados euler.


Random


VARIABLES DE CLASE:
seed:  static var seed : int 
  Coloca la semilla para el generador de números aleatorios. 
value:  static var value : float 
  Devuelve un número aleatorio entre 0.0 (inclusive) y 1.0 (inclusive).
insideUnitSphere:  static var insideUnitSphere : Vector3 
  Devuelve un punto aleatorio dentro de una esfera con radio 1.
insideUnitCircle:  static var insideUnitCircle : Vector2 
  Devuelve un punto aleatorio dentro de un círculo con radio 1.
onUnitSphere:  static var onUnitSphere : Vector3 
  Devuelve un punto aleatorio sobre la superficie de una esfera con radio 1.
rotation:  static var rotation : Quaternion 
  Devuelve una rotación aleatoria

FUNCIONES DE CLASE:
Range:  static function Range (min : float, max : float) : float 
  Devuelve un float (o un int, si se prefiere) aleatorio entre un min (inclusive) y 
  max (inclusive). 


Ray


VARIABLES:
origin:  var origin : Vector3 
  El punto de origen del rayo.
direction:  var direction : Vector3 
  La dirección del rayo. 

FUNCIONES:
Ray:  static function Ray (origin : Vector3, direction : Vector3) : Ray
  Crea un rayo que empieza en origin a lo largo de direction.
GetPoint:  function GetPoint (distance : float) : Vector3
  Devuelve un punto situado tantas unidades como le pasemos en el parámetro a lo 
  largo del rayo.
ToString:  function ToString () : String 
  Devuelve un string formateado para este rayo.


RaycastHit


VARIABLES:
point:  var point : Vector3 
  El punto de impacto en coordenadas globales donde el rayo golpea el collider
normal:  var normal : Vector3 
  El normal de la superficie que golpea el rayo.
barycentricCoordinate:  var barycentricCoordinate : Vector3 
  La coordenada baricéntrica del triángulo que golpeamos.
distance:  var distance : float 
  La distancia desde el origen del rayo hasta el punto de impacto. 
triangleIndex:  var triangleIndex : int 
  El índice del triángulo que ha sido golpeado.
textureCoord:  var textureCoord : Vector2 
  La coordenada de la textura UV en el punto de impacto. 
textureCoord2:  var textureCoord2 : Vector2 
  Las coordenadas de la textura uv secundaria. 
lightmapCoord:  var lightmapCoord : Vector2 
  La coordinada del lightmap de uv en el punto de impacto. 
collider:  var collider : Collider 
  El collider que fue golpeado.
rigidbody:  var rigidbody : Rigidbody
  El rigidbody del collider que ha sido golpeado.
transform:  var transform : Transform 
  El Transform del rigidbody o collider que ha sido golpeado.


Rect:


VARIABLES:
x:  var x : float 
  Coordenada izquierda del rectángulo (a lo largo del eje X).
y:  var y : float
  Coordenada superior del rectángulo.
width:  var width : float
  Anchura del rectángulo.
height:  var height : float
  Altura del rectángulo.
xMin:  var xMin : float
  Coordenada izquierda del rectángulo. Cambiando este valor conservamos el lado 
  derecho del rectángulo (así width cambia también)
yMin:  var yMin : float
  Coordenada superior del rectángulo. Cambiando este valor conservamos el lado 
  inferior del rectángulo (así height cambiará también)
xMax:  var xMax : float
  Coordenada derecha del rectánculo. Cambiando este valor seguimos conservando el 
  lado izquierdo del rectángulo, por lo que la anchura cambiará también.
yMax:  var yMax : float
  Coordenada inferior del rectángulo. Cambiando este valor seguimos conservando el
  lado superior del rectángulo, así que la altura cambiará también.

FUNCIONES:
Rect:  static function Rect (left : float, top : float, width : float, height
 : float) : Rect
  Crea un nuevo rectángulo. 
Contains:  function Contains (point : Vector2) : boolean 
  Devuelve true si los componentes x e y del parámetro point conforman un punto 
  dentro del rectángulo.

FUNCIONES DE CLASE:
MinMaxRect:  static function MinMaxRect (left : float, top : float, right 
: float, bottom : float) : Rect 
  Crea un rectángulo entre min/max valores de coordenadas.


Renderer


VARIABLES:
enabled:  var enabled : boolean 
  Hace el objeto visible (true) o invisible (false).
castShadows:  var castShadows : boolean 
  ¿Proyecta sombras este objeto?
receiveShadows:  var receiveShadows : boolean 
  ¿Recibe sombras este objeto?
material:  var material : Material 
  El material de nuestro objeto. Modificar esta variable sólo cambiará el material
  para este objeto. Si el material que asignamos a nuestro objeto está siendo usado
  para otros renders, se clonará el material compartido y se asignará una copia de 
  dicho material para nuestro objeto.
sharedMaterial:  var sharedMaterial : Material
  Hace referencia al material que nuestro objeto comparte con otros. 
sharedMaterials:  var sharedMaterials : Material[] 
  Devuelve un array con todos los materials compartidos de este objeto, a 
  diferencia de sharedMaterial y material, que sólo devuelven el primer material 
  usado si el objeto tiene más de uno. 
materials:  var materials : Material[] 
  Devuelve un array con todos los materiales usados por el renderer. 
bounds:  var bounds : Bounds 
  Es una variable de sólo lectura que indica los límites del volumen del renderer. 
lightmapIndex:  var lightmapIndex : int 
  El índice del lightmap aplicado a este renderer. El índice se refiere al array de 
  lightmaps que está en la clase LightmapSettings. 
isVisible  var isVisible : boolean 
  Variable de sólo lectura que indica si el renderer es visible en alguna cámara. 

FUNCIONES:
OnBecameVisible:  function OnBecameVisible () : void 
  Esta función es llamada cuando el objeto se vuelve visible para alguna cámara.
OnBecameInvisible:   unction OnBecameInvisible () : void 
  Es llamada cuando el objeto ya no es visible por ninguna cámara.


RenderSettings


VARIABLES DE CLASE:
fog:  static var fog : boolean 
  ¿Está habilitada la niebla? 
fogMode:  static var fogMode : FogMode 
  Modo de niebla a usar. 
fogColor:  static var fogColor : Color 
  El color de la niebla.
fogDensity:  static var fogDensity : float 
  La densidad de la niebla exponencial. 
fogStartDistance:  static var fogStartDistance : float 
  La distancia inicial de la niebla lineal. 
fogEndDistance:  static var fogEndDistance : float 
  La distancia final de la niebla lineal (sólo para modo Linear).
ambientLight:  static var ambientLight : Color 
  Color de la luz de ambiente de la escena.
haloStrength:  static var haloStrength : float 
  Tamaño del halo de luz. Para cualquier luz, el tamaño del halo es este valor
  multiplicado por Light.range. 
flareStrength:  static var flareStrength : float 
  La intensidad de los destellos de la luz en la escena. 
skybox:  static var skybox : Material 
  El skybox global en uso.


RenderTextures


VARIABLES:
width:  var width : int 
  La anchura de la textura renderizada en píxeles. 
height:  var height : int 
  La altura de la textura renderizada en píxeles. 
depth:  var depth : int 
  La precisión en bits de la profundidad del búfer de la render texture (son 
  soportados los valores 0, 16 y 24)
format:  var format : RenderTextureFormat
  El formato de la render texture.
useMipMap:  var useMipMap : boolean
  Por defecto, las render textures no tienen mipmaps. Si establecemos esta variable
  en true, se generarán niveles de mipmap asociados.
isCubemap:  var isCubemap : boolean 
  Si está habilitada, esta render texture será usada como Cubemap.

FUNCIONES:
RenderTextures:  static function RenderTexture (width : int, height : 
int, depth : int, format : RenderTextureFormat) : RenderTexture
  Crea un nuevo objeto RenderTexture, que es creado con anchura y altura, con un
  buffer de profundidad y en un determinado formato. 
Create:  function Create () : boolean 
  Esta función la que crea en realidad la RenderTexture.
Release:  function Release () : void 
  Esta función libera los recursos de hardware usados por la render texture. La 
  texture en sí no es destruida, y será automáticamente creada otra vez cuando se 
  use.
IsCreated:  function IsCreated () : boolean 
  Indica si la render texture se ha creado realmente o no.
DiscardContents:  function DiscardContents () : void 
  Descarta el contenido de la render texture.
SetGlobalShaderProperty:  function SetGlobalShaderProperty (propertyName 
: String) : void 
  Asigna esta render texture como la propiedad shader global llamada en el 
  parámetro propertyName.

VARIABLES DE CLASE:
active:  static var active : RenderTexture
  Se refiere a la render texture activa. 

FUNCIONES DE CLASE:
GetTemporary:  static function GetTemporary (width : int, height : int,
 depthBuffer : int = 0, format : RenderTextureFormat = RenderTextureFormat.Default)
 : RenderTexture 
  Asigna una render texture temporal.
ReleaseTemporary:  static function ReleaseTemporary (temp : 
RenderTexture) : void
  Libera una textura temporal asignada con GetTemporary.


Rigidbody


VARIABLES:
velocity:  Var velocity : Vector3 
  Representa a través de un vector la velocidad del rigidbody. 
angularVelocity:  Var angularVelocity : Vector3 
  Vector que representa la velocidad angular del rigidbody. 
drag:  Var drag : float 
  Indica la resistencia al movimiento de un objeto y por lo tanto se usa para 
  enlentecer dicho objeto. 
angularDrag:  var angularDrag : float 
  Indica la resistencia angular del objeto. Puede ser usado para enlentecer la 
  rotación de un objeto.
useGravity:  Var useGravity : boolean 
  Booleano que controla si la gravedad afecta a este rigidbody. 
isKinematic:  Var isKinematic : boolean 
  Controla si las físicas afectan al rigidbody. 
freezeRotation:  Var freezeRotation : Boolean 
  Controla si las físicas cambiarán la rotación del objeto.
constraints:  Var constraints : RigidbodyConstraints 
  Controla qué grados de libertad están permitidos para la simulación de nuestro 
  rigidbody. 
collisionDetectionMode:  var collisionDetectionMode : CollisionDetectionMode
  Permite establecer el modo de detección de colisiones del rigidbody.
centerOfMass:  var CenterOfMass : Vector3 
  Representa el centro de masa relativo al origen del transform. 
worldCenterOfMass:  var worldCenterOfMass : Vector3 
  Esta variable nos indica el centro de masa/gravedad de un rigidbody en el espacio 
  global. 
detectCollisions:  Var detectCollisions : Boolean 
  Indica si la detección de colisiones está habilitada (por defecto, sí). 
interpolation:  Var interpolation : RigidbodyInterpolation
  Nos permite suavizar el efecto de correr físicas en un framerate fijo.
sleepVelocity:  var sleepVelocity : float 
  La velocidad lineal, por debajo de la cual los objetos empiezan a dormir.
sleepAngularVelocity:  var sleepAngularVelocity : float 
  La velocidad angular, por debajo de los cuales los objetos empiezan a dormirse.
maxAngularVelocity:  Var maxAngularVelocity : float 
  Representa la maxima velocidad angular del rigidbody.

FUNCIONES:
SetDensity:  Function SetDensity (density : float) : void 
  Nos permite asignar una masa en base al collider vinculado, lo cual es útil para
  asignar una masa en unos valores acordes al tamaño de los colliders.
AddForce:  function AddForce (force : Vector3, mode : ForceMode = 
ForceMode.Force) : void
  Esta función añade una fuerza al rigidbody. Como resultado de esto el rigidbody 
  comenzará a moverse.
AddRelativeForce:  function AddRelativeForce (force : Vector3, mode : 
ForceMode = ForceMode.Force) : void
  Añade una fuerza al rigidbody relativa al sistema local de coordenadas de dicho 
  rigidbody.
AddTorque:  function AddTorque (torque : Vector3, mode : ForceMode = 
ForceMode.Force) : void 
  Esta función añade una torsión al rigidbody. Como resultado el rigidbody empezará
  a girar alrededor del eje de torsión. 
AddRelativeTorque:  function AddRelativeTorque (torque : Vector3, mode : 
ForceMode = ForceMode.Force) : void
  Esta función añade una fuerza de torsión relativa a las coordenadas locales del 
  rigidbody. 
AddForceAtPosition:  Function AddForceAtPosition (force : Vector3, 
position : Vector3, mode : ForceMode = ForceMode.Force) : void
  Aplica fuerza a un rigidbody en una posición determinada. 
AddExplosionForce:  Function AddExplosionForce (explosionForce : float, 
explosionPosition : Vector3, explosionRadius : float, upwardsModifier : float = 
0.0F, mode : ForceMode = ForceMode.Force) : void
  Aplica una fuerza al rigidbody que simula el efecto de una explosión. La fuerza 
  de la explosión decaerá de manera lineal con la distancia del rigidbody.
MovePosition:  Function MovePosition (position : Vector3) : void 
  Mueve de posición el rigidbody.
MoveRotation  unction MoveRotation (rot : Quaternion) : void 
  Rota el rigidbody.
Sleep:  Function Sleep () : void 
  Fuerza al rigidbody a dormir al menos un frame. 
IsSleeping:  Function IsSleeping () : Boolean 
  Booleano que devuelve true si el rigidbody está durmiendo.
WakeUp:  Function WakeUp () : void 
  Fuerza al rigidbody a despertarse.
SweepTest:  Function SweepTest (direction : Vector3, hitInfo : RaycastHit, distance 
: float = Mathf.Infinity) : Boolean
  Devuelve true cuando un barrido del rigidbody intercepta algún collider. Almacena
  información del primer collider que intercepta. 
SweepTestAll:  Function SweepTestAll (direction : Vector3, distance : 
float = Mathf.Infinity) : RaycastHit[] 
  Es parecida a la anterior, pero devolviendo un array de tipo RaycastHit con toda 
  la información de todos los colliders hallados en el camino.
OnCollisionEnter:  function OnCollisionEnter (collisionInfo : Collision) : void 
  Es llamada cuando nuestro rigidbody/collider toca otro rigidbody/collider.
OnCollisionExit:  function OnCollisionExit (collisionInfo : Collision) : void 
  Es llamada cuando nuestro collider/rigidbody deja de tocar otro 
  rigidbody/collider.
OnCollisionStay:  function OnCollisionStay (collisionInfo : Collision) : void 
  Es llamada una vez cada frame para cada collider/rigidbody que esté tocando 
  nuestro rigidbody/collider.


Screen


VARIABLES DE CLASE:
resolutions:  static var resolutions : Resolution[] 
  Devuelve todas las resoluciones de pantalla completa soportadas por el monitor.
currentResoluction:  static var currentResolution : Resolution 
  Variable de sólo lectura que devuelve la resolución de pantalla actual. 
showCursor:  static var showCursor : boolean
  ¿Debe el cursor ser visible?
lockCursor:  static var lockCursor : boolean
  ¿Debe el cursor ser bloqueado?
whidth:  static var width : int 
  La anchura actual de la ventana en la pantalla en píxeles (sólo lectura).
height:  static var height : int 
  La altura actual de la ventana en la pantalla en píxeles (sólo lectura)
fullScreen:  static var fullScreen : boolean 
  ¿Está el juego corriendo en pantalla completa?
sleepTimeout:  static var sleepTimeout : float 
  Un ajuste de ahorro de energía, permitiendo la atenuación de la pantalla algún 
  tiempo después de la interacción del último usuario activo.

FUNCIONES DE CLASE:
SetResolution:  static function SetResolution (width : int, height : int, fullscreen 
: boolean, preferredRefreshRate : int = 0) : void
  Cambia la resolución de pantalla. 


Shader


VARIABLES:
isSupported:  var isSupported : boolean 
  Bool de sólo lectura que indica si un determinado shader puede correr en la 
  tarjeta gráfica del usuario.

FUNCIONES DE CLASE:
Find:  static function Find (name : String) : Shader 
  Encuentra un shader con el nombre dado.


SpringJoint


VARIABLES:
spring:  var spring : float 
  La fuerza del spring usada para mantener los dos objetos juntos. 
damper:  var damper : float 
  La fuerza de amortiguación usada para amortiguar la fuerza del spring.
minDistance:  var minDistance : float 
  La distancia mínima entre los rigidbodies relativa a su distancia inicial. 
maxDistance:  var maxDistance : float 
  La distancia máxima entre los rigidbodies relativa a su distancia inicial. 


Texture


VARIABLES:
width:  var width: int 
  Variable de sólo lectura que indica la anchura de la textura en píxeles.
height:  var height : int
  Variable de sólo lectura que indica la alturade la textura en píxeles.
filterMode:  var filterMode : FilterMode 
  Modo de filtrado de la textura.
anisoLevel:  var anisoLevel : int 
  Nivel de filtro anisotrópico de la textura.
wrapMode:  var wrapMode : TextureWrapMode  
  Modo de envoltura de la textura. 


Texture2D


VARIABLES:
mipmapCount:  var mipmapCount : int 
  Variable de sólo lectura que indica cuántos niveles de mipmap hay en la textura.
textureFormat:  var format : TextureFormat 
  El formato de los datos de los píxeles en la textura (sólo lectura). 

FUNCIONES:
Texture2D:  static function Texture2D (width : int, height : int) : Texture2D 
  Crea una nueva textura vacía. Esta tendrá un tamaño dado por anchura y altura, 
  con un formato de textura ARGV32 y con mipmaps.
SetPixel:  function SetPixel (x : int, y : int, color : Color) : void
  Función que nos permite indicar el color de los píxeles en las coordenadas que le
  pasamos. 
GetPixel:  function GetPixel (x : int, y : int) : Color 
  Devuelve el color del píxel que se halla en las coordenadas dadas.
GetPixelBilinear:  function GetPixelBilinear (u : float, v : float) : Color 
  function GetPixelBilinear (u : float, v : float) : Color 
SetPixels:  function SetPixels (colors : Color[], miplevel : int = 0) : void
  Establece un bloque de colores de píxeles. Esta función toma un array de colores
  y cambia los colores de los píxeles del nivel mip entero de la textura. 
SetPixels32:  function SetPixels32 (colors : Color32[], miplevel : int = 0) : void 
  Establece un bloque de colores de píxeles. Esta función toma un array de tipo 
  Color32 y cambia los colores de los píxeles del nivel de mip entero de la 
  textura. 
LoadImage:  function LoadImage (data : byte[]) : boolean 
  Carga una imagen de tipo JPG o PNG desde un array de bytes.
GetPixels:  function GetPixels (miplevel : int = 0) : Color[] 
  Esta función devuelve un array de colores de píxeles del nivel de mip entero de 
  la textura. 
GetPixels32:  function GetPixels32 (miplevel : int = 0) : Color32[]
  Obtiene un bloque de colores de píxeles en formato Color32.
Apply:  function Apply (updateMipmaps : boolean = true, makeNoLongerReadable 
: boolean = false) : void 
  Aplica en la práctica todos los cambios previamente efectuados con las funciones 
  SetPixel y SetPixels.
Resize:  function Resize (width : int, height : int, format : TextureFormat, hasMipMap 
: boolean) : boolean 
  Redimensiona la textura, y en concreto modifica la anchura, altura, formato y en 
  ocasiones crea mipmaps. 
ReadPixels:  function ReadPixels (source : Rect, destX : int, destY : 
int, recalculateMipMaps : boolean = true) : void 
  Lee píxeles de pantalla dentro de los datos de la textura guardada. 
EncodeToPNG:  function EncodeToPNG () : byte[] 
  Codifica esta textura en formato PNG. El array de bytes que devuelve es el 
  archivo PNG. 


Time


VARIABLES DE CLASE:
time:  static var time : float 
  Es el tiempo en segundos desde el inicio del juego (sólo lectura).
timeSinceLevelLoad:  static var timeSinceLevelLoad : float 
  Tiempo en segundos desde que el último level ha sido cargado (sólo lectura)
deltaTime:  static var deltaTime : float 
  El tiempo en segundos que se tardó en completar el último frame (sólo lectura).
fixedTime:  static var fixedTime : float 
  El tiempo desde que el último FixedUpdate comenzó (sólo lectura). 
maximumDeltaTime:  static var maximumDeltaTime : float
  El máximo tiempo que un frame puede tomar. 
smoothDeltaTime:  static var smoothDeltaTime : float
  Un Time.deltaTime suavizado. 
timeScale:  static var timeScale : float 
  La escala en la cual el tiempo pasa. 
frameCount:  static var frameCount : int 
  El número total de frames que han pasado (sólo lectura) 
realtimeSinceStartup:  static var realtimeSinceStartup : float
  El tiempo real en segundos desde que el juego empezó (solo lectura).
captureFramerate:  static var captureFramerate : int 
  Si está establecida en un valor superior a 0, el tiempo avanzará en (1.0 / 
  captureFramerate) por frame sin tener en cuenta el tiempo real.


Transform


VARIABLES:
position:  var position : Vector3
  Indica en qué punto del espacio global se ubica nuestro transform.
localPosition:  var localPosition : Vector3 
  Indica la posición del transform al que dicha variable pertenece, calculada en 
  términos relativos al transform del que aquél depende. 
eulerAngles:  var eulerAngles : Vector3  
  Indica la rotación del transform en grados.  
localEulerAngles:  var localEulerAngles : Vector3 
  Se refiere a la rotación en grados de un transform con relación a la que tiene el
  transform del cual depende en una relación hijo/padre. 
rotation:  var rotation : Quaternion 
  Contiene la rotación del transform en el mundo global almacenada en quaterniones. 
localRotation:  var localRotation : Quaternion 
  Indica la rotación en quaterniones de un transform relativa a la rotación de su 
  padre.
right:  var right : Vector3 
  El eje X de las coordenadas globales del transform. 
up:  var up : Vector3 
  El eje Y de las coordenadas globales del transform. 
forward:  var forward : Vector3 
  El eje Z de las coordenadas globales del transform. 
localScale:  var localScale : Vector3 
  Permite consultar o establecer la escala de un transform en relación con la de su 
  padre. 
parent:  var parent : Transform 
  Hace referencia al padre del transform.
root:  var root : Transform 
  Hace referencia al transform más alto de la jerarquía.
childCount:  var childCount : int 
  Indica el número de hijos que tiene un transform. 
lossyScale:  var lossyScale : Vector3 
  Representa la escala global del objeto. 

FUNCIONES:
Translate:  function Translate (translation : Vector3, relativeTo : Space = 
Space.Self) : void 
  Esta función nos permite mover el transform en la dirección y distancia indicados
  en el parámetro de tipo Vector3 traslation. El segundo parámetro nos permite 
  decidir si el transform se moverá según sus propias coordenadas (locales) o lo
  hará en base al espacio global.
Rotate:  function Rotate (eulerAngles : Vector3, relativeTo : Space = Space.Self)
 : void 
  Esta función permite rotar un transform.
RotateAround:  function RotateAround (point : Vector3, axis : Vector3, angle
 : float) : void 
  Esta función nos permite que nuestro transform rote alrededor de un punto (u 
  objeto situado en ese punto), como si orbitara. 
LookAt:  function LookAt (target : Transform, worldUp : Vector3 = Vector3.up) : void 
  Rotar nuestro transform hacia un objetivo.
TransformDirection:  function TransformDirection (direction : Vector3) : Vector3 
  Toma como único parámetro la dirección local de un transform almacenada en un 
  Vector3 y la convierte en dirección global, devolviéndola en otro Vector3.
InverseTransformDirection:  function InverseTransformDirection (direction : Vector3)
 : Vector3 
  Transforma una dirección global en dirección local. 
TransformPoint:  function TransformPoint (position : Vector3) : Vector3 
  Tansforma una posición de local a global.
InverseTransformPoint:  function InverseTransformPoint (position : Vector3) : Vector3 
  Transforma la posición de un transform dado del espacio global al espacio local. 
DetachChildren:  function DetachChildren () : void 
  Función que sirve para desparentar los hijos.
Find:  function Find (name : String) : Transform 
  Con esta función podemos buscar por su nombre -y en su caso acceder- a un 
  transform hijo de nuestro transform.
IsChildOf:  function IsChildOf (parent : Transform) : boolean 
  Devuelve true si el transform que hace la pregunta es hijo, "nieto" o incluso 
  idéntico al transform parent que pasamos como parámetro. 


Vector3


VARIABLES:
x:  var x : float      
  Componente x del vector.
y:  var y : float      
  Componente y del vector.
z:  var z : float      
  Componente z del vector. 
this[index:int]:  var this[index : int] : float      
  Otra forma de acceder a los componentes del vector, a través del índice 0, 1 y 2.
normalized:  var normalized : Vector3      
  Devuelve un vector con la misma dirección que el original, pero con magnitud 1. 
magnitude:  var magnitude : float      
  Devuelve la longitud o tamaño de un vector.
sqrMagnitude:  var sqrMagnitude : float      
  Devuelve el cuadrado de la longitud de un vector. 

VARIABLES DE CLASE:
zero:  static var zero : Vector3     
  Equivale a Vector3(0,0,0).
one:  static var one : Vector3      
  Equivale a Vector3(1,1,1).
forward: static var forward : Vector3      
  Equivale a Vector3(0,0,1).
up:  static var up : Vector3      
  Equivale a Vector3(0,1,0).
right:  static var right : Vector3      
  Equivale a Vector3(1,0,0).

FUNCIONES:
Vector3 (constructor):  static function Vector3 (x : float, y : float, z : float)
 : Vector3      
  Crea un nuevo Vector3.
Scale:  function Scale (scale : Vector3) : void      
  Multiplica el Vector3 que llama la función por el Vector3 que le pasamos a 
  dicha función como parámetro. 
Normalize:  function Normalize () : void      
  Hace que el Vector3 que la llama pase a tener una magnitude de 1, conservando 
  la misma dirección.
ToString:  function ToString () : String      
  Devuelve nuestro vector convertido en un string y formateado.

FUNCIONES DE CLASE:
Lerp:  static function Lerp (from : Vector3, to : Vector3, t : float) : Vector3      
  Esta función interpola linealmente entre dos vectores, desde from hacia to en el 
  valor t.
Slerp:  static function Slerp (from : Vector3, to : Vector3, t : float) : Vector3      
  Esta función interpola esféricamente entre dos vectores, desde from hacia to en 
  el valor t.

POSTED BY
POSTED IN
DISCUSSION
Con la tecnología de Blogger.