graphics - template - BlackBerry-transformada 3D de imagen

titles premiere template

Question

Sé cómo rotar la imagen en cualquier ángulo con drawTexturePath :

int displayWidth = Display.getWidth();
int displayHeight = Display.getHeight();
int[] x = new int[] { 0, displayWidth, displayWidth, 0 };
int[] x = new int[] { 0, 0, displayHeight, displayHeight };
int angle = Fixed32.toFP( 45 );
int dux = Fixed32.cosd(angle );
int dvx = -Fixed32.sind( angle );
int duy = Fixed32.sind( angle );
int dvy = Fixed32.cosd( angle );
graphics.drawTexturedPath( x, y, null, null, 0, 0, dvx, dux, dvy, duy, image);

pero lo que necesito es una proyección en 3D de una imagen simple con transformación 3D (algo como esto )

¿Puede por favor aconsejarme cómo hacer esto con drawTexturedPath (estoy casi seguro de que es posible)?
¿Hay alguna alternativa?

Answer 1

Con el siguiente código, puede sesgar su imagen y obtener una perspectiva como efecto:

 int displayWidth = Display.getWidth();
int displayHeight = Display.getHeight();
int[] x = new int[] { 0, displayWidth, displayWidth, 0 };
int[] y = new int[] { 0, 0, displayHeight, displayHeight };
int dux = Fixed32.toFP(-1);
int dvx = Fixed32.toFP(1);
int duy = Fixed32.toFP(1);
int dvy = Fixed32.toFP(0);
graphics.drawTexturedPath( x, y, null, null, 0, 0, dvx, dux, dvy, duy, image);

Esto sesgará su imagen en un ángulo de 45º, si desea un ángulo determinado, solo necesita usar algo de trigonometría para determinar la longitud de sus vectores.

Answer 2

El método utilizado por esta función (2 vectores de recorrido) es el mismo que los trucos de codificación de oldskool utilizados para el famoso efecto "rotozoomer". ejemplo de rotozoomer video

Este método es una forma muy rápida de rotar, ampliar y sesgar una imagen. La rotación se realiza simplemente girando los vectores de caminata. El zoom se hace simplemente escalando los vectores de caminata. El sesgo se realiza girando los walkvectors unos con respecto a los otros (por ejemplo, ya no forman un ángulo de 90 grados).

Nintendo había fabricado hardware en sus SNES para usar el mismo efecto en cualquiera de los sprites y / o fondos. Esto dio paso a algunos efectos muy geniales.

Una gran deficiencia de esta técnica es que no se puede deformar una textura en perspectiva. Para hacer esto, cada nueva línea horizontal, los vectores de caminata deberían cambiarse ligeramente. (difícil de explicar sin un dibujo).

En el snes superaron esto al alterar cada línea de exploración de los walkvectors (en aquellos días uno podía establecer una interrupción cuando el monitor estaba dibujando cualquier línea de exploración). Este modo más tarde se denominó MODO 7 (ya que se comportó como un nuevo tipo virtual de modo gráfico). Los juegos más famosos que usan este modo son Mario Kart y F-zero

Entonces, para que esto funcione en la blackberry, tendrá que dibujar los tiempos de "displayHeight" de la imagen (por ejemplo, cada vez una línea de escaneo de la imagen). Esta es la única forma de lograr el efecto deseado. (Sin duda, esto le costará un golpe de rendimiento ya que ahora llama a la función drawTexturedPath muchas veces con nuevos valores, en lugar de solo una vez).

Supongo que con un poco de google puedes encontrar algunas fórmulas (o incluso una implementación) de cómo calcular los walkvectors variables. Con un poco de papel (dado que no es tan malo para las matemáticas), también puede deducirlo usted mismo. Yo también lo hice cuando estaba haciendo juegos para el Gameboy Advance, así que sé que se puede hacer.

¡Asegúrate de precalcular todo! La velocidad lo es todo (especialmente en máquinas lentas como teléfonos)

EDITAR: hizo algunos google para usted. Aquí hay una explicación detallada de cómo crear el efecto de mode7. Esto te ayudará a lograr lo mismo con la función Blackberry. Implementación del modo 7

Answer 3

Quieres hacer un mapeo de textura, y esa función no lo cortará. Tal vez puedas evitarlo, pero la mejor opción es usar un algoritmo de mapeo de texturas.

Esto implica, para cada fila de píxeles, determinar los bordes de la forma y en qué parte de la forma se asignan los píxeles de la pantalla (los píxeles de textura). No es tan difícil en realidad, pero puede tomar un poco de trabajo. Y dibujarás la imagen solo una vez.

GameDev tiene un montón de artículos con código fuente aquí:

http://www.gamedev.net/reference/list.asp?categoryid=40#212

Wikipedia también tiene un buen artículo:

http://en.wikipedia.org/wiki/Texture_mapping

Otro sitio con tutoriales en 3D:

http://tfpsly.free.fr/Docs/TomHammersley/index.html

En su lugar, buscaría un sencillo programa de demostración que hiciera algo parecido a lo que desea y utilice sus fuentes como base para desarrollar las mías, o incluso encontrar una biblioteca fuente portátil, estoy seguro de que debe haber algunas.

Answer 4

Gracias por respuestas y orientación, +1 a todos ustedes.
MODE 7 fue la forma en que elegí implementar la transformación 3D, pero desafortunadamente no pude hacer que drawTexturedPath cambiara el tamaño de mis líneas de escaneo ... así que decidí usar DrawImage simple.

Suponiendo que tiene un Bitmap inBmp (textura de entrada), cree un nuevo Bitmap outBmp (textura de salida).

Bitmap mInBmp = Bitmap.getBitmapResource("map.png");
int inHeight = mInBmp.getHeight();
int inWidth = mInBmp.getWidth();
int outHeight = 0;
int outWidth = 0;
int outDrawX = 0;
int outDrawY = 0;
Bitmap mOutBmp = null;
public Scr() {
super();
mOutBmp = getMode7YTransform();
outWidth = mOutBmp.getWidth();
outHeight = mOutBmp.getHeight();
outDrawX = (Display.getWidth() - outWidth) / 2;
outDrawY = Display.getHeight() - outHeight;
}

En algún lugar del código, cree un Graphics outBmpGraphics para outBmp.
Luego haga lo siguiente en la iteración desde el inicio y hasta (altura de la textura) * y factor de transformación:
1.crear un mapa de bits lineBmp = nuevo mapa de bits (ancho, 1) para una línea
2.crear un Graphics lineBmpGraphics de lineBmp
3. pintar línea de textura a líneaBmpGraphics
4.encode lineBmp a EncodedImage img
Img de escala 5. de acuerdo con MODO 7
6.paint img a outBmpGraphics
Nota: El puerto PNGEncoder BB de Richard Puckett se usa en mi código

private Bitmap getMode7YTransform() {
Bitmap outBmp = new Bitmap(inWidth, inHeight / 2);
Graphics outBmpGraphics = new Graphics(outBmp);
for (int i = 0; i < inHeight / 2; i++) {
Bitmap lineBmp = new Bitmap(inWidth, 1);
Graphics lineBmpGraphics = new Graphics(lineBmp);
lineBmpGraphics.drawBitmap(0, 0, inWidth, 1, mInBmp, 0, 2 * i);
PNGEncoder encoder = new PNGEncoder(lineBmp, true);
byte[] data = null;
try {
data = encoder.encode(true);
} catch (IOException e) {
e.printStackTrace();
}
EncodedImage img = PNGEncodedImage.createEncodedImage(data,
0, -1);
float xScaleFactor = ((float) (inHeight / 2 + i))
/ (float) inHeight;
img = scaleImage(img, xScaleFactor, 1);
int startX = (inWidth - img.getScaledWidth()) / 2;
int imgHeight = img.getScaledHeight();
int imgWidth = img.getScaledWidth();
outBmpGraphics.drawImage(startX, i, imgWidth, imgHeight, img,
0, 0, 0);
}
return outBmp;
}

Entonces solo dibuja en pintura ()

protected void paint(Graphics graphics) {
graphics.drawBitmap(outDrawX, outDrawY, outWidth, outHeight, mOutBmp,
0, 0);
}

Para escalar, hago algo similar al método descrito en Cambiar el tamaño de un mapa de bits usando .scaleImage32 en lugar de .setScale

private EncodedImage scaleImage(EncodedImage image, float ratioX,
float ratioY) {
int currentWidthFixed32 = Fixed32.toFP(image.getWidth());
int currentHeightFixed32 = Fixed32.toFP(image.getHeight());
double w = (double) image.getWidth() * ratioX;
double h = (double) image.getHeight() * ratioY;
int width = (int) w;
int height = (int) h;
int requiredWidthFixed32 = Fixed32.toFP(width);
int requiredHeightFixed32 = Fixed32.toFP(height);
int scaleXFixed32 = Fixed32.div(currentWidthFixed32,
requiredWidthFixed32);
int scaleYFixed32 = Fixed32.div(currentHeightFixed32,
requiredHeightFixed32);
EncodedImage result = image.scaleImage32(scaleXFixed32, scaleYFixed32);
return result;
}

Ver también
J2ME Mode 7 Floor Renderer : ¡algo mucho más detallado y emocionante si escribes un juego en 3D!