Blender y JMonkeyEngine. Exportación de archivos Blender y uso de los mismos en JMonkeyEngine

4
21304

Blender y JMonkeyEngine. 

Exportación de archivos Blender y uso de los mismos en
JMonkeyEngine

    Nos encontramos ante un nuevo tutorial de Blender y
JMonkeyEngine. En tutoriales anteriores de www.adictosaltrabajo.com
hemos visto como animar una figura mediante Blender y  en otros
hemos visto como trabajar con el motor gráfico JMonkeyEngine
(JME).

    www.adictosaltrabajo.com/tutoriales.php?id=44

    Una combinación de ambos nos puede dotar de
una herramienta importante para diseñar juegos basados en Java
de manera simple.

    En este tutorial veremos cómo exportar una animación
diseñada en Blender a un formato que podamos adaptar a nuestro
motor gráfico JME, es decir, qué formato es el adecuado
para
importar un archivo .blend a
un archivo accesible mediante JMonkeyEngine.

    Lo primero es diseñar nuestra
animación. Para nuestro ejemplo creamos una animación
partiendo del modelo articulado de nuestra mascota, la cual
diseñamos en el tutorial anterior:

    Blender. Animaciones avanzadas y renderización

    De dicho tutorial podemos descargar dicho modelo al
completo y a partir de él creamos una animación que
simule el movimiento de andar. Podemos descargar dicho modelo con la
animación ya creada del siguiente link: andar.blend

    A continuación nuestro objetivo es elegir un
formato adecuado de exportación y por lo tanto elegir un script
que dote a Blender de la capacidad de exportar archivos en dicho
formato.

    Tras realizar pruebas en otros tutoriales nuestros
con multitud de scripts y formatos, como por ejemplo formato 3ds, hemos dado con un formato
adecuado para nuestro objetivo.

    Hemos elegido el script de exportación para
Blender “ JME XML Export V2
”, el cual podemos descargar de la página de nuestro motor
gráfico JMonkeyEngine,
o a través del link:    JMEXmlExporter_V2.py

    Una vez descargado nuestro script lo que hacemos es
descomprimirlo y guardarlo en la carpeta “scripts” de Blender.
Dependiendo de la versión que utilicemos dicha carpeta se
encuentra en un lugar u otro de nuestro PC, en mi caso:
 

    Abrimos nuestra aplicación Blender y en la
parte superior izquierda accedemos al menú de
exportación, antes teníamos una serie de opciones que
representan cada una de las posibilidades de exportación, ahora
podemos observar que ya nos permite exportar en el formato que hemos
elegido:
 

    Como podemos ver, simplemente por el nombre del
script, nuestro formato del fichero de salida tras la
exportación será un archivo “.xml”
(Extensible Markup Language).

    Para comenzar con el proceso de exportación
tenemos que seleccionar en Blender los objetos que queremos exportar
antes de comenzar. En nuestro caso usamos la tecla “A” para seleccionar
todos los objetos de la escena. Posteriormente utilizamos el
menú antes descrito, esto nos despliega una pantalla del script
que nos sirve para configurar nuestra exportación:

 
    
    Para generar nuestro archivo .xml de forma adecuada hemos de
marcar todas las opciones del desplegable, excepto Generate Keyframes, ya que nuestros
Keyframes ya fueron añadidos cuando creamos nuestra
animación. Como podemos ver dichas opciones son
básicamente que exporte todos los materiales, color y texturas
de los elementos de nuestra escena, así como nuestra
animación al completo.

    A continuación pulsamos el botón “Export” y elegimos
nombre y ubicación de nuestro archivo. A continuación en
la parte superior derecha de la pantalla pulamos la opción
Export JME XML”,
comienza entonces el proceso de exportación. Se despliega la
venta de de consola de Blender donde podemos ver como genera el archivo
.xml:
 

    Este proceso puede tardar un tiempo variable
dependiendo del tamaño de nuestra animación.

    Una vez finalizado podemos ver el archivo resultante
en nuestro PC. No lo subimos a nuestro tutorial ya que el tamaño
es de aproximadamente 80mb, basta con seguir los pasos y generarlo uno
mismo.

   
    Hemos de señalar que el script que estamos
utilizando no admite exportar
objetos que tengan más de un
material asignado, es decir, si unimos algunos objetos de nuestra
figura hemos de asegurarnos que sólo tengan un material
asignado, de lo contrario nuestro script nos avisará del
problema al intentar exportar:
 

     A pesar de avisarnos que la exportación no
trabajará de forma correcta, este genera nuestro archivo .xml,
pero cuando veamos el resultado mediante los métodos explicados
a continuación, veremos que este no es el adecuado. Por ejemplo
hemos probado a unir el tronco de nuestra figura, y observamos que este
pierde por completo los materiales que se consideren secundarios:

 
    Por otro lado hemos tenido algunos problemas con la
rotación y situación de algunas figuras cuando hemos
exportado. Mientras en Blender la posición de todas nuestras
figuras era la correcta, al exportar observamos que el pelo y alas se
encontraban mal posicionadas. Para solucionarlo simplemente hemos unido
(JOIN recordar que en Blender
el comando es CNTRL+J
alas, pelo y cabeza en un solo objeto. El único problema que
para pintar las alas ahora no podemos tener varios materiales
así que deberíamos pintarlas con herramientas de brocha o
similar, pero el resultado es satisfactorio. Este método podemos
aplicarlo a todas las figuras que se encuentren mal posicionadas en
otros proyectos.

    Ya tenemos generado nuestro archivo .xml con toda
nuestra animación exportada correctamente. A partir de ahora ya
podremos utilizar dicho archivo en clases Java para los distintos usos
que queramos.

    Para visualizar el resultado de nuestra
exportación en Java, es decir nuestro archivo .xml, nos valemos
de la clase Java “XMLWorld”,
dicha clase fue explicada en el tutorial “Juegos 3D en Java: Blender y JMonkeyEngine”,
al cual podemos acceder con mediante el link de nuestra página
de adictos:

    https://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=BlenderavaMonkeyEngine

    Al ejecutarla de manera adecuada, es decir, con
nuestro archivo .xml asignado como atributo de ejecución en
nuestro proyecto Java, como se explica en el tutorial nombrado, podemos
observar el resultado final de nuestra exportación, es decir,
nuestra animación al completo con todos sus movimientos y formas
exportada en formato .xml:
 

Implantación de archivo .xml en el motor gráfico de
Java «JMonkeyEngine»

    Como podemos imaginar uno de los principales
objetivos de exportar a través de Blender un archivo en un
determinado formato, es utilizar dicho archivo en un motor
gráfico sea cual sea su origen e implementación.

    En nuestro caso hemos elegido como motor
gráfico JMonkeyEngine, un motor Java de código abierto
que nos dota de una herramienta indispensable y gratuita para la
creación de juegos. Dicho motor ya ha sido tratado en distintos
tutoriales de www.adictosaltrabajo.com, al detalle:

    https://www.adictosaltrabajo.com/tutoriales.php?id=44

    Utilizaremos para nuestro tutorial una serie de
clases  ya diseñadas en uno de nuestros tutoriales, comunes
y muy útiles para todo juego de JME, de las cuales podemos
descargar todo su contenido del siguiente tutorial “Funciones esenciales para crear un juego”:

    https://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=Detalles_de_los_juegos

    A partir de estas clases ya implementadas creamos un
nuevo proyecto donde incluiremos un pequeño método main
que represente un juego a través de JMonkeyEngine. El proyecto
ha sido realizado con la herramienta NetBeans. Podemos descargar el
código completo del proyecto del siguiente link, incluimos en el
proyecto la clase XMLWorld ya explicada con anterioridad.

    Mosca(Proyecto para la apliación NetBeans)

    Lo que hacemos básicamente es cargar nuestro
archivo de Blender exportado “default-jme.xml”,
mediante la clase “CargadorModelo”,
a continuación en la clase main, llamada “Juego”  que hemos
añadido, creamos nuestro skybox, nuestro terreno y jugador, la
funcionalidad es bastante simple. Aunque observamos métodos que
implementan las colisiones entre objetos dentro de nuestro main, dichos
métodos ahora mismo no nos interesan, además la
utilización de colisiones y movimientos a través de JME
ya han sido resueltos en tutoriales anteriores. Implementamos los
movimientos de nuestra mascota para que vaya hacía unas
coordenadas en concreto y para que podamos moverla con las flechas,
pero como ya hemos dicho no lo vemos en detalle en este tutorial.

    Para ejecutar nuestro proyecto sólo debemos
asegurarnos que en nuestra clase main es correcta la ruta de acceso al
archivo default-jme.xml :


 
    Si ejecutamos nuestro proyecto de NetBeans podemos
observar el resultado final, es decir, la animación que
habíamos diseñado en Blender ha cobrado vida en nuestro
juego, la hemos exportado a nuestro motor  gráfico
JMonkeyEngine con éxito.


 

    Aclarar que en este tutorial hemos elegido este
método de exportación, pero existen multitud de
métodos, como exportar en otros formatos (3ds, ogre, md3,
md5…) o incluso utilizar programas de descarga libre como
Modeler  (ModelerApplication ) para visionar nuestros archivos .xml.

    Hemos elegido este método porque tras
realizar multitud de pruebas con otros formatos y clases hemos obtenido
los mejores resultados con él.

    Aún tenemos un largo camino en www.adictosaltrabajo.com
de estudio de este motor gráfico, JMonkeyEngine, y de este
maravilloso programa de diseño Blender. Esperamos que
algún día lleguemos a tener un juego completo con nuestra
propia mascota.

4 Comentarios

  1. hola
    estuve haciendo el tutorial y es muy bueno
    pero lo que sucede es que a la hora de correr la aplicación me sale un error el cual es :

    GRAVE: Exception in game loop
    java.lang.OutOfMemoryError: Java heap space
    at java.util.Arrays.copyOfRange(Unknown Source)
    at java.lang.String.(Unknown Source)
    at com.sun.org.apache.xerces.internal.xni.XMLString.toString(Unknown Source)
    at com.sun.org.apache.xerces.internal.util.XMLAttributesImpl.getValue(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.AbstractDOMParser.startElement(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.AbstractDOMParser.emptyElement(Unknown Source)
    at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl.scanStartElement(Unknown Source)
    at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl$FragmentContentDriver.next(Unknown Source)
    at com.sun.org.apache.xerces.internal.impl.XMLDocumentScannerImpl.next(Unknown Source)
    at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl.scanDocument(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.XMLParser.parse(Unknown Source)
    at com.sun.org.apache.xerces.internal.parsers.DOMParser.parse(Unknown Source)
    at com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl.parse(Unknown Source)
    at javax.xml.parsers.DocumentBuilder.parse(Unknown Source)
    at com.jme.util.export.xml.XMLImporter.load(XMLImporter.java:74)
    at com.jme.util.export.xml.XMLImporter.load(XMLImporter.java:104)
    at Logico.CargadorModelos.CargaModelo(CargadorModelos.java:34)
    at Logico.Juego.buildPlayer(Juego.java:325)
    at Logico.Juego.initGame(Juego.java:273)
    at com.jme.app.FixedLogicrateGame.start(FixedLogicrateGame.java:124)
    at Logico.Juego.main(Juego.java:102)
    5/01/2010 08:21:03 AM com.jme.app.FixedLogicrateGame start
    INFO: Application ending.

    espero me puedan colaborar con este error
    Gracias 🙂

  2. Hola Jeisson109, lo siento por la tardanza en contestar, en periodo de navidades es más complicado.

    ¿Cuando se produjo este error? ¿al intentar ejecutar desde tu entorno?

    Este error suele ser porque hemos superado la memoria asignada a nuestra máquina virtual de java. Para ello hemos de subir los parámetros -Xms, y -Xmx de la misma. Ten en cuenta que esta memoria estará limitada por la memoria de la que tu equipo disponga, y por su puesto no podemos asignar toda la memoria a nuestra máquina virtual de Java.

    Prueba esta solución y sino haber si puedes proporcionarme algo más de información acerca de cuando se produce el error.

    Muchas gracias por tu colaboración y me alegro que te halla servido el tutorial.

    Saludos

  3. Excelente tutorial, lo he seguido y despues de descargar librerias extras, hacer ajustes aqui y allá, al fin logre compilar el proyecto, y ahora estoy muy interesado en seguir investigando sobre esto, ya que se me hace muy interesante

Dejar respuesta

Please enter your comment!
Please enter your name here