OpenGl es 2.0 Geometry instancing

j'ai 170 objets à dessiner, chacun est construire à partir de 312 points.
J'ai un objet et je suis le dessin 170 fois avec diffrent martixes, j'ai compris que je n'ai pas besoin d'appeler certaines fonctions que si je tire un par un, j'appelle donc qu'au début, cela me donne environ 5fps, je suis en utilisant non indexées triangles avec drawArrays.

if(!started)
{
    glUseProgram( __programObject );
    glEnableVertexAttribArray(attPosition);
    glVertexAttribPointer(attPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), vVertices);//3*sizeof(float)
    glEnableVertexAttribArray(attNormals);
    glVertexAttribPointer(attNormals, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), vNormals);//3*sizeof(float)
}

Est-il un moyen de le rendre plus rapide dans es 2.0 ? je suis arriver sur 23fps sur sgx 540,
l'abaissement de vertex détail à 36 pour objet de ne pas augmenter le taux d'armature, il y a environ 10 im /s dans des calculs de matrice(à l'échelle, de la multiplier, de traduire, de transponse, inverser) mais elles sont faites sur le cpu et je ne pense pas que de les déplacer dans des shaders est une bonne idée. Je sais que la plupart du temps est consommé sur le passage des uniformes à chaque fois. Je sais qu'il existe un moyen pour instancier des objets et de passer des uniformes et de dessiner dans un appel, mais je ne peux pas le trouver n'importe tutoriel décrivant, savez-vous où je peux le trouver?

À l'aide d'un seul VBO avec les données entrelacés est censé les aider de manière significative. Certains Gpu préférez également une foulée de 16 ans.
Malheureusement, gl_ext_draw_instanced et gl_ext_instanced_arrays ne sont pas disponibles sur le SGX540, uniquement sur le SGX543, 544, 554 (ce qui est connu comme le 5XT de la série distinct le 5 de la série).

OriginalL'auteur ZZZ | 2011-04-25

  1. 3

    essayer de comprend par personne les normales et les sommets dans un tableau comme ceci:

    sqTex.getVertexBuffer().position(sqTex.VERT_OFFSET);
GLES20.glVertexAttribPointer(
                                GLES20.glGetAttribLocation(programTextured, "aPosition"), 3,
                                GLES20.GL_FLOAT, false, 5 * 4, sqTex.getVertexBuffer());
GLES20.glEnableVertexAttribArray(GLES20.glGetAttribLocation(programTextured, "aPosition"));

sqTex.getVertexBuffer().position(sqTex.TEXT_OFFSET);
GLES20.glVertexAttribPointer(
                                GLES20.glGetAttribLocation(programTextured, "aTextureCoord"), 2,
                                GLES20.GL_FLOAT, false, 5 * 4, sqTex.getVertexBuffer());
GLES20.glEnableVertexAttribArray(GLES20.glGetAttribLocation(programTextured, "aTextureCoord"));

    Dans cet exemple, j'ai un tableau de sommets et tex coords

    " d'OpenGL ES 2.0 Guide de Programmation:

     How to store different attributes of a vertex
We described the two most common ways of storing vertex attributes—
array of structures and structure of arrays. The question to ask is which allocation
method would be the most efficient for OpenGL ES 2.0 hardware
implementations. The answer is array of structures. The reason is that the
attribute data for each vertex can be read in sequential fashion and so will
most likely result in an efficient memory access pattern. A disadvantage of
using array of structures is when an application wants to modify specific
attributes. If a subset of vertex attribute data needs to be modified (e.g., texture
coordinates), this will result in strided updates to the vertex buffer.
When vertex buffer is supplied as a buffer object, the entire vertex attribute
buffer will need to be reloaded. One can avoid this inefficiency by storing
vertex attributes that are dynamic in nature in a separate buffer.

    Que le livre a aussi des exemples d'utilisation de cette manière

    Je suis de passage normales et les sommets qu'une seule fois au début, je pense que je peux passer à la normale et la position des matrices en une seule passe, il devrait être plus rapide un peu - > fait, changé gluniformmatrix3fv et 4fv pour la position et l'normale matrices de tableau de float passé que 7 vec4 et a obtenu les 28 et 29 fps maintenant . J'ai pensé à faire un gros vertex array pour tous les objets avec précalculées position et les normales.. je pense que je vais l'essayer.
    le problème des différents tableaux pour les vecteurs, c'est que le GPU doit sauter d'une memomy source à l'autre pour chaque vertex. il est des opérations supplémentaires. À mon humble avis
    J'ai lu un article à partir d'une Nvidia gars dit toujours utilisation entrelacés sommets et triangle-bande. En raison de cache. Ils ont énuméré quelques autres un autre raisons, mais la principale préoccupation était d'accès au cache. De toute façon je ne me souviens pas où j'ai vu que 🙁
    peut-être que c'est en fonction du matériel de conseils, n'est-ce pas? cependant nvidia est l'un des principaux
    Il n'y a rien en fonction du matériel à propos de linéarisation de données pour optimiser les performances du cache. Tout fois qu'un groupe d'instructions à exécuter sur plusieurs sources de données, il est conseillé d'intercaler des données pour l'amour de la localité de cache. Il est de bon conseil, même sur le CPU.

    OriginalL'auteur Yuriy Vikulov

  2. 1

    Vous pouvez essayer de passer votre par exemple des données par le biais d'attributs au lieu de l'uniforme. Il a aidé parfois sur le bureau OpenGL.

    Donc, vertex shader ressemblera à ceci:

    attribute vec3 position;
attribute mat4 proj_view_matrix;
void main()
{
    gl_Position = proj_view_matrix * position;
}

    Et le rendu du code ressemblera à ceci:

    glUseProgram( programObject );
glEnableVertexAttribArray(attPosition);
glVertexAttribPointer(attPosition, ..., pPositions);
glDisableVertexAttribArray(attProjViewMatrix+0);
glDisableVertexAttribArray(attProjViewMatrix+1);
glDisableVertexAttribArray(attProjViewMatrix+2);
glDisableVertexAttribArray(attProjViewMatrix+3);

foreach( instance )
{
    glVertexAttrib4fv(attProjViewMatrix+0, instance.proj_view_matrix.column0);
    glVertexAttrib4fv(attProjViewMatrix+1, instance.proj_view_matrix.column1);
    glVertexAttrib4fv(attProjViewMatrix+2, instance.proj_view_matrix.column2);
    glVertexAttrib4fv(attProjViewMatrix+3, instance.proj_view_matrix.column3);
    glDrawArrays( ... );
}

    OriginalL'auteur Sergey Khoroshavin