Tutorial de scripts para Unity 3d

GetPixelBilinear:

function GetPixelBilinear (u : float, v : float) : Color


Devuelve el color de los píxeles filtrado en coordenadas normalizadas (u, v).

dichas coordenadas normalizadas u y v van de 0.0 a 1.0, al igual que las coordenadas UV en mallas.


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. Precisa una posterior llamada a Aply para que los cambios se actualicen en la tarjeta gráfica.

El array de colores es un array 2d plano, donde los píxeles se distribuyen de izquierda a derecha y de abajo arriba. El tamaño del array debe ser al menos la anchura por la altura o el level de mapeo mip usado.

Usar SetPixels puede ser más rápido que llamar a SetPixel repetidamente, especialmente para texturas grandes. Además, SetPixels puede acceder a niveles de mipmap individuales.

function SetPixels (x : int, y : int, blockWidth : int, blockHeight : int, colors : Color[], miplevel : int = 0) : void

Esta versión de la función no modifica el nivel mip entero, sino sólo la parte comprendida entre los parámetros blockWidth y blockHeight empezando desde x,y. El array de colores debe tener un tamaño de blockWidth*blockHeight, y el bloque modificado debe caber dentro del nivel mip usado.


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. No nos olvidemos de llamar después a Apply.



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.

function GetPixels (x : int, y : int, blockWidth : int, blockHeight : int, miplevel : int = 0) : Color[]

Este segundo prototipo retorna sólo el mip de la región blockWidth por blockHeight empezando por x,y.


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.

Si el parámetro updateMipmaps es true, los niveles de mipmap son recalculados también, usando el nivel base como fuente. Normalmente tendremos este parámetro en true salvo cuando queramos modificar los niveles mip nosotros mismos usando SetPixels.

Si el parámetro makeNoLongerReadable es true, la textura se marcará como no legible y la memoria será liberada en la siguiente actualización. Por defecto makeNoLongerReadable se pone en false.

Esta función, como ya dijimos previamente, consume muchos recurso, así que es deseable hacer el mayor número de cambios precisos entre cada llamada a la misma.


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. Esta función es muy similar al constructor, salvo que esta trabaja con una textura que ya existe.

precisa llamar a Apply para que los cambios tengan efecto en la tarjeta gráfica.


function Resize (width : int, height : int) : boolean

Esta variante cambia meramente la altura y o la anchura de la textura.


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. Copia un área de píxeles rectangular de la RenderTexture en uso o bien la vista (especificada por el parámetro source) dentro de la posición definida por destX y destY. Ambas coordenadas usan el espacio de píxeles, donde (0,0) is abajo a la izquierda.

Si recalculateMipMaps está establecido en true, los mip maps de la textura serán tambien actualizados. En caso contrario deberemos llamar a Apply para recalcularlos.

Esta función trabaja sólo con los formatos de textura ARGB32 y RGB24.


EncodeToPNG:

function EncodeToPNG () : byte[]


Codifica esta textura en formato PNG. El array de bytes que devuelve es el archivo PNG. Puedes escribirlo entonces en disco o enviarlo a través de la rec, por ejemplo.

Esta función solo trabaja con los formatos de textura ARGB32 y RGB24. La textura también debe tener el flag Is Readable marcado en import settings.

Es esta una clase para manejo de texturas. Se suele usar para crear texturas "al vuelo" (en tiempo de ejecución) o para modificar los assets de texturas existentes.


VARIABLES:

mipmapCount:

var mipmapCount : int


Variable de sólo lectura que indica cuántos niveles de mipmap hay en la textura.

El valor retornado incluye el nivel base también, razón por la cual esta variable siempre vale 1 o más.

El conteo de mipmaps se usa en caso de que utilicemos las funciones GetPixels o SetPixels para obtener o modificar respectibamente los diferentes niveles de mipmal. Por ejemplo, podemos querer cambiar una textura de tal manera que cada nivel de mipmap se tinte de un color diferente, y así en el juego veríamos cuantos niveles de mipmap son en realidad visibles.


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.

Normalmente querremos poner los colores de la textura después de crearla, usando las funciones SetPixel, SetPixels y Apply.

function Start () {
 var nuevaTextura = new Texture2D (128, 128);
 renderer.material.mainTexture = nuevaTextura;
}

Este sería el ejemplo básico. Creamos una nueva textura de dimensiones 128 X 128 y se la asignamos como principal textura al gameobject al que le vinculemos el script. En este caso eliminamos MiPrimerScript del gameobject PortaScripts y se lo vinculamos a la Esfera. Observaremos, si la tenemos seleccionada al darle al play, que ésta importa a vuelo la nueva textura, que por defecto es de color negro.


static function Texture2D (width : int, height : int, format : TextureFormat, mipmap : boolean) : Texture2D

Este segundo prototipo se diferencia del primero en que se le pasa a la función como parámetro un determinado formato para la textura y a la vez se indica si se crea con o sin 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. No obstante, para actualizar en realidad el color de dichos píxeles en la tarjeta gráfica del usuario, deberemos acto seguido llamar a la función Apply.

Dado que esta manera de actualizar las texturas consume bastantes recursos, así que sería deseable que cambiáramos tantos píxeles como fuera posible entre cada llamada a la función Apply.

Si tenemos pensado regenerar constantemente texturas en tiempo de ejecución, puede ser más rápido generar un array de colores de píxeles y asignarlos todos a la vez con la función SetPixels.

Esta función, por último, trabaja sólo con los formatos ARGB32, RGB24 y Alpha8. Para el resto de formatos SetPixel es ignorada.

Vamos a verlo con un ejemplo. Previamente sería interesante colocar la cámara en las siguientes coordenadas: position(0,1.5,-6), rotation(10,0,0). Así tendremos una mejor visión de lo que le acontecerá a la esfera en el próximo script. Editamos MiPrimerScript ahora:

function Start () {
var nuevaTextura = new Texture2D(128, 128);
renderer.material.mainTexture = nuevaTextura;

var mitadH : int = nuevaTextura.width/2;
var mitadV : int = nuevaTextura.height/2;
var unColor : Color = Color.green;

for (var x : int = 0; x < mitadH; x++){
for (var y : int = 0; y < mitadV; y++){

  nuevaTextura.SetPixel(x, y, unColor);
}
}
nuevaTextura.Apply();
}

Vamos por partes. Creamos primero una nueva textura y se la pasamos al gameobject al que tenemos vinculado el script. Almacenamos acto seguido en sendos integers la mitad de la altura y la anchura de la nueva textura. De esta manera, en un bucle for podemos asignar un determinado color a esa mitad. Recordemos en todo caso dejar la función Apply fuera del bucle, a los efectos de no sobrecargar el pc.


GetPixel:

function GetPixel (x : int, y : int) : Color


Devuelve el color del píxel que se halla en las coordenadas dadas. Si éstas están fuera de los bordes (más grandes de la anchura/altura o más pequeñas que cero) serán fijadas o repetidas en base al wrapmode de la textura

Si quieres leer un bloque amplio de píxeles de una textura, será más rápido usar GetPixels, la cual devuelve un bloque entero de colores de píxeles.

La textura debe tener activa la variable Is Readable en import settings, ya que de lo contrario fallará la función.