Entradas con tag ‘3d’

Importar modelos 3D con Three.js y WebGL

Publicado el: 7 comentarios

En un artículo anterior hice una breve introducción de Three.js, la librería de Javascript creada por MrDoob que facilita el trabajo con WebGL. Vimos cómo poner a punto nuestro escenario, cámaras, luces e incluso añadimos algunos elementos básicos como cubos o esferas. En esta ocasión comparto con vosotros la forma de importar modelos 3D a nuestro escenario.

Importar modelos 3D

Dentro de los archivos que podemos descargar de Three.js en github encontraremos una serie de loaders (“cargadores”) , que nos permiten importar a nuestra escena diferentes formatos de modelos tridimensionales.

Tal vez por una costumbre heredada de mi época con Away3D, he elegido para este ejemplo el importador de modelos Collada. Collada es un formato, similar a XML al que se pueden exportar modelos creados con Sketchup, Maya o 3DStudio. Para este caso he usado un modelo de la galería 3D de Google.

La explicación de la carga del modelo está incluida en los comentarios del código:

<script type="text/javascript" src='js/jquery-1.8.2.min.js'></script>
 <script type="text/javascript" src='js/threelast.js'></script>

<!--Cargamos el Loader de Collada -->
 <script type="text/javascript" src='js/ColladaLoader.js'></script>
 <script type="text/javascript">

 

 var grados = 0;

var ancho = 800,
 alto = 600;

var angulo = 30,
 ratio = ancho / alto,
 cerca = 0.1,
 lejos = 10000;

var escenario = $('#escenario');

var miRender = new THREE.WebGLRenderer();

var miCamara = new THREE.PerspectiveCamera(angulo, ratio, cerca, lejos);

var miEscena = new THREE.Scene();

 miRender.shadowMapEnabled = true;

miCamara.position.x = 0;
 miCamara.position.y = 400;
 miCamara.position.z = 400;

miRender.setSize(ancho, alto);

eje = new THREE.AxisHelper();
 eje.scale.set(100,100,100);

escenario.append(miRender.domElement);

var material = new THREE.MeshLambertMaterial({color: 0xebebeb});

/* SUELO */

var suelo = new THREE.Mesh(new THREE.CubeGeometry(400, 20, 400), material);
 suelo.position.x = 0;
 suelo.position.y = 0;
 suelo.position.z = 0;
 suelo.castShadow = suelo.receiveShadow = true;

/* MODELO */
 var modelo;
 //Creamos el objeto ColladaLoader
 var cargador = new THREE.ColladaLoader();
 //ConvertUpAxis corrige la orientación del modelo usando el plano XZ
 //como base, en lugar del XY que por defecto usa Collada.
 cargador.options.convertUpAxis = true;
 //El método load recibe dos parámetros: la url del modelo y una función
 //que hace de callback una vez cargado.
 cargador.load('./models/laevatein.dae',
 function(collada){
 modelo = collada.scene;
 //Ajustamos la escala del elemento.
 modelo.scale.set(0.1,0.1,0.1);
 //Ajustamos la posicion
 modelo.position.set(0,0,0);
 //Lo añadimos a la escena
 miEscena.add(modelo);
 //Enfocamos la cámara hacia él
 miCamara.lookAt(modelo.position);
 $('.cargando').hide();
 //Animamos la cámara
 animar(new Date().getTime());
 });

 /* LUZ */

var luzAmbiental = new THREE.AmbientLight(0x444444);

 var luz = new THREE.SpotLight(0xFFFFFF);

luz.position.x = 0;
 luz.position.y = 400;
 luz.position.z = 400;
 luz.castShadow = true;

 miEscena.add(eje);
 miEscena.add(luz);
 miEscena.add(luzAmbiental);
 miEscena.add(miCamara);

/* Esta función sólo realiza un movimiento de
 rotación de la cámara alrededor de nuestro modelo */
 function animar(t){
 grados += 1;
 rad = grados * Math.PI/180;
 var _x = Math.sin(rad) * 400;
 var _z = Math.cos(rad) * 400;
 miCamara.position.x = _x;
 miCamara.position.z = _z;
 miRender.render(miEscena, miCamara);
 miCamara.lookAt(modelo.position);
 window.requestAnimationFrame(animar, miRender.domElement);
}
 </script>

Ver ejemplo

VN:F [1.9.22_1171]
Valora esta entrada
Rating: 10.0/10 (1 vote cast)

Hacer webs en 3D con WebGL y Three.js

Publicado el: 4 comentarios

Una de las características más novedosas de HTML5 es su capacidad para usar gráficos tridimensionales.

WebGL es la especificación que se está desarrollando para mostrar sin plugins estos gráficos 3D. Además, WebGL permite renderizar mediante aceleración por hardware.

Estamos hablando de que los navegadores pueden mover aplicaciones similares a videojuegos como Quake o programas como 3DStudio. Parece increíble… pero es una realidad.

Renderizado real con WebGL

En este tutorial haré una introducción a Three.js, una librería Javascript muy similar a Papervision3D o Away3D, para desarrollar de forma ágil y eficaz (sorprende su rendimiento) entornos tridimensionales a tiempo real y animaciones.

Podéis ver el ejemplo completo aquí.

Primeros pasos con Three.js

En primer lugar descargaremos la última versión de Three.js de Github. En el repositorio encontraremos, además de la librería, una treintena de ejemplos espectaculares.

Crearemos un proyecto HTML5 sencillo, con un index.html y una carpeta js, donde copiaremos la librería jQuery (que usaré en ocasiones por comodidad) y la última versión de three.js.

Primero definiremos un div que usaremos de contenedor y le aplicamos un poco de CSS para definir tamaño y color:

<!DOCTYPE html>
<html>
 <head>
 <meta charset='utf8'>
 <title>Experimentos 3D</title>

 <style type="text/css">
 body{
 margin: 0;
 }
 #escenario{
 background: #000;
 height: 600px;
 position: fixed;
 width: 800px;
 }
 </style>
 </head>
 <body>
 <div id="escenario"></div>
 </body>
</html>

E importamos nuestras librerías:

<script type="text/javascript" src='js/jquery-1.8.2.min.js'></script>
<script type="text/javascript" src='js/threelast.js'></script>

Editor 3D three.js

A partir de aquí es donde nace la magia.

Primero definiremos nuestro motor de renderizado y nuestra escena. Nuestro render es el que hace que se interpreten y muestren nuestros elementos tridimensionales, nuestras luces, sombras… Para definir un render de WebGL incluiremos en javascript:

var miRender = new THREE.WebGLRenderer();

También crearemos una escena. La escena es el espacio tridimensional “infinito” donde incluiremos nuestros elementos:

var miEscena = new THREE.Scene();

Por último indicamos el tamaño del render y embebemos nuestro render dentro de la capa que creamos en HTML. De esta forma Three.js generará el canvas que mostrará el contenido de nuestra infografía.

//El ancho y alto coinciden con ancho y alto de nuestro
//div contenedor
var ancho = 800,
 alto = 600;

//Aplicamos los tamaños.
miRender.setSize(ancho, alto);

//Embebemos
escenario.append(miRender.domElement);

Luces, cámara, ACCIÓN!

Lo siguiente que necesitaremos en nuestra escena es la cámara que nos muestre el contenido. Nuestra cámara tendrá mínimo 4 valores: el ángulo, el ratio de proporción, la distancia focal mínima y la máxima.

//El ángulo definirá la lejanía o cercanía con la que
//veremos nuestros objetos. El ratio es la proporción
//resultante entre ancho y alto. Cerca y lejos definen
//la distancia mínima y la máxima focal que se renderizará.
var angulo = 30,
 ratio = ancho / alto,
 cerca = 0.1,
 lejos = 10000;

//Declaramos la cámara
var miCamara = new THREE.PerspectiveCamera(angulo, ratio, cerca, lejos);

//Definimos la posición de la cámara en coordenadas x, y, z
miCamara.position.x = 300;
miCamara.position.y = 300;
miCamara.position.z = -300;

Por defecto la cámara estará mirando hacia el punto 0,0,0 de coordenadas. Podríamos enfocarla hacia cualquier otro punto usando el método lookAt que veremos más adelante.

Para agrecar la cámara al escenario usaremos el método add:

miEscena.add(miCamara);

Ahora creamos una luz que ilumine nuestros futuros objetos 3D. Existen varios tipos de luces, aunque mi favorita es la SpotLight, ya que es la única que permite usar sombras.

//Declaramos nuestra luz. Esta recibe como parámetro el color.
var luz = new THREE.SpotLight(0xFFFFFF);

//Indicamos una posición para nuestra luz en cada eje.
luz.position.x = 0;
luz.position.y = 200;
luz.position.z = 200;

//Por último la añadimos a la escena
miEscena.add(luz);

Añadiendo objetos

Hasta ahora lo único que hemos logrado es tener un bonito entorno 3D sin mucha utilidad. Deberíamos crear alguna figura básica para contemplar el resultado de nuestro trabajo. Incluiremos un cubo:

//Material es un material del tipo Lambert, con un color
//hexadecimal gris claro. Esta será la textura de nuestro
//objeto
var material = new THREE.MeshLambertMaterial({color: 0xebebeb});

//Nuestros elementos son mallas (mesh) a los que les aplicamos
//estructuras geométricas (en este caso un cubo) y un material
var cubo = new THREE.Mesh(new THREE.CubeGeometry(60, 60, 60), material);

//Posicionamos
cubo.position.x = 0;
cubo.position.y = 50;
cubo.position.z = 0;

//Y añadimos a la escena
miEscena.add(cubo);

Para finalizar nuestro ejemplo, sólo debemos ordenar a nuestro render que visualice lo que hemos creado:

//Con el método lookAt, enfocamos con la cámara al cubo

miCamara.lookAt(cubo.position);

//Aplicamos el método render incluyendo la escena y la cámara que vamos a visualizar
 miRender.render(miEscena, miCamara);

Para terminar

Aunque algunos navegadores aún no incluyen soporte a WebGL, está claro que el 3D se va acercando cada vez más al mundo de la web. La posibilidad de usar estos gráficos sin tener que instalar plugins adicionales (como flash, unity o silverlight) es algo realmente bueno.

Podéis ver un ejemplo completo aquí (recomiendo usar Chrome) y no dudéis en consultar cualquier duda en los comentarios o en @ajnavajas

VN:F [1.9.22_1171]
Valora esta entrada
Rating: 8.3/10 (3 votes cast)

Weekend: Webs en 3D y sliders originales

Publicado el: Un comentario

Como en varias ocasiones me he propuesto el difícil reto de mantener una constancia en las publicaciones. Actualizaré al menos una vez a la semana con un artículo o tutorial de carácter técnico de calidad como el de buenas prácticas en responsive design, filtros avanzados en CSS3 o geolocalización con HTML5.

Además, durante el fin de semana publicaré una entrada titulada “Weekend:” donde incluiré enlaces a los proyectos más interesantes que descubra durante la semana. Será nuestro apartado para la inspiración.

Podéis enviarme vuestros propios proyectos o propuestas, pero sólo publicaré aquello que realmente se salga de lo convencional. Aquí empieza nuestro primer Weekend.

Acko.net, una web en 3D

Esta es una de las webs que más me ha impresionado en los últimos meses. Es un blog con un diseño espectacular en 3D creado por Steven Wittens. Por si fuera poco sus artículos son de una calidad asombrosa. Para disfrutar del efecto tendréis que usar Chrome.

Enlace: http://acko.net/

Autor: Steven Wittens

Twitter: https://twitter.com/unconed

Acko.net

Slider efecto “papel doblado” con CSS3

Un espectacular efecto que simula una imagen que se pliega como una fotografía de verdad. Usa CSS3 y unas pocas líneas de jQuery.

Enlace: http://compilr.org/

Autor: Prashant Sharma

Twitter: https://twitter.com/CompilrORG

Efecto doblez 3D en CSS3 y jQuery

Kort, un original slider

Hakim, uno de los más activos y mejores desarrolladores front-end de interactividad que he podido descubrir a través de las redes sociales, ha creado Kort, un elemento de UI a medio camino entre el slider o grupo de thumbnails. Kort es compatible con eventos touch y dispone de diferentes efectos (y más que incluirá) de animación.

Enlace: http://lab.hakim.se/kort/

Autor: Hakim El Hattab

Twitter: https://twitter.com/hakimel

Kort

VN:F [1.9.22_1171]
Valora esta entrada
Rating: 10.0/10 (2 votes cast)

Cortometraje de animación 3D: Hambuster

Navegando por The Awesomer me he encontrado con Hambuster un fabuloso corto de animación 3D. Aunque es una típica historia sobre hamburguesas antropófagas, tiene increíbles efectos y un excelente desarrollo por lo que ha sido galardonado con el Best Student Project Imagina 2011.

VN:F [1.9.22_1171]
Valora esta entrada
Rating: 9.0/10 (3 votes cast)

Un corto de animación espectacular: Salesman Pete

Publicado el: 2 comentarios

Este corto combina tecnología 3D y 2D en su animación. Tiene un ritmo muy rápido y unos efectos impactantes, además de un tema totalmente surrealista.

Muy recomendable.

VN:F [1.9.22_1171]
Valora esta entrada
Rating: 9.0/10 (1 vote cast)