Programação Gráfica: Motor gráfico de animação [JAVA]

Después de definir un primer interface a dibujar los objetos gráficos em JAVA, vamos a implementar un motor gráfico de animación que nos permita gestionar la dinámica de la aplicación y, mais tarde, adicionar interação com o usuário.

El motor se encargará de llamar a las funciones que animan a cada uno de los objetos gráficos de la base de datos.

A motor de videojuego es un término que hace referencia a una serie de rutinas de programación que permiten el diseño, la creación y la representación de un videojuego.

Del mismo modo existen motores de juegos que operan tanto en consolas de videojuegos y sistemas operativos. A funcionalidade básica de um motor de jogo é fornecer um motor de renderização para 2D e3D, motor físico Detector de colisão, sons, scripting, animação, inteligencia artificial, redes, Streaming, gerenciamento de memória, e um grafo de cena.(W).

Nossa primeira aplicação do motor vai contar com a funcionalidade que já temos na classe responsável pelo armazenamento e representação: “Lousa“. Definir um nova interface para adicionar novas funcionalidades, possível animar um objeto.

Interface de Animable

O novo “interface” declarar um único método que irá incorporar as classes que implementam.

pacote gráfico;

público interface Animable {
	público invalidar alma();
}

Por exemplo, podemos modificar uma de nossas aulas de gráficos que anime, ou criar uma nova, que estende a funcionalidade do outro, como é o caso da nova classe Point2DAnimable que estende a classe Point2D para armazenar as coordenadas, e implementa a interface de animatable incentiva a função só muda as coordenadas armazenados aleatoriamente.

pacote gráfico;

public class Point2DAnimable estende-se Point2D implementa Animable{
	público Point2DAnimable(int x, int e){
		super(x,e);
	}
	public void alma() {
		x   =(int)(Math.random()*5);
		x-=(int)(Math.random()*5);
		e   =(int)(Math.random()*5);
		y-=(int)(Math.random()*5);
	}
}

Adicionar novos objetos para o sistema de armazenamento da principal applett classe Blackboard

	private void iniciarElementos() {
		pizarra.addElement(novo Point2DAnimable(50,50));
		pizarra.addElement(novo Point2D(70,50));
		pizarra.addElement(novo Point2D(50,70));
	}

Para animar objetos no banco de dados, implementação de um novo método na classe Blackboard analisará se animatable, no caso em que a chamada em si a função encoraja cada objecto

	public void anima(){
		Enumeração enum = bd.elements();
		Objeto ob;
		enquanto(enum.hasMoreElements()){
			ob = enum.nextElement();
			se(ob instanceof Animable){
				((Animable) se).alma();
			}
		}

	}

Motor de animación

El proceso que gestiona la actualización de la animación es el que denominamos motor de animación (construido como un hilo o “Thread“). Su responsabilidad se limita a llamar al procedimiento de animación que hemos implementado en la clase Lousa.

En sistemas operativos, um hilo de ejecución, hebra o subproceso es la unidad de procesamiento más pequeña que puede ser planificada por un sistema operativo.

Un hilo (Thread) es una característica que permite a una aplicación realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecución comparten una serie de recursos tales como el espacio de memoria, los archivos abiertos, situación de autenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debe llevar a cabo distintas funciones simultáneamente.

Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea.(W)

Nuestro motor de animación implementará la clase “Runnable” para disponer de métodos de inicio y parada.

pacote gráfico;

public class MotorGrafico implementa Runnable {
long interval = 100;

Dispondremos de una serie de variables de control de tipo booleano para poder pausar la animación.

boolean parar = false;
public void parar() { parar = true; }

boolean pausado = false;
void pausar() { pausado = !pausado; }

El constructor de la clase recibirá un objeto “Lousa” como parámetro. Servirá para saber qué elemento tiene la función de animación principal. Este objeto lo almacenaremos en una variable para referenciarlo posteriormente.

private Blackboard graf;
público MotorGrafico(Blackboard graf) {
	este.graf=graf;
}

Antes de arrancar el hilo de ejecución deberemos asegurarnos de que no está activo, en cuyo caso deberemos destruirlo para no ejecutar nada más que un proceso a la vez.

private volatile Thread blinker;
public void start() {
	se(blinker!=zero){
		blinker=zero;
	}
	blinker = novo Thread(este);
	blinker.start();
}

Para parar el motor de animación destruiremos el hilo de ejecución, simplemente asignándole un valor nulo a la variable que controla el “Thread”.

público invalidar stop() {
	blinker = zero;
}

El proceso principal se realiza en la función “correr()”.

Primero comprobaremos que no deseamos parar la ejecución del programa, y verificaremos que el hilo de ejecución es el adecuado. Si esto es así, suspenderemos la ejecución del programa unos milisegundos con la llamada a “sleep” e, al reanudarla, llamaremos al método de animación. Una vez animados los elementos gráficos volveremos a dibujarlos (repaint)

public void correr() {
	Thread thisThread = Thread.currentThread();

	enquanto (!parar && blinker == thisThread) {
		tentar {
			thisThread.sleep(interval);
		}  captura (InterruptedException e) {}

		se (graf != zero && !pausado) {
			animate();
			graf.repaint();
		}
	}
}

Função “animate” llamará a la función “alma()” de la clase “Lousa”, responsable de almacenar la base de datos gráfica.

	private void animate() {
		graf.anima();
	}
}

Ejecución del programa

La clase de ejemplo deberá incluir la declaración de un objeto “MotorGrafico” al que le pasaremos el correspondiente parámetro para localizar la pantalla gráfica o “Lousa”.

public class Example1 estende-se Applet {
	Blackboard pizarra=novo Lousa();
	MotorGrafico motor =novo MotorGrafico(ardósia);

Também, deberemos arrancar el motor de animación mediante la llamada a su método “start()”

	público Example1() throws HeadlessException {
		este.setLayout(novo GridLayout());
		este.add(ardósia);
		iniciarElementos();
		motor.start();
	}

Sólo nos queda añadir algunos elementos animables a la base de datos gráficos para completar el ejercicio. Veremos que unos puntos no se mueven, mientras que los que implementan el interface “Animable” si lo hacen de forma aleatoria.

	private invalidar iniciarElementos() {
		pizarra.addElement(novo Point2DAnimable(50,50));
		pizarra.addElement(novo Point2DAnimable(60,50));
		pizarra.addElement(novo Point2DAnimable(50,80));
		pizarra.addElement(novo Point2DAnimable(50,70));
		pizarra.addElement(novo Point2D(70,50));
		pizarra.addElement(novo Point2D(50,70));
	}

Curso JAVA