Tutorial de scripts para Unity 3d

Render:

function Render () : void


Renderiza la cámara manualmente, usando el clear flags de la cámara, target texture y otras propiedades. La cámara puede enviar mensajes como OnPreCull, OnPreRender o OnPostRender a cualquier script que esté vinculado, y renderizar algunos filtros de imagen.

Esto es usado para tener control preciso sobre el orden de renderizado. Para hacer uso de esta característica, crea una cámara y deshabilitala, y entonces llama a la función Render para ella.


RenderWithShader:

function RenderWithShader (shader : Shader, replacementTag : String) : void


Hace que la cámara renderice con reemplazo de sombreado (shader) . Esto renderizará la cámara, usando los clear flags de la cámara, target texture y otras propiedades. A direrencia de la función anterior, la cámara no enviará OnPreCull, OnPreRender or OnPostRender a scripts vinculados. Los filtros de la imagen tampoco serán renderizados.

Esto es usado para efectos especiales, como por ejemplo renderizar una visión de calor y cosas así. Para usar estas características, habitualmente crearás una cámara y la deshabilitarás y luego llamarás RenderWithShader en ella.


SetReplacementShader:

function SetReplacementShader (shader : Shader, replacementTag : String) : void


Hace que la cámara renderice con shader replacement. Después de llamar a esta función, la cámara renderizará su vista con shader replacement. Para volver al renderizado normal hay que llamar a ResetReplacementShader.


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. Esto es muy útil en el editor para bakear cubemaps estáticos de tu escena.

La posición de la cámara, clear flags y clipping plane distances son usados para renderizar dentro de las caras de un cubemap. faceMask es un mapa de bits que indica qué cara del cubemap debe ser renderizada. Cada bit se corresponde a una cara y está representado por un int dentro de una enum de tipo cubemapface. Por defecto las seis caras del cube map se renderizarán, que es lo que viene representado en la firma por el 63, que corresponde a lo que ocupan los bits de las seis caras.

La función devuelve false si el renderizado del cubemap falla.

Esta función tiene un segundo prototipo:

function RenderToCubemap (cubemap : RenderTexture, faceMask : int = 63) : boolean


Esta segunda modalidad es usada para reflexiones en tiempo real dentro de render textures de cubemap. Puede ser bastante caro en términos de rendimiento, eso sí, especialmente si las seiz caras del cubemap son renderizadas cada frame.


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…) Puede ser útil si queremos que una cámara coincida con la configuración de otra, para conseguir efectos personalizados de rendering, como por ejemplo los objetidos usando RenderWithShader.




VARIABLES DE CLASE:

main:

static var main : Camera


Se refiere a la cámara que esté habilitada y con el tag “Main Camera”(Read Only). Devuelve nulo si no hay una cámara con esas características en la escena.


allCameras:

static var allCameras : Camera[]


Devuelve todas las cámaras habilitadas en la escena.

ViewportToWorldPoint:

function ViewportToWorldPoint (position : Vector3) : Vector3


Es la función inversa a WorldToViewportPoint, que estudiamos en la lección anterior. Convierte por tanto la posición de un transform medida en el viewport space relativo de la cámara (0,0 a 1,1) a coordenadas globales.

Se suministra a la función un vector donde los componentes X e Y son las coordenadas de pantalla, y el componente Z es la distancia del plano resultante desde la cámara en unidades globales, y la función los transforma en coordenadas globales.

Así, podemos adaptar el ejemplo que nos propone el manual de referencia y dibujar una esfera amarilla en la esquina superior derecha de la pantalla, y traducir dichas coordenadas de ubicación a las generales de la escena.

function OnDrawGizmos () {
var deLaCamaraAlMundo : Vector3 = camera.ViewportToWorldPoint (Vector3 (1,1,0.5));
 
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (deLaCamaraAlMundo, 0.1);
}

Le hemos dado una profundidad a la ubicación de la esfera de 0.5. Hemos de tener presente que esta distancia no debe ser inferior a la que esté establecida en nearClipPlane, o no se verá.


ScreenToWorldPoint:

function ScreenToWorldPoint (position : Vector3) : Vector3


Convierte la posición de un transform desde el espacio de pantalla en píxeles (0,0 a pixelWidth,pixelHeight) a coordenadas globales, con la posición z (como en el resto de casos) medida en unidades globales desde la cámara.


ScreenToViewportPoint:

function ScreenToViewportPoint (position : Vector3) : Vector3


Convierte la posición de un transform de espacio de pantalla en píxeles (0,0 a pixelWidth,pixelHeight) a viewport space relativo al espacio de cámara (0,0 a 1,1).



ViewportToScreenPoint:

function ViewportToScreenPoint (position : Vector3) : Vector3


Convierte la posición del transform de viewport space relativo al espacio de cámara (0,0 a 1,1) en espacio de pantalla en píxeles (0,0 a pixelWidth,pixelHeight). La posición z en ambos tipo de medida es la misma, medida en unidades globales desde la cámara.


ViewportPointToRay:

function ViewportPointToRay (position : Vector3) : Ray


Devuelve un rayo que sale de la cámara en coordenadas relativas a ésta (0,0 a 1,1). El rayo comienza en el plano más cercano a la cámara, razón por la que la posición Z es ignorada.


ScreenPointToRay:

function ScreenPointToRay (position : Vector3) : Ray


Devuelve un rayo que va de la cámara a través de un punto de la pantalla. Estando el rayo en las coordenadas globales, empieza en el plano cercano a la cámara y va a través de la posición x e y en las coordenadas de píxeles (0,0 a pixelWidth,pixelHeight) en la pantalla (la posición z es ignorada.)

clearFlags:

var clearFlags : CameraClearFlags


Indica cómo la cámara completa el background. Admite los valores CameraClearFlags.Skybox (rellena el bacground con el skybox habilitado), CameraClearFlags.SolidColor (con el color que le indiquemos), CameraClearFlags.Depth (que mantiene el color que tuviera el background el frame anterior o en cualquier estado previo)o CameraClearFlags.Nothing (no se renderiza background alguno).


FUNCIONES:


ResetAspect:

function 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.

Lo veremos mejor con un ejemplo (por cierto, si al término del ejemplo anterior no lo hicísteis, aprovechad ahora para volver a marcar el checkbox del componente Camera de Main camera)

Editamos MiSegundoScript para que luzca como sigue:

camera.aspect = 2;
yield WaitForSeconds (5);
camera.ResetAspect();

Lo que estamos haciendo es lo siguiente: primero establecemos la variable aspect en 2. Recordemos que aspect es la anchura de la cámara dividida por la altura, esto es, en este caso la cámara será el doble de ancha que alta (y en consonancia lo grabado será el doble de estrecho de lo normal). Para ver la diferencia, intercalamos una instrucción yield que -como ya sabemos- suspende la ejecución de cualquier otra instrucción (en este caso durante cinco segundos) y acto seguido reseteamos el aspect de la cámara para devolverlo a sus parámetros normales.


WorldToScreenPoint:

function WorldToScreenPoint (position : Vector3) : Vector3


Transforma la posición de un transform desde el espacio global al espacio de la pantalla.

Recordemos que el espacio de la pantalla está definido en píxeles (izquierda-abajo es (0,0) y derecha-arriba es (pixelWidth,pixelHeight). La posición z se calcula en unidades globales desde la cámara.

Un ejemplo. Editamos MiSegundoScript tecleando esto:

var eseQueTuVesAhi : Transform;
var posicionGlobal : String;
var posicionEnPixeles : String;

posicionGlobal = eseQueTuVesAhi.position.ToString();
posicionEnPixeles = camera.WorldToScreenPoint(eseQueTuVesAhi.position).ToString();

Debug.Log("La posicion global es " + posicionGlobal + " y la posicion en pixeles " 
+posicionEnPixeles);

Guardamos y arrastramos desde la Jerarquía nuestro Cubo hasta la variable expuesta eseQueTuVesAhi. El script devuelve primero la posición global del cubo en la escena, en un string generado por la función ToString. Acto seguido convertimos ese vector3 que contiene las coordenadas globales en otro Vector3 que contiene la ubicación en píxeles del transform del cubo respecto de la pantalla. Al devolver un Vector3, podemos también aprovechar la función ToString para convertir dichas coordenadas en un String e imprimirlas. Recordemos que el tercer parámetro del Vector3 con la ubicación en píxeles viene referido (eje Z) a la distancia en unidades globales (metros) entre la cámara y el transform.


WorldToViewportPoint:

function WorldToViewportPoint (position : Vector3) : Vector3


Convierte la posición de un transform desde las coordenadas globales al espacio de punto de vista (viewport space en inglés). El viewport space es el relativo a la cámara, donde izquierda-abajo es (0,0) y derecha-arriba (1,1). La posición z se mediría en unidades globales desde la cámara.

Lo vemos con más claridad modificando ligeramente el script anterior:

var eseQueTuVesAhi : Transform;
var posicionGlobal : String;
var posicionEnEspacioCamara : String;

posicionGlobal = eseQueTuVesAhi.position.ToString();
posicionEnEspacioCamara = camera.WorldToViewportPoint(eseQueTuVesAhi.position).ToString();

Debug.Log("La posicion global es " + posicionGlobal + " y la posicion en espacio 
normalizado de camara " +posicionEnEspacioCamara);

Como vemos al darle al play, ahora se nos muestra en coordenadas relativas a la cámara la ubicación del transform del cubo. Continúa inalterada, eso sí, la distancia respecto del eje Z (profundidad), que ya dijimos que va medido en unidades globales respecto de la posición de la cámara.