jueves 21 de agosto de 2008

Nueva versión de Nocturnal Initiative

2 Comentarios

Hace dos días se ha lanzado una nueva versión de Nocturnal Initiaitve cargadita de mejoras:

We have posted our second major release (codenamed BrutalNamespaceLength/Malleable/LaconicPuma/WickedCrazyHorsepower). Some key items include:
* RCS is our main working library for Revision Control (it consumes Perforce)
* Reflect is our C++ reflection system that we use for storing export and original content
* Inspect is our data-drivable property UI system
Most of the modules that we have previously released are also updated with bug fixes and improvements.
Note that many of the wiki pages for these modules have yet to be written. Expect them to come online in the following weeks.
I have installed a plugin on this wiki called WikiArticleFeeds. You should be able to subscribe to future news updates using RSS here and Atom here, or using the shortcuts in the tool box to your left.

Además han reorganizado un poco todo presentando diferentes paquetes para descarga, así como añadido soluciones de Visual Studio y corregido algunos bugs

[J2ME] Log en aplicaciones J2ME

0 Comentarios
Una de los problemas que presenta el desarrollo en dispositivos móviles es la aparente falta de un sistema de log que funcione en la versión de java J2ME. Si, podemos hacer el típico System.out.printl(), pero eso aparte de ser una chapuza, no siempre funciona. Las aplicación J2ME son probadas en emuladores o en terminales reales, y normalmente éstos últimos no suelen implementar el volcado de la información de la consola a pantalla, y los emuladores no siempre son fiables al 100% para testear la plataforma: más de una vez me he encontrado con código que funcionaba perfectamente en el emulador y provocaba errores en el terminal real.
Lo recomendable es usar un sistema simple de log que vuelque la información a pantalla, por ejemplo. Buscando un poco he encontrado exactamente esta librería que expone exactamente lo que necesito: microlog
Microlog es una librería muy simple de logging, que permite redirigir la entrada del log a la consola, a un Form, a un registro RMS, o incluso a un fichero si el móvil soporta la API FileConnection especificada en JSR-75.
La librería es realmente sencilla de usar. Tenemos un objeto logger que será el encargado de escribir las entradas. En él registramos una serie de Appenders, que serán donde se redirigirán las entradas de log para ser procesadas. Por ejemplo, para crear un log que se muestre en consola y en un Form haríamos
import sf.net.micrologger.Logger; 
import sf.net.micrologger.appender.*; 

public class MyForm extends Form
{

private Logger myLogger;


public MyForm()
{
myLogger = Logger.getLogger();
myLogger.AddAppender( new ConsoleAppender() );
myLogger.AddAppender( new FormAppender( this ) );

myLogger.Info("new instance of MyForm created");
}
}

Adicionalmente he implementado mi propio appender que escribe las entradas en una clase derivada de canvas, ya que así podemos seleccionar hasta cierto punte el tamaño de la fuente usada a dibujar y por tanto se pueden mostrar más entradas a la vez que usando un FormAppender. Aquí está el fichero .java para descarga, sólo hay que recompilar el código de microlog añadiendo este fichero:
CanvasAppender.java
O bien descargar este jar creado por mi a partir de la versión 0.5.0.2 de microlog que ya incluye la clase CanvasAppender:

MicroLog.jar

lunes 18 de agosto de 2008

[J2ME]Desarrollo de aplicaciones J2ME en Mac OS X con NetBeans 6

12 Comentarios

En esta entrada vamos a intentar configurar y preparar un entorno de desarrollo para poder crear aplicaciones J2ME desde Mac OS X. En mi caso concreto uso la versión Leopard, pero en principio todos estos pasos sirven perfectamente para Tiger.

El entorno de desarrollo que vamos a usar es NetBeans. Se podría utilizar otro IDE multiplataforma, como Eclipse, pero mi experiencia de uso con este último es muy limitado, mientras que con NetBeans ya tengo experiencia de desarrollo de un juego y una librería para dispositivos móviles. Además considero que NetBeans está mejor preparado para el desarrollo de aplicaciones móviles:

  • Dispone de un editor visual, que permite editar las pantallas a visualizar en el dispositivo (sólo las clases derivadas de Screen, es decir, de alto nivel), editar los comandos que acepta esa Screen concreta, así como el flujo de las mismas. Aunque esto en algunos casos puede ser un incordio ya que no te permite tener el control de todo el código (el código autogenerado por el editor visual no se puede editar desde NetBeans), en general es bastante eficiente, y en cualquier caso sigue siendo muy útil para crear el esqueleto de la aplicación de forma rápida.
  • Permite la creación de varias configuraciones de proyecto, lo que junto a las habilidades (abilities), y un lenguaje de preprocesador, permite crear de forma sencilla diferentes versiones de la aplicación para cada familia de dispositivos, que es una de las pesadillas del desarrollo de aplicaciones J2ME.
  • A partir de la versión 6.0, NetBeans incluye un editor visual de Sprites y TileMaps para aprovechar la GameAPI incluida en el perfil MIDP2.0.

Lo primero que haremos es instalar NetBeans, para lo cual accedemos a su página web y pulsamos el link para descargarlo. En esta página seleccionaremos la versión para Mac OS en el despegable con la etiqueta 'platform'. Descargamos la versión 'Web & Java EE' o la versión 'all'. Una vez descargado instalamos NetBeans y lo ejecutamos.


NetBeans en la versión para Mac no incluye por defecto los plugins de la categoría Mobility debido a que no existen emuladores de dispositivos móviles por parte de los fabricantes bajo Mac OS. Pero eso no impide que podamos descargarlos nosotros, así que hacemos clic en el menú Tools/Plugins. En el diálogo que aparece seleccionamos todos los plugins de la categoría Mobility y pulsamos en el botón de Install. Cuando finalice de descargar los plugins el propio entorno nos pedirá reiniciarse para poder aplicarlos.

Instalar plugins 

Una vez hecho esto, necesitaremos un emulador de dispositivo móvil para poder probar y depurar las aplicaciones sin necesidad de estar copiándolas a un dispositivo físico. Como ya he comentado no hay ninguno disponible para mac por parte de Sun o de los importantes fabricantes de dispositivos móviles (como Nokia, Sony-Ericsson, etc) así que tendremos que utilizar uno genérico: el MPowerPlayer, que se integra perfectamente con NetBeans como un WTK más. Para ello nos vamos a la página web de MPowerPlayer, donde nos descargaremos el SDK y lo descomprimimos en la ubicación que deseemos.

Una vez hecho esto debemos añadir MPowerPlayer como plataforma J2ME en NetBeans. Para eso hacemos clic en el menú Tools / Java Platforms y pulsamos el botón Add Platform...

Menu java platformsConfiguración plataforma 1 Seleccion carpeta MPowerPlayer

Seleccionamos la carpeta donde hemos instalado el MPowerPlayer, y pulsamos el botón Search. NetBeans detectará en dicha carpeta una nueva plataforma llamada mpowerplayer sdk. Marcamos su casilla y pulsamos Next y por último Finish.

Configuración plataforma 2

Veremos entonces que la nueva plataforma aparece seleccionada en el diálogo que aparecía anteriormente, pero aún tenemos que cambiar un par de cosas mas. Hacemos clic sobre la plataforma MPowerPlayer SDK (si no has cambiado el nombre por defecto asignado a la plataforma) y veremos que aparece a la derecha la posibilidad de editar los comandos de ejecución y debug. En ambos debemos cambiar la última palabra encerrada entre llaves ( {jadfile} ), por {jadurl} y pulsamos el botón Close.

Comandos originales

Comandos modificados

Para comprobar que todo funciona creamos un nuevo proyecto J2ME en NetBeans haciendo clic en File / New Project, seleccionando J2ME como categoría, y Mobile Application como proyecto. NetBeans generará una aplicación sencilla con una pantalla que muestra el clásico "Hello world!" Sólo tenemos que compilar el proyecto (clic en el menú Run / Build Proyect) y ejecutarlo (clic en el menú Run / Run Project). Se generará un fichero .JAD que se cargará automáticamente en MPowerPlayer:

Ejecutando MPowerPlayer

Y ya tenemos NetBeans preparado para desarrollar aplicaciones J2ME

smile_regular

martes 12 de agosto de 2008

Especificaciones de OpenGL 3.0

0 Comentarios

Leo en GameDev que ya están disponibles las especificaciones de OpenGL 3.0.

pdf-logo

Ahí va lo más destacado gracias a un copy&paste de lo más perro:

  • API support for the new texture lookup, texture format, and integer and unsigned integer capabilities of the OpenGL Shading Language 1.30 specification (GL EXT gpu shader4).
  • Conditional rendering (GL NV conditional render).
  • Fine control over mapping buffer subranges into client space and flushing modified data.
  • Floating-point color and depth internal formats for textures and renderbuffers (GL ARB color buffer float, GL NV depth buffer float, 455 N.2. DEPRECATION MODEL 456 GL ARB texture float, GL EXT packed float, and GL EXT texture shared exponent).
  • Framebuffer objects (GL EXT framebuffer object).
  • Half-float (16-bit) vertex array and pixel data formats
    (GL NV half float and GL ARB half float pixel).
  • Multisample stretch blit functionality (GL EXT framebuffer multisample and GL EXT framebuffer blit).
  • Non-normalized integer color internal formats for textures and renderbuffers (GL EXT texture integer).
  • One- and two-dimensional layered texture targets
    (GL EXT texture array).
  • Packed depth/stencil internal formats for combined depth+stencil textures and renderbuffers (GL EXT packed depth stencil).
  • Per-color-attachment blend enables and color writemasks
    (GL EXT draw buffers2).
  • RGTC specific internal compressed formats (GL EXT texture compression rgtc).
  • Single- and double-channel (R and RG) internal formats for textures and renderbuffers.
  • Transform feedback (GL EXT transform feedback).
  • Vertex array objects (GL APPLE vertex array object).
  • sRGB framebuffer mode (GL EXT framebuffer sRGB)
    Plus deprecation of older features.

En GameDev han creado un hilo de discusión al respecto, y parece ser que la gente no ha acogido la nueva especificación con mucha alegría...

UPDATE: En CodePixel tampoco lo han cogido con mucho agrado.

lunes 11 de agosto de 2008

Parser para ficheros INI en .NET

0 Comentarios

Aprovecho para presentar (y añadir link) un proyecto sencillito que he hecho en mis ratos libres: una librería para procesar o generar ficheros .INI

Aunque un fichero .INI tiene una estructura bien definida, que es la que en la librería se usa por defecto, también se permite personalizar un poco la definición de los caracteres especiales usados para definir los diferentes elementos del fichero, pudiendo, por ejemplo, definir el caracter a usar para marcar una línea como comentario.

La librería define un parser básico que usa las clases System.IO.StreamWriter y System.IO.StreamReader para obtener y generar los datos .INI. A partir de ahí podemos convertirlo en lo que queramos, y como ejemplo la librería incluye implementaciones de parsers para tratar los datos desde un fichero o desde un string.

En la wiki que proporciona google code como parte de los proyectos que alberga, he escrito una página explicando el uso (en inglés).

A partir de ahí poco más hay que aprender (lo de librería simple no es un eufemismo smile_wink )

De todas maneras se incluye un fichero CHM con la documentación al estilo MSDN generado con SandCastle y SandCastle Help File Builder (un GUI del anterior que simplifica mucho la generación de documentación)

 

Espero que pueda servir a alguien de utilidad.

[C#] Arrays con índice distinto de cero

2 Comentarios

Una de las bizarradas características de Visual Basic al menos en sus versiones anteriores a VB.NET era la posibilidad de utilizar rangos arbitrarios a la hora de acceder a las posiciones de un array. Es decir, que para un array de n elementos ya no estamos limitados a usar las posiciones [0, n-1], sino cualquier otra: [-1, n-2], [-n, 0], etc.

Lo más común era utilizar el rango [1, n] que puede resultar más natural a la hora de contar los elementos de un array. El problema es que todo esto va en contra de la representación real en memoria de un array: un conjunto de datos del mismo tipo ordenados consecutivamente en memoria. Es precisamente por eso que comenzamos a contar las posiciones de un array en cero:

array

La posición del primer elemento en el array está en la posición de memoria 0x00fa, el segundo elemento se encuentra en la posición de memoria 0x00fa + 1 (suponiendo que el array contiene tipos que ocupan 1byte) y así sucesivamente.

Aunque hay gente que lo defiende no creo que vayas a crear "mejor código" haciendo esto

for (int i = 1; i<=array.Length; ++i)
array[i] = i;
que haciendo esto:
for (int i = 0; i<array.length;++i)
array[i] = i;

De todas maneras ya que a veces puede ser necesario crear este tipo de arrays, por ejemplo para llamar desde .NET a código VB6, podemos disponer de esta funcionalidad por medio de una factoría expuesta por la clase Array, más concretamente, con el método estático Array.CreateInstance:

public static Array CreateInstance (
Type elementType,
int[] lengths,
int[] lowerBounds
)

Necesitamos el tipo de los elementos que almacenará el Array, y además un par de arrays de enteros. El primero define la longitud de cada dimensión del array, por lo que esto nos permite crear arrays multidimensionales. El segundo define el índice inferior de cada una de las dimensiones.


Por ejemplo, para crear un array unidimensional de enteros de tamaño 100, con un índice inferior de 1 haríamos:

Array.CreateInstance( typeof(int),  new int[]{100}, new int[]{1})for (int i = 1; i <= 100; ++i)
{
// se debe de usar SetValue y GetValue en un array
a1.SetValue(i,i);
Console.WriteLine(a1.GetValue(i));
}

Bueno, y ahora que sabéis cómo hacerlo ¡no lo hagáis! smile_nerd