OpenGL: Lote de Procesador: Debe Transformaciones tienen lugar en la CPU o la GPU?

0

Pregunta

Estoy desarrollando un juego en 2D motor que soporte 3D en el futuro. En esta fase actual de desarrollo, estoy trabajando en el lote procesador. Como algunos de ustedes saben, cuando la selección de lotes de gráficos juntos, el apoyo uniforme de color (RGBA), las coordenadas de textura, textura (textura índice), y la transformación del modelo de matriz de salir por la ventana, pero en su lugar pasa por el vértice de búfer. Ahora, me han implementado aprobar el modelo de las posiciones, color, coordenadas de textura, y la textura de IDENTIFICACIÓN para el vertex buffer. Mi vertex buffer formato mira como esta ahora:

float* v0 = {x, y, r, g, b, a, u, v, textureID};
float* v1 = {x, y, r, g, b, a, u, v, textureID};
float* v2 = {x, y, r, g, b, a, u, v, textureID};
float* v3 = {x, y, r, g, b, a, u, v, textureID};

Estoy a punto de integrar el cálculo en el que el objeto debe estar en el mundo espacio utilizando una matriz de transformación. Esto me lleva a una pregunta:

Debe la transformación de la matriz se multiplica por el modelo de vértice posiciones en la CPU o la GPU?

Algo a tener en cuenta es que si me pase el vertex buffer, tendría que subir la matriz de transformación una vez por cada vértice (4 veces por sprite) que me parece un desperdicio de memoria. Por otro lado, multiplicando el modelo de vértice posiciones de la matriz de transformación de la CPU parece que sería más lento en comparación con el GPU de la concurrencia de las capacidades.

Esta es la forma en que mi vertex buffer formato sería como si me calcular la transformación en la GPU:

float* v0 = {x, y, r, g, b, a, u, v, textureID, m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15};
float* v1 = {x, y, r, g, b, a, u, v, textureID, m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15};
float* v2 = {x, y, r, g, b, a, u, v, textureID, m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15};
float* v3 = {x, y, r, g, b, a, u, v, textureID, m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15};

La pregunta es en su mayoría teóricamente impulsados. Así, una teórica y técnica de la respuesta sería muy apreciada. Pero para referencia, aquí está el código.

c++ glm-math glsl opengl
2021-11-24 03:43:20
2

Mejor respuesta

1

Debe Transformaciones tienen lugar en la CPU o la GPU?

Realmente depende de la situación en la mano. Si vuelve a enviar los vértices de cada fotograma, lo mejor referencia de lo que es mejor para su caso. Si desea animar sin volver a enviar todos sus vértices, usted no tiene una elección, sino para aplicarlo en la GPU.

Cualquiera que sea la razón, si usted decide aplicar las transformaciones en la GPU, hay mejores maneras de hacer que otros de duplicar la matriz para cada vértice. Me gustaría que en lugar de poner las matrices de transformación en un SSBO:

layout(std430, binding=0) buffer Models {
    mat4 MV[]; // model-view matrices
};

y almacenar un único índice en cada vértice en el VAO:

struct Vert {
    float x, y, r, g, b, a, u, v;
    int textureID, model;
};

El vertex shader puede ir a buscarla a la matriz completa basado en el índice de atributo:

layout(location = 0) in vec4 in_pos;
layout(location = 1) in int in_model;
void main() {
    gl_Position = MV[in_model] * in_pos;
}

Usted puede incluso combinar con otros por los atributos de los objetos, como el textureID.

EDIT: se puede lograr algo similar con la creación de instancias y multi-sorteo. Aunque es probable que sea más lenta.

2021-11-24 17:20:51

Usted puede elaborar más sobre exactamente qué modelo sería? Estoy tratando de implementar y estoy consiguiendo solamente un sprite en la pantalla y creo que es porque no soy de enviar la información correcta.
Christopher Barrios Agosto

@ChristopherBarriosAgosto un índice de que el modelo de la matriz en el MV matriz: 0, 1, 2, etc...
Yakov Galka

Ya que son la representación de forma individual transformado quads, que será 0,0,0,0,1,1,1,1,2,2,2,2,... si el procesamiento con glDrawElements.
Yakov Galka

Me lo imaginé! Todo funciona ahora! Resulta que yo estaba pasando y la interpretación de los índices de derecho, pero me estaba pasando el índice como un flotador para GLSL cuando se esperaba un int. Me hizo recibir un flotador y en GLSL echó a un int y no es la interpretación de todos los índices de derecho. Tengo que hacerlo de esta manera porque el vertex buffer es de tipo float. Gracias por todo!
Christopher Barrios Agosto

@ChristopherBarriosAgosto: Felicitaciones que imaginé. 'vertex buffer es de tipo float' -- vertex buffers son secuencias de bytes. Usted puede almacenar structs allí con algunos int campos y algunos float campos.
Yakov Galka
0

No estoy seguro de cómo su código de motor en realidad se parece, pero supongo que se parece a cualquier otro programa de OpenGL.

Si es así, en mi experiencia, la transformación de la matriz por lo general debe ser aprobado para el vertex shader y aplicarse con el vértice de la información en la GPU al dibujar la escena. Por ejemplo:

//MVP matrix
GLuint MatrixID = glGetUniformLocation(shaderProgID, "MVP");
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &mvp[0][0]);

Pero si usted quiere encontrar el mundo de las coordenadas de todos los vértices de un grupo específico, fuera de la función de representación, usted probablemente tendrá que hacerlo de la CPU, o usted tendrá que utilizar algunas técnicas de programación paralela como OpenCL para hacer el trabajo en la GPU.

El más importante es, ¿por qué específicamente lo que usted quiere que el mundo coordenadas de información fuera el dibujo de procedimiento? Si usted simplemente quiere encontrar el modelo de coordenadas del mundo, usted puede simplemente establecer un centro de coordenadas para cada modelo tiene en la escena y la única pista que solo coordinar en lugar de todo el grupo de malla.

El vértice de la información debe ser siempre en el modelo de coordenadas y se almacena en el búfer de vértice sin tocar, a menos que usted desea aplicar alguna modificación en ellos.

2021-11-24 03:57:24

Estoy procesamiento por lotes de múltiples gráficos juntos. Por lo tanto, no puedo usar uniformes para pasar de los gráficos se transforma, porque no voy a ser capaz de cambiar el uniforme por la transformación entre la llamada de dibujo. Sin embargo, creo que con SSBOs es una muy buena alternativa.
Christopher Barrios Agosto

En otros idiomas

Esta página está en otros idiomas

Русский
..................................................................................................................
Italiano
..................................................................................................................
Polski
..................................................................................................................
Română
..................................................................................................................
한국어
..................................................................................................................
हिन्दी
..................................................................................................................
Français
..................................................................................................................
Türk
..................................................................................................................
Česk
..................................................................................................................
Português
..................................................................................................................
ไทย
..................................................................................................................
中文
..................................................................................................................
Slovenský
..................................................................................................................