Tutorial de scripts para Unity 3d

DragWindow:

static function DragWindow (position : Rect) : void

Crea una ventana que puede arrastrarse. Si llamamos a esta función dentro del código de la ventana, automáticamente ésta podrá arrastrarse.

Le hemos de pasar a la función un parámetro que indica la parte de la ventana que puede ser arrastrada, dando un rectángulo que recorta la ventana original.

Para constatar lo que estoy diciendo, sólo tenéis que añadir esta línea a la función CreaMiVentana del ejemplo anterior:

GUI.DragWindow (Rect (0,0, 100, 20));

Pensad que 0,0 viene referido a la ventana emergente, no a las coordenadas generales.


static function DragWindow () : void

Esta función tiene un segundo prototipo que no requiere parámetros. Si queremos que nuestra ventana pueda ser arrastrada desde cualquier parte del background de la misma, es preferible utilizar esta forma de la función y colocarla al final de las funciones de la ventana.

Así, si modificamos esta parte del script:

function CreaMiVentana (windowID : int) {
  if (GUI.Button (Rect (10,20,100,20), "Hola mundo"))
  print ("Recibí un click");
  GUI.DragWindow ();
}

podremos arrastrar nuestra ventana emergente desde cualquier punto de ésta.


BringWindowToFront:

static function BringWindowToFront (windowID : int) : void


Trae una ventana determinada al frente del resto de ventanas flotantes. Tiene como único parámetro la ID de la ventana que queremos poner en primer plano.


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. Se le pasa como parámetro la ID de dicha ventana.


UnFocusWindow:

static function UnfocusWindow () : void


Quita el foco de todas las ventanas.

BeginGroup:

static function BeginGroup (position : Rect) : void
static function BeginGroup (position : Rect, text : String) : void
static function BeginGroup (position : Rect, image : Texture) : void
static function BeginGroup (position : Rect, content : GUIContent) : void
static function BeginGroup (position : Rect, style : GUIStyle) : void
static function BeginGroup (position : Rect, text : String, style : GUIStyle) : void
static function BeginGroup (position : Rect, image : Texture, style : GUIStyle) : void
static function BeginGroup (position : Rect, content : GUIContent, style : GUIStyle) : void


Comienza un grupo. Esta función debe emparejarse con una llamada a EndGroup.

Cuando comenzamos un grupo, el sistema de coordenadas para los controles GUI será tal que coincidirá la coordenada (0,0) con la esquna superior izquierda del grupo. Los grupos pueden ser anidados, estando lo hijos agrupados respecto de sus padres.

Esto es muy útil cuando movemos un montón de elementos GUI a lo largo de la pantalla. Un caso de uso común es diseñar nuestros menús para que encajen en un específico tamaño de pantalla, centrando la GUI en pantallas más amplias.

Los distintos prototipos de función usan estos parámetros:

position:     Rectángulo en la pantalla a usar para el grupo.
text:         Texto a mostrar en el grupo.
image:        Textura a mostrar en el grupo.
content:      Texto, imagen y tooltip para este grupo. Si el parámetro es 
              proporcionado, cualquier click de ratón es capturado por el grupo y 
              si no se proporciona, no se renderiza ingún bacground y los clicks 
              del ratón son renderizados. 
style:        El estilo a usar para el background. 

Veremos muy claramente la funcionalidad de este método con un ejemplo:

function OnGUI () {

 GUI.BeginGroup (new Rect (Screen.width / 2 -200 , Screen.height / 2 - 150, 400,    
 300));

 GUI.Box (new Rect (0,0,400,300), "Este cuadrado está ahora centrado, y dentro del 
 mismo podemos colocar nuestro menú");

 GUI.EndGroup ();
} 

Expliquemos páso a paso en qué consiste lo que hemos hecho. Para empezar usamos la función BeginGroup para crear un grupo en un rectángulo que se iniciará en el centro de la pantalla. Si lo ubicáramos en width/2 el rectángulo quedaría desplazado, pues no se estaría teniendo en cuenta en este caso la anchura del propio rectángulo. De esta manera, le hemos de restar al centro de la pantalla la mitad de la anchura del rectángulo, asegurándonos así que queda justo en el centro. Hacemos lo propio con la altura.

Una vez ya tenemos definido para el grupo un rectángulo centrado con unas dimensiones de 400 X 300, ahora para los controles dentro de dicho grupo la esquina superior izquierda del rectángulo pasa a ser la coordenada 0,0. Así, cuando a continuación invocamos una caja con un texto y la ubicamos en las coordenadas 0,0, ésta se nos viene a colocar al inicio del rectángulo del grupo.

No hemos de olvidarnos, por último, que si usamos una función BeginGroup hemos de usar cuando acabemos de diseñar el grupo una función EndGroup obligatoriamente, para indicarle a Unity que las instrucciones referidas al grupo ya se han acabado.


EndGroup:

static function EndGroup () : void


Finaliza un grupo.


BeginScrollView:



static function BeginScrollView (position : Rect, scrollPosition : Vector2, viewRect : Rect) : Vector2
static function BeginScrollView (position : Rect, scrollPosition : Vector2, viewRect : Rect, alwaysShowHorizontal : boolean, alwaysShowVertical : boolean) : Vector2
static function BeginScrollView (position : Rect, scrollPosition : Vector2, viewRect : Rect, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle) : Vector2
static function BeginScrollView (position : Rect, scrollPosition : Vector2, viewRect : Rect, alwaysShowHorizontal : boolean, alwaysShowVertical : boolean, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle) : Vector2


Inicia una vista de desplazamiento (scrollview) dentro de la GUI. Un scrollview nos permite poner una área más pequeña en la pantalla dentro de un área mucho mayor, usando barras de desplazamiento (scrollbars) a los lados.

Esta función devuelve la posición del scroll modificada. Al igual que con otras variables, se recomienda reintroducir en la variable que se le pasa a la función los datos nuevos que ésta devuelve.

Tiene estos parámetros:

position:            Rectángulo en la pantalla a usar para el ScrollView.
scrollPosition:      La distancia en píxeles que la vista es desplazada en las 
                     direcciones X e Y.
viewRect:            El rectángulo usado dentro del scrollview.
alwayShowHorizontal: Parámetro opcional para enseñar siempre el scrollbar 
                     horizontal. Si lo establecemos en falso o no lo aportamos a la 
                     función, sólo se enseñará cuando clientRect sea más ancho que 
                     la posición.
alwayShowVertical:   Lo mismo para el scrollbar vertical. 
horizontalScrollbar: GUIStyle opcional a usar por el scrollbar horizontal. Si no se 
                     aporta, se usará el estilo horizontalScrollbar del GUISkin que 
                     se esté usando.
verticalScrollbar:   Lo mismo para el scrollbar vertical

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
static function Window (id : int, clientRect : Rect, func : WindowFunction, image : Texture) : Rect
static function Window (id : int, clientRect : Rect, func : WindowFunction, content : GUIContent) : Rect
static function Window (id : int, clientRect : Rect, func : WindowFunction, text : String, style : GUIStyle) : Rect
static function Window (id : int, clientRect : Rect, func : WindowFunction, image : Texture, style : GUIStyle) : Rect
static function Window (id : int, clientRect : Rect, func : WindowFunction, title : GUIContent, style : GUIStyle) : Rect


Crea una ventana emergente y devuelve el rectángulo en el que dicha ventana se ubica.

Las ventanas flotan sobre los controles GUI normales,
Windows float above normal GUI controls, y pueden ser opcionalmente arrastrados por los usuarios finales. A diferencia de otros controles, necesitamos pasarles una función separada para los controles GUI para colocarlos dentro de la ventana.

Nota: Si usamos GUILayout (de próxima explicación) para colocar nuestros componentes dentro de la ventana, debemos usar GUILayout.Window.

Parámetros:

id:          Una ID única a usar para cada ventana.
clientRect:  Rectángulo en la pantalla a usar por el grupo.
func:        La función que crea el GUI dentro de la ventana. Esta función debe 
             tomar un parámetro, que será la ID de la ventana para la que se está 
             creando la GUI.
text:        Texto a mostrar como título para la ventana.
image:       Textura que muestra una imagen en la barra del título.
content:     Texto, imagen y tooltip para esta ventana.
style:       Un estilo opcional a usar por la ventana. Si no se aporta, se usará el
             estilo de ventana del GUISkin corriente. 

Y vamos con un ejemplo:

var windowRect : Rect = Rect (20, 20, 120, 50);

function OnGUI () {
  windowRect = GUI.Window (0, windowRect, CreaMiVentana, "Mi ventana");
}

function CreaMiVentana (windowID : int) {
  if (GUI.Button (Rect (10,20,100,20), "Hola mundo"))
  print ("Recibí un click");
}

Creamos una ventana con ID 0, que ubicamos en un rectángulo cuyas coordenadas y dimensiones están almacenadas en una variable, variable en la cual almacenaremos el rectángulo retornado por la función. Como tercer parámetro le pasamos una función que es la que crea los controles que irán dentro de la ventana, y por último el título de dicha ventana.

La función que crea los controles toma como parámetro a su vez el primer parámetro de GUI.Window, que es la id de la ventana, y en este caso meramente creamos un botón con un texto, que al ser pulsado imprime un mensaje en plantalla.

SelectionGrid:

static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int) : int
static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount : int) : int
static function SelectionGrid (position : Rect, selected : int, content : GUIContent[], xCount : int) : int
static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int, style : GUIStyle) : int
static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount : int, style : GUIStyle) : int
static function SelectionGrid (position : Rect, selected : int, contents : GUIContent[], xCount : int, style : GUIStyle) : int


Hace una cuadrícula (grid) de botones. Devuelve un int con el índice del botón seleccionado.

Permite los siguientes parámetros:

position:    Rectándulo de la pandalla a usar para la cuadrícula.
selected:    El índice del botón seleccionado de la cuadrícula.
texts:       Un array de strings que mostrar en los botones de la cuadrícula.
images:      Un array de texturas en los botones de la cuadrícula.
contents     Un array de texto, imágenes y tooltips para los botones de la cuadrícula
xCount:      Cuántos elementos caben en la dirección horizontal. Los controles serán
             escalados para encajar a meno que el estilo elegido para usar sea 
             fixedWidth.
style:       El estilo a usar. Si no se indica, se usa el estilo de botón marcado  
             por el GUISkin que se esté usando. 

Veamos un breve ejemplo:

var selGridInt : int = 0;
var selStrings : String[] = ["Grid 1", "Grid 2", "Grid 3", "Grid 4"];

function OnGUI () {
selGridInt = GUI.SelectionGrid (Rect (25, 25, 100, 30), selGridInt, selStrings, 2);
}

HorizontalSlider:

static function HorizontalSlider (position : Rect, value : float, leftValue : float, rightValue : float) : float
static function HorizontalSlider (position : Rect, value : float, leftValue : float, rightValue : float, slider : GUIStyle, thumb : GUIStyle) : float

Crea una barra de desplazamiento horizontal que el usuario puede arrastrar para cambiar un valor entre un mínimo y un máximo. Devuelve un float con el valor que ha sido elegido por el usuario.

Parámetros:

position:    Rectángulo en la pantalla a usar para la barra.
value:       El valor que muestra la barra. Esto determina la posición del 
             deslizable móvil. 
leftValue:   El valor del extremo izquierdo de la barra.
rightValue   El valor del extremo derecho de la barra.
slider:      El GUIStyle a usar para mostrar el área de arrastre. Si no se 
             utiliza, se usará el estilo de horizontalSlider que tenga por 
             defecto el GUISkin que se esté usando.
thumb:       El GUIStyle a usar para mostrar el deslizable móvil. Si no se usa, 
             se usará el estilo de horizontalSliderThumb style que tenga por 
             defecto el GUISkin que se esté usando. 

Y por último el ejemplo:

var valorDelSlider : float = 0.0;

function OnGUI () {
 valorDelSlider = GUI.HorizontalSlider (Rect (25, 25, 100, 30), valorDelSlider,  
 0.0,  10.0);
}

VerticalSlider:

static function VerticalSlider (position : Rect, value : float, topValue : float, bottomValue : float) : float
static function VerticalSlider (position : Rect, value : float, topValue : float, bottomValue : float, slider : GUIStyle, thumb : GUIStyle) : float


Crea una barra de deslizamiento vertical que el usuario puede arrastrar para cambiar un valor entre un mínimo y un máximo. Devuelve un float con el valor que ha sido escogido por el usuario.

Tiene los siguientes parámetros:

position:     Rectángulo en la pantalla a usar para la barra.
value:        El valor que muestra la barra. Esto determina la posición del 
              deslizable móvil. 
topValue:     El valor en lo alto de la barra
bottomValue:  El valor en lo bajo de la barra
slider:       El GUIStyle a usar para mostrar el área de arrastre. Si no se 
              utiliza, se usará el estilo de verticalSider que tenga por 
              defecto el GUISkin que se esté usando.
thumb:        El GUIStyle a usar para mostrar el deslizable móvil. Si no se usa, 
              se usará el estilo de verticalSliderThumb que tenga por 
              defecto el GUISkin que se esté usando. 

HorizontalScrollbar:



static function HorizontalScrollbar (position : Rect, value : float, size : float, leftValue : float, rightValue : float) : float
static function HorizontalScrollbar (position : Rect, value : float, size : float, leftValue : float, rightValue : float, style : GUIStyle) : float


Crea una barra de desplazamiento (scrollbar) horizontal. Un scrollbar es lo que usamos para desplazarnos por un documento. Por norma general en lugar de scrollbar usaremos scrolliews.

Devuelve un float con el valor modificado. Este puede ser cambiado por el usuario arrastrando el scrollbar o clickando en las flechas de los extremos.


Un breve ejemplo:

var valorDeBarra : float;

function OnGUI () {
 valorDeBarra = GUI.HorizontalScrollbar (Rect (25, 25, 100, 30), valorDeBarra,  
 1.0, 0.0, 10.0);
}

VerticalScrollbar:

static function VerticalScrollbar (position : Rect, value : float, size : float, topValue : float, bottomValue : float, style : GUIStyle) : float


Crea una barra de desplazamiento (scrollbar) vertical.