¿Por qué FloatBuffer en lugar de float[]?

He estado usando FloatBuffers en mi código de Android por un tiempo (lo copié de un tutorial de Opengles), pero no puedo entender exactamente qué es esta construcción y por qué es necesaria.

Por ejemplo, este código (o similar) que veo en el código de muchas personas y en los tutoriales de Android:

float[] vertices = ...some array...

ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4); 
vbb.order(ByteOrder.nativeOrder());    // use the device hardware's native byte order
FloatBuffer fb = vbb.asFloatBuffer();  // create a floating point buffer from the ByteBuffer
fb.put(vertices);    // add the coordinates to the FloatBuffer
fb.position(0);      // set the buffer to read the first coordinate

Esto parece terriblemente detallado y desordenado para algo que, por lo que puedo decir, es solo un elegante envoltorio de una serie de flotadores.

Preguntas:

  • ¿Cuál es la justificación para este tipo de clase (ByteBuffer, FloatBuffer), a diferencia de cualquier otro tipo de colección o simple matriz de flotantes?

  • ¿Cuál es la idea detrás de crear un ByteBuffer antes de convertirlo en un FloatBuffer?

preguntado el 22 de mayo de 12 a las 07:05

2 Respuestas

La razón principal es el rendimiento: ByteBuffers y las otras clases de NIO permiten operaciones aceleradas cuando interactúan con código nativo (normalmente al evitar la necesidad de copiar datos en un búfer temporal).

Esto es bastante importante si está haciendo muchas llamadas de renderizado OpenGL, por ejemplo.

La razón para crear un ByteBuffer primero es que desea usar la llamada allocateDirect para crear un de reservas búfer de bytes, que se beneficia de las operaciones aceleradas. Luego crea un FloatBuffer a partir de esto que comparte la misma memoria. El FloatBuffer en sí mismo no tiene un método allocateDirect por alguna razón, razón por la cual tiene que ir a través de ByteBuffer.

contestado el 22 de mayo de 12 a las 08:05

Hacemos nuestra codificación en Java en Android, pero la implementación subyacente de OpenGL ES en realidad está escrita en C. Antes de pasar nuestros datos a OpenGL, debemos convertirlos en una forma que pueda entender. Es posible que Java y el sistema nativo no almacenen sus bytes en el mismo orden, por lo que usamos un conjunto especial de clases de búfer y creamos un ByteBuffer lo suficientemente grande como para contener nuestros datos y le indicamos que almacene sus datos usando el orden de bytes nativo. Luego lo convertimos en un FloatBuffer para que podamos usarlo para almacenar datos de coma flotante. Finalmente, copiamos nuestra matriz en el búfer.

Respondido 24 ago 12, 10:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.