Esta es mi primera publicación aquí, por lo tanto, pido disculpas por los errores.
Estoy desarrollando un juego de acción simple con el uso de OpenGL ES 2.0 y Android 2.3. Mi marco de juego en el que estoy trabajando actualmente se basa en sprites bidimensionales que existen en el mundo tridimensional. Por supuesto, mis entidades mundiales poseen información como posición dentro del mundo imaginario, valor de rotación en forma de matriz flotante [], manejador de textura OpenGL y manejador de mapa de bits de Android (no estoy seguro si esto último es necesario ya que estoy haciendo la rasterización con el uso de la máquina OpenGl, pero por el momento está allí, para mi conveniencia). Este es brevemente el trasfondo, ahora al problema problemático.
Actualmente estoy atascado con la detección de colisiones basada en píxeles, ya que no estoy seguro de qué objeto (aquí textura OGL, o mapa de bits de Android) necesito muestrear. Quiero decir, ya he intentado probar el mapa de bits de Android, pero no funcionó por completo para mí: muchos bloqueos en tiempo de ejecución en relación con la lectura fuera del mapa de bits. Por supuesto, para poder leer los píxeles del mapa de bits, he usado el método Bitmap.create para obtener un sprite rotado correctamente. He aquí el fragmento de código:
Problema de detección de colisiones basado en píxeles con OpenGLES 2.0 en Android
android.graphics.Matrix m = new android.graphics.Matrix();
if(o1.angle != 0.0f) {
m.setRotate(o1.angle);
b1 = Bitmap.createBitmap(b1, 0, 0, b1.getWidth(), b1.getHeight(), m, false);
}
Otra cuestión, lo que podría agravar el problema, o incluso ser el principal problema, es que mi rectángulo de intersección (rectángulo indicando espacio bidimensional mutuo para ambos objetos) es la acumulación a partir de partes de dos cuadros delimitadores que se calcularon con el uso de matrices OpenGL funcionalidad Matrix.multiplyMV (código a continuación). ¿Podría ser que esos dos métodos de cálculo de matrices de Android y OpenGL no son iguales?
Matrix.rotateM(mtxRotate, 0, -angle, 0, 0, 1);
// original bitmap size, equal to sprite size in it's model space,
// as well as in world's space
float[] rect = new float[] {
origRect.left, origRect.top, 0.0f, 1.0f,
origRect.right, origRect.top, 0.0f, 1.0f,
origRect.left, origRect.bottom, 0.0f, 1.0f,
origRect.right, origRect.bottom, 0.0f, 1.0f
};
android.opengl.Matrix.multiplyMV(rect, 0, mtxRotate, 0, rect, 0);
android.opengl.Matrix.multiplyMV(rect, 4, mtxRotate, 0, rect, 4);
android.opengl.Matrix.multiplyMV(rect, 8, mtxRotate, 0, rect, 8);
android.opengl.Matrix.multiplyMV(rect, 12, mtxRotate, 0, rect, 12);
// computation of object's bounding box (it is necessary as object has been
// rotated second ago and now it's bounding rectangle doesn't match it's host
float left = rect[0];
float top = rect[1];
float right = rect[0];
float bottom = rect[1];
for(int i = 4; i < 16; i += 4) {
left = Math.min(left, rect[i]);
top = Math.max(top, rect[i+1]);
right = Math.max(right, rect[i]);
bottom = Math.min(bottom, rect[i+1]);
};
En general, OpenGL es * solo * para gráficos. No debe permitir que toque las coordenadas de su juego/mundo, excepto para hacer una * copia * transformada de ellas para su presentación en la pantalla. Esto significa que cualquier cuadro delimitador que tenga debe calcularse con su propio código. Y tenga cuidado con los sistemas de física basados en píxeles :) Suena como una buena idea para todo, hasta que lo pruebe y descubra que es solo una buena idea para los elementos que no interactúan físicamente (cualquier elemento que desaparece cuando lo toca, como una bala o artículo recogido, o si mueres instantáneamente cuando te tocan). –
Gracias por esa respuesta. El resultado que quería lograr es tener una mejor colisión que la basada en círculos y cuadros.Esto es probablemente cierto que las colisiones de píxeles no son lo suficientemente buenas ya que son computacionalmente costosas. Sill recientemente leí sobre algo llamado 'formas convexas' y probablemente las use para aumentar el comportamiento de mi sistema de colisión. – cplusogl
La advertencia sobre el píxel fue sobre todo porque jugué con ella, implementé una función de oscilación para un viejo juego de plataformas de estilo escolar, y descubrió que no se sentía bien. La complejidad computacional se puede reducir enormemente con las técnicas correctas (inicialmente colisión con AABB, posiblemente reducida mediante información de particiones espaciales como un sistema de cuadrícula o cuadrícula dinámica, luego use máscaras de colisión especiales de blanco y negro, y pruebe solo la superposición). Las formas convexas son definitivamente una buena manera de hacerlo, y te permitirán sustituir el arte 3d en un juego con solo 2d interacciones. –