Tutorial de scripts para Unity 3d

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.

Por ejemplo:

if(renderer.material.HasProperty("_Color"))
renderer.material.SetColor("_Color",Color.red);

GetTag:

function GetTag (tag : String, searchFallbacks : boolean, defaultValue : String = "") : String


Obtiene el valor del tag del shader del material. Si el shader del material no tiene definido el tag, devuelve defaultValue. Si el parámetro searchFallbacks es true, entonces esta función buscará el tag en todos los subshaders. Si searchFallbacks es falso entonces sólo se hará la consulta para el actual subshader.


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. Cuanto el tercer parámetro (t) es cero, se toman los valores de start; cuando es 1, los valores se toman de end.


CopyPropertiesFromMaterial:

function CopyPropertiesFromMaterial (mat : Material) : void


Copia propiedades de otro material en este material.

mainTextureScale:

var mainTextureScale : Vector2


La escala de la textura principal.


FUNCIONES:

Constructor:

static function Material (contents : String) : Material


Crea un material temporal a partir de un shader descrito por un string.

static function Material (shader : Shader) : Material

O bien crea un material temporal directamente desde un shader que le proporcionemos de entre los que tengamos. A grandes rasgos la creación de un nuevo material sería así:

var shader : Shader;
var texture : Texture;
var color : Color;
function Start () {
renderer.material = new Material (shader);
renderer.material.mainTexture = texture;
renderer.material.color = color;
}

Arrastrándole el shader, material y color, o cuanto menos el primero, creamos un material totalmente nuevo.

static function Material (source : Material) : Material


Crea un material temporal copiando el shader y todas las propiedades del material que le pasamos como parámetro.


SetColor:

function SetColor (propertyName : String, color : Color) : void


Nos permite indicar el nombre para un determinado color. Muchos shaders usan más de un color, por ejemplo:

"_Color" es el color principal del material, que es el que puede ser también accedido desde la propiedad "color" de la clase.
"_SpecColor" es el color especular de un material (usado en shaders specular/glossy/vertexlit).
"_Emission" es el color que emite un material (usado en vertexlit shaders).
"_ReflectColor" es el color de reflexión del material (usado en reflective shaders).


En el ejemplo siguiente, sacado del manual de referencia, asignamos el shader glossy (brillante) a nuestra esfera, y establecemos su color especular en rojo:

function Start () {
renderer.material.shader = Shader.Find ("Glossy");
renderer.material.SetColor ("_SpecColor", Color.red);
}

GetColor:

function GetColor (propertyName : String) : Color


Obtiene el valor de un color con nombre. Por ejemplo:

print (renderer.material.GetColor("_SpecColor"));

SetTexture:

function SetTexture (propertyName : String, texture : Texture) : void


Establece el nombre de una textura. Permite cambiar el propertyName de la textura.

Los nombres comunes de las texturas que encontramos ya creadas en Unity son:

"_MainTex" es la textura difusa principal. Puede ser accedida también a través de la propiedad mainTexture.
"_BumpMap" es el mapa de normales.
"_Cube" se refiere al cubemap.


GetTexture:

function GetTexture (propertyName : String) : Texture

Obtiene el nombre de una textura.

Como podéis comprobar en el esquema superior, hemos subido dos peldaños en la jerarquía respecto a las últimas clases que estábamos estudiando, y vamos ahora a aproximarnos a una serie de clases que derivan directamente de la clase base Object.

La clase material, tal como es de suponer, accede a todas las propiedades de un material, permitiéndonos alterarlas/animarlas. Si pretendemos referirnos al material usado por un objeto, es preferible usar la propiedad Renderer.material, tal que así:

 renderer.material.color = Color.red;

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.

Es una variable de la clase Shader (que estudiaremos en su momento). Nos permite utilizar/crear/importar diferentes reacciones que tendrá nuestro objeto al darle la luz (diffuse, transparent, ect)

Por ejemplo, podemos comprobar qué tipo de shader tiene nuestra esfera. Para ello, antes que nada, eliminamos el script que tenemos vinculado a la luz (si es que estamos siguiendo las lecciones por orden), y editamos MiPrimerScript tal como sigue:

renderer.material.shader = Shader.Find( "Transparent/Diffuse" );
var miShader : String;
miShader = renderer.material.shader.ToString();
Debug.Log(miShader);

Como vemos, para obtener el tipo de material referido a un objeto recurrimos a la clase Renderer. Observamos que nuestra esfera tiene el shader por defecto, que es de tipo Difusse.

Y si queremos cambiar el tipo de shader y convertirlo en especular, usamos la función Find (que estudiaremos en su momento cuando demos la clase Shader) y se la asignamos a nuestra esfera.

var miShader : String;
renderer.material.shader = Shader.Find( "Specular" );
miShader = renderer.material.shader.ToString();
Debug.Log(miShader);

color:

var color : Color


El color principal del material. Es lo mismo que -como veremos en breve- usar GetColor o SetColor con el nombre “_Color”.

Añadimos una declaración a nuestro script para cambiarle el color a la esfera:

var miShader : String;
renderer.material.shader = Shader.Find( "Specular" );
renderer.material.color = Color.cyan;
miShader = renderer.material.shader.ToString();
Debug.Log(miShader);

mainTexture:

var mainTexture : Texture

La textura principal del material. Es lo mismo que usar GetTexture o SetTexture con el nombre “_MainTex”.

Si por ejemplo escribiéramos un script así:

var texture : Texture;
renderer.material.mainTexture = texture;

tendríamos una variable "expuesta" donde podríamos arrastrar la textura principal que quisiéramos que tuviera nuestro material.


mainTextureOffset:

var mainTextureOffset : Vector2

Nos permite desplazar la textura principal.

Hay un ejemplo muy indicativo en el manual de referencia de Unity, que he modificado ligeramente. Con carácter previo necesitaría que os descargárais una textura, a poder ser alguna cuyo movimiento fuera perceptible. Yo por ejemplo voy a utilizar esta:

http://www.blogger.com/img/blank.gif

Una vez descargada, la guardamos dentro de la carpeta "assets" de nuestro proyecto en Unity, de tal manera que en Proyecto nos salga.

Acto seguido escribimos este script:

var miTextura : Texture;
renderer.material.mainTexture = miTextura;

var scrollSpeed : float = 0.5;

function Update() {
  var offset : float = Time.time * scrollSpeed;
  renderer.material.mainTextureOffset = Vector2 (offset, 0);
}

Salvamos y arrastramos la textura hasta la variable expuesta del script miTextura.

Le damos al play y observaremos que la textura de nuestra esfera comienza a girar (ojo, si vemos las variables rotate de la esfera observaremos que no es el objeto el que gira, sino la textura la que se desplaza sobre el objeto). Meramente estamos cambiando de sitio a nuestra textura con respecto a nuestro objeto (pensemos en aplicaciones como anuncios de neón en una ciudad futurista).