Problème de performances bsp quake 3

**drcd** · 24/11/2009, 15h29

Bonjour à tous,

J'ai codé, une classe permettant de charger et d'afficher les fichiers bsp de quake 3. En faisant des tests avec Irrlicht, je me suis apercu que ma classe était à la ramasse comparé à ce que fait Irrlicht avec DirectX. Bien entendu la comparaison a été effectué sur la même map et le point de vue de la caméra était le même, le tout compilé en release.

Résultat des tests:

Irrlicht configuré pour DX9: 54 FPS
Irrlicht configuré pour OpenGL: 13 FPS
Ma classe utilisant OpenGL: 13 FPS

Nombre de triangles: environ 7000.

Je sais, vous allez me dire que mes perfs sont pas si mal lorsqu'on compare les perfs de ma classe à celle d'Irrlicht en mode OpenGL. Mais ca ne me convient pas. De plus, comment expliquer un tel écart et avec si peu de triangles? Et quelles pourraient être les méthodes pour remédier au problème?
Je me suis penché sur l'occlusion culling, mais j'ai peur que ce ne soit utiliser un bazooka pour faire du tir aux pigeons. Qu'en pensez vous?

Les chiffres du dessus ont été produit avec une carte graphique Intel Q965 Express Chipset Familly et permettent d'expliquer en partie que j'ai si peu de FPS. Cepedant, la plupart de mes développements se font sur un NVIDIA 8800 GTS et j'obtient des résultats similaire au regard des pertes de FPS entre Irrlicht configuré pour DX9 et ma classe OpenGL (30 FPS au lieu de 13 sur la 8800).

Merci.

**Mat.M** · 24/11/2009, 15h43

Salut je ne comprends pas comment tu obtiens autant de différence en FPS avec Irrlicht rendu Open GL et Irrlicht rendu Direct X.
Quand j'exécute les exemples fournis avec Irrlicht la différence entre Dx8,DX8 et Open GL est quasi nulle..
Même les exemples de Irrlicht.NET ( et pourtant j'ai souvent été détracteur de C# et .NET

) sont tout aussi performants..
donc c'est que tu as des device drivers pour Open GL qui ne sont pas à jour.
Sinon si tu utilises un BSP et que tu as des pertes de performances c'est que l'algorithme que tu utilises pour le BSP est mal optimisé.
Ceci dit rien ne prouve que l'utilisation d'un BSP accroisse les performances parce que les cartes graphiques utilisent le procédé du Z-buffer et possèdent sans doute leur propre implémentation d'algorithme tri de faces cachées.

J'ai le livre de Alan Sherrod "Ultimate Direct X Game Programming" et il dit que ce n'est pas forcément nécessaire d'avoir recours à un BSP voire même cela risque d'alourdir les traitements.
Je peux essayer de retrouver le texte...

**drcd** · 24/11/2009, 17h12

Envoyé par Mat.M

Salut je ne comprends pas comment tu obtiens autant de différence en FPS avec Irrlicht rendu Open GL et Irrlicht rendu Direct X.
Quand j'exécute les exemples fournis avec Irrlicht la différence entre Dx8,DX8 et Open GL est quasi nulle..
Même les exemples de Irrlicht.NET ( et pourtant j'ai souvent été détracteur de C# et .NET

) sont tout aussi performants..
donc c'est que tu as des device drivers pour Open GL qui ne sont pas à jour.

Je viens de faire les tests suivants:

- Exécution du binaire fourni et déjà compilé de l'exemple fourni Quake3Map:
- OpenGL : environ 200 FPS
- DirectX : environ 200 FPS

- Compilation puis exécution du même exemple à partir du fichier source d'exemple:
- OpenGL : environ 70 FPS
- DirectX : environ 200 FPS

Heu... je crois que il y a un soucis.

Pourrais tu essayer de compiler puis d'exécuter cet exemple et me donner les résultats? Ça me parait intéressant.

Envoyé par Mat.M

Sinon si tu utilises un BSP et que tu as des pertes de performances c'est que l'algorithme que tu utilises pour le BSP est mal optimisé.

Dans ce cas, comment puis-je repérer le goulot d'étranglement?

Pour moi, une partie des performances d'un bsp repose sur la façon dont la géométrie est faite. La map fourni avec l'exemple d'Irrlicht est parfaite pour faire fonctionner le BSP . Quelque soit la position ou on se trouve dans la map, à un instant t, on ne voit que très peu de géométrie. En revanche, si on considère une map composée de plein de formes arrondi et qui dispose d'un point ou l'on peut voir une grande partie de la géométrie, on risque d'avoir de sérieux ralentissements lorsqu'on se balade aux environs de cette position(je suis d'ailleurs dans ce cas).

Envoyé par Mat.M

J'ai le livre de Alan Sherrod "Ultimate Direct X Game Programming" et il dit que ce n'est pas forcément nécessaire d'avoir recours à un BSP voire même cela risque d'alourdir les traitements.
Je peux essayer de retrouver le texte...

Merci c'est gentil mais laisse tomber. Je ne vais pas te faire perdre du temps à chercher ce texte.

**Mat.M** · 24/11/2009, 18h04

Salut,
bon eh bien effectivement Open GL semble moins performante que Direct X

Testé avec Irrlicht 0.7 ( c'est une vieille version )
Ce sont les exemples binaires de la distributions d'Irrlicht

Carte ATI Radeon HD 4670

Exemple 02.Quake3Map.exe

D3D8 -> ~780FPS
D3D9 -> ~780FPS
Open GL 1.2 -> ~615 FPS
Software Renderer -> ~715 FPS
Attention ce sont des valeurs moyennes

Exemple 08.SpecialFx.exe
D3d9 ->entre 600 et 800 FPS
Open GL ->1.2 ~720 FPS

Exemple QuakeMap recompilé avec Visual Studio 2008

Open GL 1.2-> ~530 FPS
D3D8 -> ~780 FPS
D3D9 -> ~780 FPS

Dans ce cas, comment puis-je repérer le goulot d'étranglement?

Cela dépend des opérations effectuées lors du rendu , je dirais.
Si à chaque render() tu fais des appels récursifs comme pour l'exemple suivant
http://www.codesampler.com/dx9src/dx..._solidnode_bsp
cela risque de diminuer les performances d'affichage...
dans son exemple de code l'auteur fait appel à walkBspTree( ) dans la fonction de rendu..
donc le CPU va travailler pour recalculer l'arbre BSP et la carte graphique elle pendant ce temps-là attendra.
Moralité il faudrait que tu programmes éventuellement le GPU en HLSL éventuellement..

Merci c'est gentil mais laisse tomber. Je ne vais pas te faire perdre du temps à chercher ce texte.

In the beginning of 3D video games a BSP tree was an efficient way to
render the polygons of a scene in the correct order before the Z-buffer became
standard in graphics hardware. Using a BSP tree for rendering in
the manner of early games is less efficient than using the Z-buffer. However,
BSP trees can be used for fast collision detection and, with the addition
of potential visibility sets, which are discussed later in this chapter,
for large-scale culling and fast rendering.

Rendering without using potential visibility sets and the Z-buffer with front-to-back
rendering is less efficient than using them in combination. Many games today use
BSP trees with potential visibility tests and the Z-buffer to quickly render a scene.

**dridri85** · 24/11/2009, 22h30

Essayer avec la version 1.2 d'OpenGL n'est pas très parlant, il faut au moins utiliser la version 2.0 pour parler d'équivalence avec D3D9.

Personnellement je suis passé à OpenGL3 et il est franchement plus performant (pas plus rapide mais plus modulable, ce qui fait qu'on ne perd pas trop de FPS en alourdissant le programme). Mais d'ailleurs la dernière beta d'Irrlitch gère OGL3 non ?

**drcd** · 25/11/2009, 10h59

Envoyé par Mat.M

Cela dépend des opérations effectuées lors du rendu , je dirais.
Si à chaque render() tu fais des appels récursifs comme pour l'exemple suivant
http://www.codesampler.com/dx9src/dx..._solidnode_bsp
cela risque de diminuer les performances d'affichage...
dans son exemple de code l'auteur fait appel à walkBspTree( ) dans la fonction de rendu..
donc le CPU va travailler pour recalculer l'arbre BSP et la carte graphique elle pendant ce temps-là attendra.
Moralité il faudrait que tu programmes éventuellement le GPU en HLSL éventuellement..

Je ne fais pas des choses comme ca. Grosso modo, voici ce que je fais en pseudo code:

Debut de la boucle de jeu
- Update du frustrum de la camera
- Calcul des faces visibles en se basant sur leur boundingbox
- Affichage des faces visibles
Fin de la boucle de jeu

Le code complet maintenant:

Boucle de jeu:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
void GameLoop(void)
{
    Map.CamPos.x=GSECamera->GetPositionX();
    Map.CamPos.y=GSECamera->GetPositionY();
    Map.CamPos.z=GSECamera->GetPositionZ();
 
    Map.frustum.Update();
 
    glPushAttrib(GL_TEXTURE_BIT);
    glEnable(GL_TEXTURE_2D);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glActiveTextureARB(GL_TEXTURE1_ARB);
    glEnable(GL_TEXTURE_2D);
 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
 
    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
 
    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
 
    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
 
    glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f);
 
    glActiveTextureARB(GL_TEXTURE0_ARB);
 
    Map.CalculateVisibleFaces(Map.CamPos, Map.frustum);
    Map.Draw();
 
    glPopAttrib();
}

Code de Map.frustum.Update():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
void FRUSTUM::Update()
{
    MATRIX4X4 projection, view;
    MATRIX4X4 clip;
 
    //get matrices
    glGetFloatv(GL_PROJECTION_MATRIX, projection);
    glGetFloatv(GL_MODELVIEW_MATRIX, view);
 
    //Multiply the matrices
    clip=projection*view;
 
    //calculate planes
    planes[RIGHT_PLANE].normal.x=clip.entries[3]-clip.entries[0];
    planes[RIGHT_PLANE].normal.y=clip.entries[7]-clip.entries[4];
    planes[RIGHT_PLANE].normal.z=clip.entries[11]-clip.entries[8];
    planes[RIGHT_PLANE].intercept=clip.entries[15]-clip.entries[12];
 
    planes[LEFT_PLANE].normal.x=clip.entries[3]+clip.entries[0];
    planes[LEFT_PLANE].normal.y=clip.entries[7]+clip.entries[4];
    planes[LEFT_PLANE].normal.z=clip.entries[11]+clip.entries[8];
    planes[LEFT_PLANE].intercept=clip.entries[15]+clip.entries[12];
 
    planes[BOTTOM_PLANE].normal.x=clip.entries[3]+clip.entries[1];
    planes[BOTTOM_PLANE].normal.y=clip.entries[7]+clip.entries[5];
    planes[BOTTOM_PLANE].normal.z=clip.entries[11]+clip.entries[9];
    planes[BOTTOM_PLANE].intercept=clip.entries[15]+clip.entries[13];
 
    planes[TOP_PLANE].normal.x=clip.entries[3]-clip.entries[1];
    planes[TOP_PLANE].normal.y=clip.entries[7]-clip.entries[5];
    planes[TOP_PLANE].normal.z=clip.entries[11]-clip.entries[9];
    planes[TOP_PLANE].intercept=clip.entries[15]-clip.entries[13];
 
    planes[FAR_PLANE].normal.x=clip.entries[3]-clip.entries[2];
    planes[FAR_PLANE].normal.y=clip.entries[7]-clip.entries[6];
    planes[FAR_PLANE].normal.z=clip.entries[11]-clip.entries[10];
    planes[FAR_PLANE].intercept=clip.entries[15]-clip.entries[14];
 
    planes[NEAR_PLANE].normal.x=clip.entries[3]+clip.entries[2];
    planes[NEAR_PLANE].normal.y=clip.entries[7]+clip.entries[6];
    planes[NEAR_PLANE].normal.z=clip.entries[11]+clip.entries[10];
    planes[NEAR_PLANE].intercept=clip.entries[15]+clip.entries[14];
 
    //normalize planes
    for(int i=0; i<_NB_PLANE; ++i)
        planes[i].Normalize();
}

Code de Map.CalculateVisibleFaces(Map.CamPos, Map.frustum):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
void BSP::CalculateVisibleFaces(const POINT3D & cameraPosition, FRUSTUM frustum)
{
    //Clear the list of faces drawn
    facesToDraw.ClearAll();
 
    //calculate the camera leaf
    int cameraLeaf=CalculateCameraLeaf(cameraPosition);
    int cameraCluster=leaves[cameraLeaf].cluster;
 
    //loop through the leaves
    for(int i=0; i<numLeaves; ++i)
    {
        //if the leaf is not in the PVS, continue
        if(!isClusterVisible(cameraCluster, leaves[i].cluster))
            continue;
 
        //if this leaf does not lie in the frustum, continue
        if(!frustum.IsBoundingBoxInside(leaves[i].boundingBoxVertices))
            continue;
 
        //loop through faces in this leaf and mark them to be drawn
        for(int j=0; j<leaves[i].numFaces; ++j)
        {
            facesToDraw.Set(leafFaces[leaves[i].firstLeafFace+j]);
        }
    }
}

Code de isClusterVisible(cameraCluster, leaves[i].cluster):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
//See if one cluster is visible from another
int BSP::isClusterVisible(int cameraCluster, int testCluster)
{
    int index=	cameraCluster*visibilityData.bytesPerCluster + testCluster/8;
 
    int returnValue=visibilityData.bitset[index] & (1<<(testCluster & 7));
 
    return returnValue;
}

Code de frustum.IsBoundingBoxInside(leaves[i].boundingBoxVertices):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
//is a bounding box in the frustum?
bool FRUSTUM::IsBoundingBoxInside(const POINT3D * vertices)
{
    //loop through planes
    for(int i=0; i<_NB_PLANE; ++i)
    {
        //if a point is not behind this plane, try next plane
        if(planes[i].ClassifyPoint(vertices[0])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[1])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[2])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[3])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[4])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[5])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[6])!=POINT_BEHIND_PLANE)
            continue;
        if(planes[i].ClassifyPoint(vertices[7])!=POINT_BEHIND_PLANE)
            continue;
 
        //All vertices of the box are behind this plane
            return false;
    }
 
    return true;
}

Code de Map.Draw():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
//Draw all faces marked as visible
void BSP::Draw()
{
    //UpdateDrawing();
    glFrontFace(GL_CW);
 
    //enable vertex arrays
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    glClientActiveTextureARB(GL_TEXTURE1_ARB);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
    nbTrianglesDrawn=0;
 
    //loop through faces
    for(int i=0; i<numTotalFaces; ++i)
    {
        //if this face is to be drawn, draw it
        if(facesToDraw.IsSet(i))
        {
            DrawFace(i);
        }
    }
 
    //disable vertex arrays
    glClientActiveTextureARB(GL_TEXTURE1_ARB);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);
 
    glFrontFace(GL_CCW);
}

Code de DrawFace(i):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
//Draw a face
void BSP::DrawFace(int faceNumber)
{
    //look this face up in the face directory
    if(faceDirectory[faceNumber].faceType==0)
        return;
 
    if(faceDirectory[faceNumber].faceType==bspPolygonFace)
    {
        //Dessine la map sans les voutes
        DrawPolygonFace(faceDirectory[faceNumber].typeFaceNumber);
    }
 
    if(faceDirectory[faceNumber].faceType==bspMeshFace)
    {
        //Dessine les objets(lampes)
        DrawMeshFace(faceDirectory[faceNumber].typeFaceNumber);
    }
 
    if(faceDirectory[faceNumber].faceType==bspPatch)
    {
        //Dessine les trucs arondi
        DrawPatch(faceDirectory[faceNumber].typeFaceNumber);
    }
}

Code de DrawPolygonFace(faceDirectory[faceNumber].typeFaceNumber):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
//Draw a polygon face
void BSP::DrawPolygonFace(int polygonFaceNumber)
{
    //skip this face if its texture was not loaded
 
if(isTextureLoaded[polygonFaces[polygonFaceNumber].textureIndex]==false)
		return;
 
    //set array pointers
    glVertexPointer(	3, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].position);
 
    //Unit 0 - decal textures
    glTexCoordPointer(	2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].decalS);
 
    //Unit 1 - Lightmaps
    glClientActiveTextureARB(GL_TEXTURE1_ARB);
    glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].lightmapS);
    glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
 
    //bind textures
    //unit 0 - decal texture
    glBindTexture(GL_TEXTURE_2D, decalTextures[polygonFaces[polygonFaceNumber].textureIndex]);
 
    //unit 1 - lightmap
    glActiveTextureARB(GL_TEXTURE1_ARB);
    if(polygonFaces[polygonFaceNumber].lightmapIndex>=0)	//only bind a lightmap if one exists
        glBindTexture(	GL_TEXTURE_2D,
						lightmapTextures[polygonFaces[polygonFaceNumber].lightmapIndex]);
    else
        glBindTexture(GL_TEXTURE_2D, whiteTexture);
    glActiveTextureARB(GL_TEXTURE0_ARB);
 
    //Draw face
    glDrawArrays(	GL_TRIANGLE_FAN, polygonFaces[polygonFaceNumber].firstVertexIndex,
									 polygonFaces[polygonFaceNumber].numVertices);
 
    int nbT=polygonFaces[polygonFaceNumber].numVertices-2;
 
    if(nbT>0)
    {
        nbTrianglesDrawn+=nbT;
    }
}

Code de DrawMeshFace(faceDirectory[faceNumber].typeFaceNumber):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
//Draw a mesh face
void BSP::DrawMeshFace(int meshFaceNumber)
{
    //skip this face if its texture was not loaded
    if(isTextureLoaded[meshFaces[meshFaceNumber].textureIndex]==false)
        return;
 
    //set array pointers
    glVertexPointer(	3, GL_FLOAT, sizeof(BSP_VERTEX),
						&vertices[meshFaces[meshFaceNumber].firstVertexIndex].position);
    glTexCoordPointer(	2, GL_FLOAT, sizeof(BSP_VERTEX),
						&vertices[meshFaces[meshFaceNumber].firstVertexIndex].decalS);
 
    glClientActiveTextureARB(GL_TEXTURE1_ARB);
    glTexCoordPointer(	2, GL_FLOAT, sizeof(BSP_VERTEX),
						&vertices[meshFaces[meshFaceNumber].firstVertexIndex].lightmapS);
    glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(GL_GREATER, 0.0f);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    //bind textures
    //unit 0 - decal texture
    glBindTexture(GL_TEXTURE_2D, decalTextures[meshFaces[meshFaceNumber].textureIndex]);
 
    //unit 1 - lightmap
    glActiveTextureARB(GL_TEXTURE1_ARB);
    if(meshFaces[meshFaceNumber].lightmapIndex>=0)	//only bind a lightmap if one exists
        glBindTexture(GL_TEXTURE_2D, lightmapTextures[meshFaces[meshFaceNumber].lightmapIndex]);
    else
        glBindTexture(GL_TEXTURE_2D, whiteTexture);
    glActiveTextureARB(GL_TEXTURE0_ARB);
 
 
    //draw the face, using meshIndices
    if(!EXT_draw_range_elements_supported)
    {
        glDrawElements(	GL_TRIANGLES, meshFaces[meshFaceNumber].numMeshIndices, GL_UNSIGNED_INT,
						&meshIndices[meshFaces[meshFaceNumber].firstMeshIndex]);
    }
    else
    {
        glDrawRangeElementsEXT(	GL_TRIANGLES, 0, meshFaces[meshFaceNumber].numVertices,
								meshFaces[meshFaceNumber].numMeshIndices, GL_UNSIGNED_INT,
								&meshIndices[meshFaces[meshFaceNumber].firstMeshIndex]);
    }
 
    int nbT=meshFaces[meshFaceNumber].numMeshIndices/2.0;
 
    if(nbT>0)
    {
        nbTrianglesDrawn+=nbT;
    }
 
    glDisable(GL_BLEND);
    glDisable(GL_ALPHA_TEST);
}

Code de DrawPatch(faceDirectory[faceNumber].typeFaceNumber):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
//Draw a patch
void BSP::DrawPatch(int patchNumber)
{
    //skip this patch if its texture was not loaded
    if(isTextureLoaded[patches[patchNumber].textureIndex]==false)
        return;
 
    //bind textures
    //unit 0 - decal texture
    glBindTexture(GL_TEXTURE_2D, decalTextures[patches[patchNumber].textureIndex]);
 
    //unit 1 - lightmap
    glActiveTextureARB(GL_TEXTURE1_ARB);
    if(patches[patchNumber].lightmapIndex>=0)	//only bind a lightmap if one exists
        glBindTexture(GL_TEXTURE_2D, lightmapTextures[patches[patchNumber].lightmapIndex]);
    else
        glBindTexture(GL_TEXTURE_2D, whiteTexture);
    glActiveTextureARB(GL_TEXTURE0_ARB);
 
    for(int i=0; i<patches[patchNumber].numQuadraticPatches; ++i)
        patches[patchNumber].quadraticPatches[i].Draw();
}

Et enfin le code de patches[patchNumber].quadraticPatches[i].Draw():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
//Draw a biquadratic patch
void BSP_BIQUADRATIC_PATCH::Draw()
{
    //set array pointers
    glVertexPointer(3, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].position);
 
    glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].decalS);
 
    glClientActiveTextureARB(GL_TEXTURE1_ARB);
    glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].lightmapS);
    glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
    //Draw a triangle strip for each row
    if(!EXT_multi_draw_arrays_supported)
    {
        for(int row=0; row<tesselation; ++row)
        {
            glDrawElements(	GL_TRIANGLE_STRIP, 2*(tesselation+1), GL_UNSIGNED_INT,
							&indices[row*2*(tesselation+1)]);
        }
    }
    else
    {
        glMultiDrawElementsEXT(	GL_TRIANGLE_STRIP, trianglesPerRow,
								GL_UNSIGNED_INT, (const void **)rowIndexPointers,
								tesselation);
    }							
}

Je n'ai aucun appel récursif dans mon code et je pense utiliser des fonctions suffisamment rapide pour afficher la géométrie. Donc j'ai mis le code parce que je ne vois pas quel partie pourrait poser problème, donc si vous voyez quelque chose n'hésitez pas.

Je ne vois pas bien à quoi servirai que je fasse un shader pour augmenter les performances?

Envoyé par dridri85

Mais d'ailleurs la dernière beta d'Irrlitch gère OGL3 non ?

Je ne sais pas si elle supporte OGL 3 mais en tout cas c'est pas encore le cas pour moi lol.

**bafman** · 25/11/2009, 11h55

pour la difference entre la version compilé avec visual et la version fournis, tu peut essayer en faisant :
Project properties | Configuration Properties | Debugging | Environment
<- mettre : "_NO_DEBUG_HEAP=1"

ça permet d'éviter d'utiliser le tas en mode débug, ce qui est le cas quand on lance sous visual mais n'est pas le cas quand on lance un exe

Problème de performances bsp quake 3

OpenGL

Vue hybride

Discussions similaires

Partager

Partager