miércoles, 3 de octubre de 2012

Occlusion Culling (I de IV)

http://geeks.ms/blogs/jcanton/archive/2011/02/06/occlusion-culling.aspx

Hacía tiempo que no escribía y me alegra que el regreso sea con un tema tan interesante como el Occlusion Culling. Esta técnica podríamos clasificarla dentro de las técnicas de visibilidad para mejorar el rendimiento del render, y se suele usar junto a muchas otras técnicas de visibilidad conocidas, como el frustum culling o el back-face culling.
Back-face Culling: En esta técnica el objetivo es detectar cuales son las caras o polígonos de un objeto que no serán vistos desde la posición actual de la cámara (no se usará con objetos transparentes). De forma que dichas caras no serán dibujadas y por lo tanto reduciremos el coste en tiempo del render, sobre todo para objetos complejos donde podamos descartar gran cantidad de polígonos.
¿Y cómo funciona?, se obtiene la normal de una cara la cual puede tenerse ya almacenada tras la carga del modelo o se puede calcular usando el producto vectorial de dos aristas de la cara, después estudiaremos el signo del producto escalar entre dicha normal ( N ) y el vector de vista del observador ( L ), si el signo es “=” ó “> 0” significa que el ángulo formado por estos vectores es mayor o igual a 90º, lo que indicará que no será visible al observador y podremos descartar el polígono

Rotating An Image In Java Graphics 2D By Specified Degree

http://sanjaal.com/java/401/java-graphics-2d/rotating-an-image-in-java-graphics-2d-by-specified-degree/

http://www.htmlpoint.com/guidajava/java_30.htm

http://www.bibigeek.com/2009/03/11/como-rotar-imagenes-con-java/

RenderingHints, renderizados y operaciones de manipulación de imágenes

http://swing-facil.blogspot.com.es/2011/12/renderinghints-renderizados-y.html

Java 2D: Hardware Accelerating - Part 1 - Volatile Images

http://www.javalobby.org/java/forums/m91823967.html

Java 1.4 introduced support for hardware acceleration in Java 2D functionality. Hardware acceleration is great to have, no question - but effectively using the

java.awt.image.VolatileImage

class is at least bit more complicated than using a traditional 'buffered image' format. The details of working with this low-level 'hardware acceleration' is only really important if you are doing complex Java 2D rendering on your own. If you are only working with pre-built widgets/components in Swing for instance, most of this tip isn't really relevant. This tip is very helpful, however, for people working with 2D game programming in Java, or perhaps someone working on a graphics-intensive GUI such as charts and diagrams.

I'm going to assume that readers of this tip are familiar with at least the concept of double-buffering - if you aren't, please read here . In short, double buffering is a technique of deferring the rendering process to an 'offscreen' buffer, and then quickly copying that buffer to the onscreen device, which gives the illusion of higher performance (by making the onscreen rendering smoother). To simply produce a standard double buffer (not hardware accelerated), your code may look something like this:

// other classes may be extended - canvas is a common selection however.
public class CustomGUI extends Canvas {
 
 private Image offscreenImage;
 private Graphics offscreenGraphics;
 private Dimension offscreenDimension;
 
 // ...
 public void paint(Graphics g) {
  Dimension currentSize = getSize();
  if(offscreenImage == null || !currentSize.equals(offscreenDimension)) {
   // call the 'java.awt.Component.createImage(...)' method to get an
   // image
   offscreenImage = createImage(currentSize.width, currentSize.height);
   offscreenGraphics = offscreenImage.getGraphics();
   offscreenDimension = currentSize;   
  }
  
  // rendering code here (use offscreenGraphics 'Graphics' object)
  // this algorithm assumes the background will be re-filled because it 
  // reuses the image object (otherwise artifacts will 
  // remain from previous renderings)
  offscreenGraphics.setColor(Color.WHITE);
  offscreenGraphics.fillRect(0, 0, offscreenDimension.width, offscreenDimension.height);
  offscreenGraphics.setColor(Color.BLACK);
  offscreenGraphics.drawLine(0, 0, 10, 10); // arbitrary rendering logic
  
  // paint back buffer to main graphics
  g.drawImage(offscreenImage, 0, 0, this);
 }
 
 public void update(Graphics g) {
  paint(g);
 }
}

This sort of 'double-buffer' situation is the perfect case for hardware acceleration. The question becomes, however, how do you utilize classes such as the

java.awt.image.VolatileImage

class to accelerate this code? Well, adapted from the Javadocs of

VolatileImage

and the contents of this Java whitepaper on volatile images (which I highly recommend you read for a more thorough understanding) - here is a new version of the same class above that uses volatile images for rendering - don't worry, I will take a stab at explaining the 'wierdness' after:

// other classes may be extended - canvas is a common selection however.
public class CustomGUI extends Canvas {
 
 private VolatileImage volatileImg;
 
 // ...
 
 public void paint(Graphics g) {
  // create the hardware accelerated image.
  createBackBuffer();
 
  // Main rendering loop. Volatile images may lose their contents. 
  // This loop will continually render to (and produce if neccessary) volatile images
  // until the rendering was completed successfully.
  do {
   
   // Validate the volatile image for the graphics configuration of this 
   // component. If the volatile image doesn't apply for this graphics configuration 
   // (in other words, the hardware acceleration doesn't apply for the new device)
   // then we need to re-create it.
   GraphicsConfiguration gc = this.getGraphicsConfiguration();
   int valCode = volatileImg.validate(gc);
   
   // This means the device doesn't match up to this hardware accelerated image.
   if(valCode==VolatileImage.IMAGE_INCOMPATIBLE){
    createBackBuffer(); // recreate the hardware accelerated image.
   }
  
   Graphics offscreenGraphics = volatileImg.getGraphics();   
   offscreenGraphics.setColor(Color.WHITE);
   offscreenGraphics.fillRect(0, 0, getWidth(), getHeight());
   offscreenGraphics.setColor(Color.BLACK);
   offscreenGraphics.drawLine(0, 0, 10, 10); // arbitrary rendering logic
   
   // paint back buffer to main graphics
   g.drawImage(volatileImg, 0, 0, this);
   // Test if content is lost   
  } while(volatileImg.contentsLost());
 }
 
 // This method produces a new volatile image.
 private void createBackBuffer() {
   GraphicsConfiguration gc = getGraphicsConfiguration();
   volatileImg = gc.createCompatibleVolatileImage(getWidth(), getHeight());
 }
 
 public void update(Graphics g) {
  paint(g);
 }
}

Whew - things are getting complicated. Long story short, however, volatile images are just as their name suggests - temperamental. Volatile images can be considered to represent an image in non-standard memory (e.g. video card memory). This makes them reliant on an underlying hardware feature (the video card) that may or may not be the active 'weapon of choice' at all times, and as such the image may or may not apply (it represents memory in a video card not being used). This is specifically why the

VolatileImage.IMAGE_INCOMPATIBLE

check is performed. We ask the volatile image to validate itself against the graphics configuration for the current component (remember the graphics configuration represents, at its core, the destination 'device' of our component), and if it doesn't match, we reproduce the volatile image for the current graphics configuration (current video card for instance).

In addition to the foreign 'validate' check, we also have that nasty (and rare) use of a

do-while

loop. There are two reasons that all of this logic is wrapped in the

do-while

loop. First, after we have begun rendering to the volatile image, the image may once again become incompatible. In this case, the

contentsLost()

method will return true to let us know that something went wrong. Second, certain platforms (I won't name names) allow for a case where video memory may be 'lost' (*poof*! where'd it go?), and as such requires that you re-write any data to that block of memory. In these cases the 'valCode' returned from the

VolatileImage.validate(...)

method will actually be

VolatileImage.IMAGE_RESTORED

(there are three results - IMAGE_OK, IMAGE_RESTORED, IMAGE_INCOMPATIBLE). The way the code is structured above, however, this return-type doesn't need to be handled explicitly. In general,

VolatileImage.contentsLost()

returns true if the contents of the image have been lost for one of these reasons since the last call to VolatileImage.validate(...) was performed. Because of that distinction I just emphasized, our code works rather simply by performing two validates each loop: the call to

VolatileImage.validate()

before our rendering logic (to ensure our image is in good shape to use), and then a call to

VolatileImage.contentsLost()

after our rendering logic to determine if the image stayed happy since we last called validate (which implies all of our rendering logic since we called validate worked as expected).

Stay tuned, as tomorrow I will show how to hide some of this code craziness by using the

java.awt.image.BufferStrategy

class.

VolatileImage

http://www.java-gaming.org/index.php/topic,7045.

http://stackoverflow.com/questions/2684123/java-volatileimage-slower-than-bufferedimage

http://www.javalobby.org/java/forums/m91823967.html

https://deim.urv.cat/~pfc/docs/pfc852/d1238664969.pdf

http://singletechgames.com/2008/11/20/3-a-full-screen-exclusive-mode-fsem-worm-part-1/

http://singletechgames.com/category/java/killer-game-programming-in-java/

http://www.coderanch.com/t/346138/GUI/java/BufferedImage-versus-VolatileImage

http://content.gpwiki.org/index.php/Java:Tutorials:VolatileImage

http://www.oracle.com/technetwork/articles/javase/index-141909.html

http://www.java.net/pub/au/78?page=3

http://www.javahispano.org/antiguo_javahispano_org/2003/9/17/introduccion-al-api-volatileimage.html

http://www.exampledepot.com/egs/java.awt.image/VolImage.html

http://docs.oracle.com/javase/1.4.2/docs/api/java/awt/image/VolatileImage.html

http://webcache.googleusercontent.com/search?q=cache:r_ZKdfwidcYJ:docs.oracle.com/javase/1.4.2/docs/api/java/awt/image/VolatileImage.html+&cd=1&hl=es&ct=clnk&gl=es

http://www.java.net/node/703840

http://www.java.net/node/662985

OTROS ENLACES DE JAVA
http://www.docjar.org/docs/api/java/awt/GraphicsConfiguration.html

http://www.docjar.org/docs/api/java/awt/Canvas.html

Gráficos con Java 2D

http://www.programacion.com/articulo/graficos_con_java_2d_111/1

***********************************************
HABLA DE MUCHAS COSAS MUY INTERESANTE
***********************************************

OpenGL para Android para todos

http://www.muchoandroid.com.ar/2012/05/opengl-en-android-para-todos.html

En este primer post vamos a aprender a manejar los conceptos básicos de una de las librerías graficas más utilizadas, OpenGL.

Luego iremos haciendo cosas un poco más complejas, hasta llegar a gráficos en 3D y sus respectivas operaciones, pero primero lo primero.

Lo primero que debes conocer antes de empezar a graficar con OpenGL, son las clases a utilizar, y son:

- GLSurfaceView, la clase que te permite escribir las aplicaciones con OpenGL

- GLSurfaceView.Renderer, es una interfaz de renderizado genérica donde escribirás el código de lo que quieras que se dibuje.

El desarrollo de un juego para Android

http://unjuegoenandroid.blogspot.com.es/2011/09/que-herramientas-puedo-utilizar.html

¿Qué herramientas puedo utilizar?

El framework de android es bastante extenso y generalmente puede resultar confuso. Lo positivo de esto es que hay una API para cualquier cosa que se nos ocurra, además podemos usar una serie de SDK’s que están potenciadas para la creación de juegos.

Lo primero que tenemos que tener en cuenta para la creación del juego es que si este va a ser 2D o 3D, conociendo esto ya recein podemos decidir que SDK es el que nos convendrá usar para que nos brinde los mejores resultados.

Para desarrollar juegos en android existe un conjunto de herramientas y entonrnos de desarrollo que podemos utilizar para crear juegos en Andorid. Entre los mas conocidos o mas populares están:

Corona SDK: Lo que destaca de este SDK es con la facilidad y rapidez con las que se pueden empezar a crear juegos, dentro de lo más interesante de este SDK es que tiene un motor de física muy avanzado que permite crear juegos con tan sólo escribir unas pocas líneas de código. Además nos permitirá crear aplicaciones rápidas, poderosas y multiplataforma que tienen acceso a API’s de otros frameworks que nos permitirán manipular componentes de hardware como la cámara, GPS y acelerómetro.

Entre sus características principales cuenta con:

Integración automática con OpenGL-ES: No habrá necesidad de llamar a un sin número de clases y funciones para crear simples manipulaciones de la pantalla.

Desarrollo Multiplataforma: Corona nos permite crear aplicaciones tanto para iOS (iPhone, iPad) como para Android.

Rendimiento: Corona está optimizado para hacer uso de las características de hardware de aceleración, dando como resultado un alto rendimiento en juegos y aplicaciones.

Características del dispositivo: Posee controles nativos para el acceso al dispositivo y hardware como cámara, acelerómetro, GPS, etc.

Fácil de aprender: Corona utiliza el lenguaje de programación Lua, que es potente y fácil de aprender.

Lo interesante de Corona SDK es que podemos utilizarlo totalmente gratis. Basta con llenar un formulario y obtendremos una versión trial que contiene todas las funcionalidades y que podemos usar por tiempo ilimitado para desarrollar nuestros videojuegos. Pero si queremos darle uso comercial, ahí es cuando tendremos que comprar la licencia Indie que cuesta $199 dólares al año y que nos permite desarrollar únicamente para iPhone o para Android y $349 al año en la versión que nos permite trabajar con ambas plataformas.

Dejo un video para que vean lo fácil que es desarrollar con este SDK.

Libgdx: Este es un framework multiplataforma de desarrollo de juegos para Windows, Linux y Android. Está escrito en Java con una mezcla de C/C++ para dar soporte y rendimiento a tareas relacionadas con el uso de la física y procesamiento de audio. De esta forma, sólo hay que preocuparse por la parte de codificar en lenguaje Java mientras el framework se encarga de empaquetar todo el código nativo de la aplicacion.

Otra de las cosas interesantes de Libgdx es que permite escribir, probar y depurar la aplicación en el PC y utilizar el mismo código para Android. Esto se debe a que uno de los objetivos principales de este framework es brindar una arquitectura unificada para trabajar, garantizando el mismo comportamiento en todas las plataformas para las cuáles se ha creado el juego. Pero aun con esto, hay ciertas cosas que se deben tomar en cuenta cuando se está trabajando un mismo juego para PC y para Android, ya que el rendimiento puede ser muy bueno en PC y muy malo en Android.

Dentro de las herramientas que nos brinda Libgdx son las siguientes:

Un framework: Que nos permitirá manejar el ciclo de vida (creación, pausa, reanudación y destrucción) de nuestra aplicación.

Un módulo de gráficos: Que nos proporciona una forma de dibujar objetos en la pantalla.

Un módulo de audio: Para reproducir música y efectos de audio.

Un módulo de entrada: Para recibir toda la información del usuario proveniente del mouse, teclado, pantalla táctil, acelerómetro, etc.

Un módulo de I/O: Para leer y escribir datos como texturas, mapas o archivos de configuración.

Aca hay un video de un juego creado con este SDK.

AndEngine: Este SDK es que es de código abierto y que en sí, se trata de una implementación 2D de OpenGL para Android por lo que se utilizara puramente el lengaue Java, a diferencia de los motores Unity3D y Shiva3D con los que podíamos trabajar con lenguajes como C#, Python, o incluso Javascript.

En AndEngine se usa una terminología propia, explico aquí los conceptos más básicos:

BaseGameActivity: El BaseGameActivity es la raiz del juego, que contiene el motor y crea la vista donde se va a dibujar todo. Hay siempre exactamente un solo Engine por cada BaseGameActivity.

Engine: El Engine es el motor interno del juego, se encarga de ir dibujando en pantalla y actualizando objetos en la escena, que contiene todo el contenido que tu juego lleva. Normalmente hay una escena por por Engine, a menos que vayas a usar un SplitScreenEngines.

IResolutionPolicy: Una implementacion de IResolutionPolicy interface es parte del EngineOptions. Te hace abstraerte de la resolución del terminal, tú trabajas para una resolución y el AndEngine se encarga del resto.

Camera: Un objeto Camera define el rectangulo visible actualmente de la escena actual, no tiene porqué ser la escena completa. Normalmente hay una cámara por escena. Hay subclases específicas que permiten hacer zoom y mover la cámara suavemente.

Scene: La clase Scene es el contenedor para todos los objetos que se van a dibujar en la escena. Una escena puede tener Layers, que son capas para ordenar objetos. Hay subclases de la Scene como CameraScene/HUD/MenuScene que tienen comportamientos específicos.

Entity: Una entidad es un objeto que puede ser dibujado, como Imagenes, rectángulos, Texto, Líneas. Una entidad tiene posición/rotación/zoom/color...

Texture: Una textura es una imagen que se guarda en memoria. En Android, las imágenes deben ser una potencia de 2.

ITextureSource: Una implementacion de ITextureSource-interface se encarga de cargar una imagen en una posición en la textura.

TextureRegion: Una TextureRegion define un rectangulo en una imagen. Las TextureRegion se usan por Sprites para usar una imagen grande en la que guardamos muchas imagenes.

PhysicsConnector: Motor de físicas integrado en el Engine.

Aca hay un video de la física de AndEngine.

Unity3D: Con este motor de videojuegos se pueden desarrollar juegos en 3D implementar física avanzada, crear escenarios rápidamente con el editor de terrenos y crear scripts en tres lenguajes de programación distintos, Python, JavaScript y C#. Aunque la versión la gratuita permite publicar los juegos para Windows y para la web, la versión para publicación en Android tiene un costo de $400 dólares.

Por otro lado, Unity3D soporta una amplia variedad de formatos de diseños 3D como Blender, Cinema 4D, Maya y 3ds Max, por lo que los diseños se pueden importar a un escenario en Unity para luego armar un juego con gráficos de última generación. Lo mejor es que no es necesario escribir código distinto para cada plataforma, si no que una vez desarrollado el juego podemos exportarlo a Xbox360, Playstation 3, Nintendo Wii, MacOS, Windows, iPhone y obviamente juegos web que se reproducen a través de un plugin.

Y un video de un demo desarrollado con Unity3D.

Introducción a AndEngine (Parte I)

http://droideando.blogspot.com.es/2011/03/introduccion-andengine-parte-i.html

BaseGameActivity: El BaseGameActivity es la raiz del juego, que contiene el motor y crea la vista donde se va a dibujar todo. Hay siempre exactamente un solo Engine por cada BaseGameActivity.
Engine: El Engine es el motor interno del juego, se encarga de ir dibujando en pantalla y actualizando objetos en la escena, que contiene todo el contenido que tu juego lleva. Normalmente hay una escena por por Engine, a menos que vayas a usar un SplitScreenEngines.
IResolutionPolicy: Una implementacion de IResolutionPolicy interface es parte del EngineOptions. Te hace abstraerte de la resolución del terminal, tú trabajas para una resolución y el AndEngine se encarga del resto.
Camera: Un objeto Camera define el rectangulo visible actualmente de la escena actual, no tiene porqué ser la escena completa. Normalmente hay una cámara por escena. Hay subclases específicas que permiten hacer zoom y mover la cámara suavemente.
Scene: La clase Scene es el contenedor para todos los objetos que se van a dibujar en la escena. Una escena puede tener Layers, que son capas para ordenar objetos. Hay subclases de la Scene como CameraScene/HUD/MenuScene que tienen comportamientos específicos.
Entity: Una entidad es un objeto que puede ser dibujado, como Imagenes, rectángulos, Texto, Líneas. Una entidad tiene posición/rotación/zoom/color...
Texture: Una textura es una imagen que se guarda en memoria. En Android, las imágenes deben ser una potencia de 2.
ITextureSource: Una implementacion de ITextureSource-interface se encarga de cargar una imagen en una posición en la textura.
TextureRegion: Una TextureRegion define un rectangulo en una imagen. Las TextureRegion se usan por Sprites para usar una imagen grande en la que guardamos muchas imagenes pequeñicas.
PhysicsConnector: Motor de físicas integrado en el Engine

Engines para juegos

libGDX- Desktop/Android/HTML5 Java game development framework

SIO2 ENGINE

andEngin e - Free Android 2D OpenGL Game Engine
http://droideando.blogspot.com.es/2011/03/introduccion-andengine-parte-i.html

Slick -2D Game Library based on LWJGL (Java Desktop)

http://www.projectdarkstar.com/

Pulpcore(ABANDONADO)

jMonkeyEngine 3.0 | Java OpenGL Game Engine

playn - Cross platform game library for N≥5 platforms - Google ...

Cocos2D

Cocos2D for Iphone

lwjgl.org - Home of the Lightweight Java Game Library

http://lwjgl.org/javadoc/org/lwjgl/opengl/AWTGLCanvas.html

JOGL - Java Binding for the OpenGL API

Unity3D
UDK de Epic Games
CryEngine de Crytek
Shiva3D

FÍSICAS DE JUEGOS
Box2D
Havok

Libgdx para crear juegos en Android

http://androideity.com/2011/08/22/libgdx-para-crear-juegos-en-android/

Libgdx para crear juegos en Android

Escrito por Condesa | Monday, August 22, 2011 a las 11:42 am | 3 Comentarios

Uno de los ámbitos más populares para crear aplicaciones en Android (y en cualquier otra plataforma móvil) es sin duda la de los juegos. Hoy vamos a conocer una herramienta que te puede ser de mucha utilidad si lo que quieres es dedicarte a la creación de juegos en Android.
Se trata de Libgdx, un framework multiplataforma de desarrollo de juegos para Windows, Linux y Android. Está escrito en Java con una mezcla de C/C++ para dar soporte y rendimiento a tareas relacionadas con el uso de la física y procesamiento de audio. De esta forma, sólo tendrás que preocuparte por la parte que codificarás en lenguaje Java mientras el framework se encarga de empaquetar todo el código nativo de tus aplicaciones.

Otra de las cosas interesantes de Libgdx es que te permite escribir, probar y depurar tu aplicación en tu PC y utilizar el mismo código para Android. Esto se debe a que uno de los objetivos principales de este framework es brindar una arquitectura unificada para trabajar, garantizando el mismo comportamiento en todas las plataformas para las cuáles hayas creado tu juego. Genial ¿no?. Aún con esto, hay ciertas cosas que debes tomar en cuenta cuando estés trabajando un mismo juego para PC y para Android, ya que el rendimiento puede ser muy bueno en PC y muy malo en Android.
Las herramientas que nos brinda Libgdx son las siguientes:

Un framework que nos permitirá manejar el ciclo de vida (creación, pausa, reanudación y destrucción) de nuestra aplicación.
Un módulo de gráficos que nos proporciona una forma de dibujar objetos en la pantalla.
Un módulo de audio para reproducir música y efectos de audio.
Un módulo de entrada para recibir toda la información del usuario proveniente del mouse, teclado, pantalla táctil, acelerómetro, etc.
Un módulo de I/O para leer y escribir datos como texturas, mapas o archivos de configuración.

¿Por dónde empiezo?
Lo primero es descargarnos el framework desde la página del proyecto. A continuación te comparto un video introductorio de 13 minutos en el que podrás conocer todo el proceso de instalación y configuración de Libgdx con Eclipse y un pequeño demo por medio de un ejemplo que te permitirá darle un vistazo rápido a los componentes básicos del framework y puedas arrancarte a crear tus propios demos de juegos.

Links de referencia

Wiki. Te recomiendo que explores toda la página del proyecto de Libgdx, y en especial del apartado de la Wiki que contiene información General básica y en la que también encontrarás la estructura básica de un proyecto con Libgdx; la Guía del desarrollador con información de los módulos que contiene el framework y las consideraciones a tomar para el uso óptimo en tus juegos, las herramientas que puedes utilizar y el apartado de Tutoriales que se encuentran divididos en categorías de Beginner, Intermediate y Misc.
Javadoc. La documentación de referencia que te permitirá navegar y consultar información de alguna clase en específico de Libgdx.
Foro. Cuando empiezas a conocer un proyecto uno de los pilares más importantes son los foros en dónde puedes encontrar información de otros usuarios que tal vez ya resolvieron una duda que te aqueja ahora y también si tienes la oportunidad de aportar algo hazlo.
Videotutoriales. Échale un ojo a esta serie de videotutoriales para que empieces con lo básico de Libgdx.
Badlogic Games. En esta página encontrarás ligas de referencia a documentación y a la comunidad que apoya este proyecto.

AndEngine, otro motor de juegos 2D OpenGL

http://www.muchoandroid.com.ar/2012/05/andengine-otro-motor-de-juegos-2d.html

Links de referencia

Si quieres empezar a crear demos con AndEngine te comparto unos links que te pueden servir de mucha ayuda para lograrlo.

Droideando. Un excelente blog enfocado a publicar series de tutoriales acerca de AndEngine y tips muy útiles para desarrollo de juegos en Android.
Guía tutorial para programar juegos 2D en Android utilizando AndEngine. Este es uno de los recursos que más recomiendo que revises ya que se explica desde cómo enlazar tu proyecto con la librería, la estructura básica de un juego, implementación de características básicas y cómo mejorar el rendimiento de un juego.
AndEngine – Examples. Aplicación Android con ejemplos de AndEngine para que los veas corriendo en un entorno completamente “real”.
Código del proyecto. Aquí encontrarás varias extensiones que puedes utilizar en tus proyectos y una serie de video dónde se muestra su uso.
Foro y Blog oficiales.
Artículo “Eligiendo un framework de desarrollo para Android”. Este artículo expone una comparativa entre varios frameworks de los cuáles podemos elegir para crear juegos. Te ayudará a decidir cuál es que más se acomoda a tus necesidades.

Engine choice before development

http://aniketos00.blogspot.com.es/2012/03/engine-choice-before-development.html

3D Android Game Engines
• Unity3D: http://unity3d.com/
• Airplay SDK: http://www.airplaysdk.com/index.php
• ShiVa3D: http://www.stonetrip.com/mobile-publishing.html
• DX Studio: http://www.dxstudio.com/
• Unreal Development Kit: http://udk.com/
• Papaya: http://papayamobile.com/developer/engine
• Dwarf-fw: http://code.google.com/p/dwarf-fw/
• jPCT-AE: http://www.jpct.net/jpct-ae/
• Catcake: http://code.google.com/p/catcake/
• Alien3D: http://code.google.com/p/alien3d/
• Sio2: http://sio2interactive.com/

2D Android Game Engines
• Cuttlefish Engine: http://www.cuttlefishengine.com/
• Rokon 2D Game Engine: http://code.google.com/p/rokon/ (discontinued as of 2011-10-17)
• Corona Game Edition: http://anscamobile.com/corona/games/index.html
• AndEngine: http://www.andengine.org/
• Candroidengine: http://code.google.com/p/candroidengine/
• Google App Inventor: http://appinventor.googlelabs.com/about/
• Mages Engine: http://code.google.com/p/mages/
• Android-2D-Engine: http://code.google.com/p/android-2d-engine/
• Angle: http://code.google.com/p/angle/
• Loon-simple: http://code.google.com/p/loon-simple/
• Libgdx: http://code.google.com/p/libgdx/

Web based Game Engines & Specials
• Flash 10.1/Air: http://labs.adobe.com/technologies/air2/android/#examples
• Aves Engine: http://www.dextrose.com/projekte/aves-engine/index.html
• jMonkeyEngine: http://www.jmonkeyengine.com/

Java a Tope. Sergio Gálvez Rojas.

http://books.google.es/books?id=M6reV4TGyIQC&pg=PA58&lpg=PA58&dq=java+2d+usar+opengl%3D&source=bl&ots=jdrVjg5tEM&sig=Iy0oGDS5ctwFy4oDdBeRaIsnPqE&hl=es&sa=X&ei=oSNsUKi6MLOL4gSj44GABg&ved=0CE0Q6AEwBQ#v=onepage&q=java%202d%20usar%20opengl%3D&f=false

Curso de Android por OutKast

http://www.youtube.com/user/0utKast?feature=watch

Lista Cursos Videotutoriales

Curso de node.js

Curso de Videotutoriales de node.js

13 vídeos

Aprende Adobe Illustrator CS6 practicando

Curso práctico de Videotutoriales sobre Adobe Illustrator CS6

9 vídeos

Curso de Desarrollo con Java EE 6

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Curso de Videotutoriales de Desarrollo con Java EE 6, NetBeans y y GlassFish 3

23 vídeos

Curso de C++

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de C++ de Videotutoriales.com. 29 videos. 20 horas.

35 vídeos

Curso de Android

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de Desarrollo de Aplicaciones para Android.

26 vídeos

Curso de Java

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de Java de Videotutoriales.com. Curso de 34 horas de duración formado por 40 Videos. Accede al índice temporal de cada video en este enlace:

40 vídeos

Curso de jQuery

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de jQuery de Videotutoriales.com. 21 Videotutoriales. 10 horas y media de duración.

21 vídeos

Curso de Drupal Práctico

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de Drupal Práctico de Videotutoriales.com

18 vídeos

Curso de CakePHP

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de CakePHP de Videotutoriales.com

21 vídeos

Curso XHTML, CSS y JavaScript

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de XHTML, CSS y JavaScript de Videotutoriales.com. 49 videos. 33 horas y media.

50 vídeos

Crear Web Dinámicas conforme a Estándares con DWCS3

Descarga Cursos completos con códigos en http://www.videotutoriales.com
Descarga videotutoriales sueltos en http://illasaron.com/html
Videotutoriales del Curso de Creación de Webs Dinámicas conformes a estándares con Dreamweaver CS3 de Videotutoriales.com