[OpenGL] Corruption avec glTexSubImage2D ?

Corruption avec glTexSubImage2D ? [OpenGL] - C - Programmation

Marsh Posté le 15-08-2006 à 09:14:41    

Bonjour à tous :hello:  
 
j'ai un blème avec le morceau de code ci-dessous. J'explique vite fait, l'intérêt n'est pas de comprendre le code mais de comprendre le problème : basiquement je propose deux méthodes pour dessiner des surfaces à l'écran, la plus simple charge la surface entière quelle que soit la portion qui nous intéresse ( SourceRectangle ) ( par ex. si on veut seulement afficher un rectangle 256x256 d'une surface 1024x1024 on chargera quand même entièrement la surface 1024x1024 ) puis dessine un seul quad et la seconde plus complexe divise la surface en plusieurs morceaux et colle plusieurs quads pour reformer le quad qu'on veut dessiner. Le rendu en utilisant la première méthode est nickel mais avec la seconde j'ai un petit problème de corruption plus ou moins aléatoire ( et ça scintille ) lorsque je dessine plusieurs rectangles de la même surface, ils se pompent les uns sur les autres comme on le voit bien sur ces captures :
 
http://moigeeknevro.com/wine/capture16.png
http://moigeeknevro.com/wine/capture17.png
 
Bon là encore c'est pas très embêtant, mais d'en d'autres cas c'est complètement illisible. La seconde méthode utilise en fait une "texture tampon" qu'on reremplit avec glTexSubImage2D à chaque fois qu'on dessine un nouveau morceau /ou une nouvelle portion ( suffit de jeter un coup d'oeil au code pour comprendre ). Ma question est : je suis assez nouveau en 3D, est-ce que glTexSubImage2D a besoin qu'on lui laisse le tampon ( ici bltBuffer ) pendant un certain temps ? J'ai essayé de placer des glFinish un peu partout pour voir mais ça n'a pas aidé. Quelqu'un qui connaît bien le fonctionnement de glTexSubImage2D et des drivers/matos ( j'ai le problème avec r200 dri et fglrx avec une 9250 sous Linux ) peut me dire ce qui ne va pas ?
 
edit : bon tout compte fait spa très clair tout ça je vais essayer de reproduire le problème avec un exemple plus simple :o  
 
edit 2 : ah ben en réalité la première méthode marche correctement avec fglrx [:croquignol] , je me suis démené pour rien

Code :
  1. if(splitDrawing) {
  2.     /* The trick is : we split the surface into 128x128,256x256,whatever
  3.         * squares then we draws multiple quads. This helps to upload and bind only
  4.         * needed portions of (especially full-dirty and/or full-screen) surfaces
  5.         * and also will someday take advantage of asynchronous texture uploads
  6.         * ( upload/draw the quad while we convert another portion ).
  7.         * NOTE: the quad size doesn't depend on the rectangle size because this will
  8.         * complexify the code and eat more memory without notable performance boost. */
  10.     /* TODO: There should be a reasonable balance between dirtyfying rate,
  11.         * surface/rect ratio and the drawing method.
  12.         * ( e.g when a surface is never dirtyfied and the rect is not too
  13.         * smaller than the surface size basic drawings should be at least as fast )
  14.         * For instance remember the blts count ( !! max one per frame ) performed
  15.         * since the last dirtyfying */
  16.     d3dfmt_get_conv(Src, (Flags & DDBLT_KEYSRC)?TRUE:FALSE, TRUE, &format, &internal, &type, &convert, &bpp);
  18.     /* Allocate the buffer */
  19.     if(Src->bltBuffer == NULL) /*FIXME: check bpp*/{
  20.         Src->bltBuffer = HeapAlloc(GetProcessHeap(), 0, QUAD_SIZE*QUAD_SIZE*bpp);
  21.         glGenTextures(1, &Src->bltBufferTextureName);
  22.         glBindTexture(GL_TEXTURE_2D, Src->bltBufferTextureName);
  23.         checkGLcall("glBindTexture" );
  24.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  25.         checkGLcall("glTexParameteri" );
  26.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  27.         checkGLcall("glTexParameteri" );
  28.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  29.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  30.         checkGLcall("glTexParameteri" );
  31.         glTexImage2D(GL_TEXTURE_2D, 0, internal,
  32.             QUAD_SIZE, QUAD_SIZE, 0,
  33.             format, type, NULL);
  34.         checkGLcall("glTexImage2D" );
  35.     }
  37.     /* FIXME: redundant.. */
  38.     glBindTexture(GL_TEXTURE_2D, Src->bltBufferTextureName);
  39.     checkGLcall("glBindTexture" );
  40. } else {
  41.     /* Now load the surface */
  42.     IWineD3DSurface_PreLoad((IWineD3DSurface *) Src);
  44.     /* Bind the texture */
  45.     glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName);
  46.     checkGLcall("glBindTexture" );
  48.     /* No filtering for blts */
  49.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  50.     checkGLcall("glTexParameteri" );
  51.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  52.     checkGLcall("glTexParameteri" );
  53.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  54.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  55.     checkGLcall("glTexParameteri" );
  56. }
  58. glColor3d(1.0f, 1.0f, 1.0f);
  60. if(splitDrawing) {
  61.     int x,y,i;
  62.     UINT pitch = IWineD3DSurface_GetPitch(SrcSurface);
  63.     int width, height;
  64.     float x_stretch, y_stretch;
  66.     width = SourceRectangle.right - SourceRectangle.left;
  67.     height = SourceRectangle.bottom - SourceRectangle.top;
  69.     x_stretch = (float) (rect.x2 - rect.x1) / (float) width;
  70.     y_stretch = (float) (rect.y2 - rect.y1) / (float) height;
  72.     glTexCoord[0] = 0.0;
  73.     glTexCoord[2] = 0.0;
  75.     glPixelStorei(GL_UNPACK_ROW_LENGTH, QUAD_SIZE);
  76.     checkGLcall("glPixelStorei" );
  78.     for (y = 0; y < height; y += QUAD_SIZE) {
  79.         UINT flush_height;
  80.         if(y + QUAD_SIZE > height) {
  81.             flush_height = height - y;
  82.             glTexCoord[3] = (float) flush_height / (float) QUAD_SIZE;
  83.         } else {
  84.             flush_height = QUAD_SIZE;
  85.             glTexCoord[3] = 1.0;
  86.         }
  88.         for (x = 0; x < width; x += QUAD_SIZE) {
  89.             UINT flush_width;
  90.             BYTE *srcRow = Src->resource.allocatedMemory + ((SourceRectangle.left+x)*bpp) + ((SourceRectangle.top+y)*pitch);
  92.             if(x + QUAD_SIZE > width) {
  93.                 flush_width = width - x;
  94.                 glTexCoord[1] = (float) flush_width / (float) QUAD_SIZE;
  95.             } else {
  96.                 flush_width = QUAD_SIZE;
  97.                 glTexCoord[1] = 1.0;
  98.             }
  100.             for (i = 0; i < flush_height; i++, srcRow += pitch) /* row by row */
  101.                 d3dfmt_convert_surface(srcRow, Src->bltBuffer + (i*QUAD_SIZE*bpp),
  102.                     flush_width, convert, Src);
  104.             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
  105.                 flush_width, flush_height,
  106.                 format, type, Src->bltBuffer);
  107.             checkGLcall("glTexSubImage2D" );
  109.             glBegin(GL_QUADS);
  110.             glTexCoord2f(glTexCoord[0], glTexCoord[2]);
  111.             glVertex3f(rect.x1 + (x * x_stretch),
  112.                     rect.y1 + (y * y_stretch),
  113.                     0.0);
  114.             glTexCoord2f(glTexCoord[0], glTexCoord[3]);
  115.             glVertex3f(rect.x1 + (x * x_stretch),
  116.                     rect.y1 + ((y + flush_height) * y_stretch),
  117.                     0.0);
  118.             glTexCoord2f(glTexCoord[1], glTexCoord[3]);
  119.             glVertex3f(rect.x1 + ((x + flush_width) * x_stretch),
  120.                     rect.y1 + ((y + flush_height) * y_stretch),
  121.                     0.0);
  122.             glTexCoord2f(glTexCoord[1], glTexCoord[2]);
  123.             glVertex3f(rect.x1 + ((x + flush_width) * x_stretch),
  124.                     rect.y1 + (y * y_stretch),
  125.                     0.0);
  126.             glEnd();
  127.             checkGLcall("glEnd" );
  128.         }
  129.     }
  130.     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  131.     checkGLcall("glPixelStorei" );
  132. } else {
  133.     /* Draw a textured quad */
  134.     glBegin(GL_QUADS);
  135.     glTexCoord2f(glTexCoord[0], glTexCoord[2]);
  136.     glVertex3f(rect.x1,
  137.             rect.y1,
  138.             0.0);
  140.     glTexCoord2f(glTexCoord[0], glTexCoord[3]);
  141.     glVertex3f(rect.x1, rect.y2, 0.0);
  143.     glTexCoord2f(glTexCoord[1], glTexCoord[3]);
  144.     glVertex3f(rect.x2,
  145.             rect.y2,
  146.             0.0);
  148.     glTexCoord2f(glTexCoord[1], glTexCoord[2]);
  149.     glVertex3f(rect.x2,
  150.             rect.y1,
  151.             0.0);
  152.     glEnd();
  153.     checkGLcall("glEnd" );
  154. }


Message édité par SuperDindon le 30-08-2006 à 07:00:33
Reply

Marsh Posté le 15-08-2006 à 09:14:41   

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed