the effects of textures on my frame rate

Well, this is my 2nd attempt at writing this post because an error happened the 1st time, so grrr...makes me mad...oh well...Here goes...

Many of you know I am working on a Battletech game, very similar to that of Mechwarrior.

Lately, however, I have come upon a severe bottleneck in my game, and having tried everything I know of, am unable to fix it. Hence I have conducted a series of tests in order to gather data and then present it before you to see if you can give me any help with my problem I have here.

Here is the basics of the problem: I have my terrain engine. It ran run in two modes: textured and non-textured. When I run it with no textures, I get a frame rate of about 30 fps. When I run it with textures applied, my frame rate drops to about 7 fps.

Now, to explain the problem further in depth, I will give you some background about my engine:

I have a "map" which is composed of the terrain that all the units move on, obviously.

The map is composed of a unit which I call a "hex" (short for hexagon...each piece of the map is a hexagon). The plural is "hexes." So when you see me say hex in this post, I mean a spot on the map, NOT hexidecimal.

The map is a matrix of hexes. The size is specified by the programmer and the data for the map is loaded in from a file. Right now I am running a map of 30x20 hexes.

I have 3 textures loaded into memory right now. One is called GRASS, one is called HILL, and one is called WATER. When I load in the height map, textures are automatically applied to each hex.

All hexes with a height less than or equal to 0 receive a water texture. All hexes with a height between 0 and 2 (non-inclusive) receive a grass texture, and all hexes with a height of 2 or greater receive a hill texture.

The programmer can choose whether to actually use the textures or not, but nevertheless, each hex is assigned its texture, and the textures are loaded into memory.

Each texture is a 64x64 pixel 24-bit bitmap.

That is basically all the info on how I store my map in memory. Now I will show you some code...

Before you jump to any conclusions, do not tell me to use display lists to boosts my frame rate. I have already tried them.

The following code is my function to initialize OpenGL. Remember that this function is only called once, so it has no factor whatsoever in my frame rate, but it might give some useful information for all of you:

Code:

---

void setup_opengl( int width, int height )
{
    float ratio = (float) width / (float) height;

        //Texture Mapping Initialization       
        InitTextureNames ( );
        LoadGLTextures();                // Texture Loading Routine
        BuildFont();
        glEnable(GL_TEXTURE_2D);// Enable Texture Mapping
       

    /* Our shading model--Gouraud (smooth). */
    glShadeModel( GL_SMOOTH );

    /* Set the clear color. */
    glClearColor( 0, 0, 0, 0 );

    /* Setup our viewport. */
    glViewport( 0, 0, width, height );

    /*
    * Change to the projection matrix and set
    * our viewing volume.
    */
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );

    gluPerspective( 60.0, ratio, 1.0, 1024.0 );


//Create a map of 20x30 hexes of 1 radius each.
//Set the base elavation of the map to -1.0 on the y-axis.
//Load and apply the height map.
//Apply the default terrain colors for when textures are not used.
//Enable texture mapping, and create a display lists for the map.
        myMap = new HEXMAP_DTP( 20, 30, 1.0f );
        myMap->SetBase ( 0.0f, -1.0f, 0.0f );
        myMap->LoadHeightMap ( "heightmap.dat" );
        myMap->HeightMap( );
        myMap->ApplyDefaultTerrainColors();
        myMap->EnableTextureMapping ( true );
        myMap->CreateHexDisplayLists ( );

        glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
}

---

I hope that function is pretty clear and straight forward. If there is any confusion about my code, ask me and I will explain a part of it.

Here is the next function. This function is my draw function and gets called on every frame:

Code:

---

static void draw_screen( void )
{   

        GLfloat xtrans = -xpos;
        GLfloat ztrans = -zpos;               
        movy -= ypos;
        GLfloat sceneroty = 360.0f - yrot;

    /* Clear the color and depth buffers. */
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    /* We don't want to modify the projection matrix. */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );

        glRotatef(sceneroty,0,1.0f,0);
        glTranslatef(xtrans, movy, ztrans);

//Draw the map...obviously. 
        myMap->DrawMap();       


//This function is for printing text onto the screen.
        CyclePrintBuffer ( );

    /*
    * Swap the buffers. This this tells the driver to
    * render the next frame from the contents of the
    * back-buffer, and to set all rendering operations
    * to occur on what was the front-buffer.
    *
    * Double buffering prevents nasty visual tearing
    * from the application drawing on areas of the
    * screen that are being updated at the same time.
    */


    SDL_GL_SwapBuffers( );

        movy += ypos;
       
}

---

There are some variables in that function that are global variables and declared elsewhere in my code. Just have confidence that they HAVE been decalared. ;-)

Anyways, I will show you one more function. This is the function where an individual hex is actually drawn onto the screen. Keep in mind that although I am using display lists for the drawing, I have omitted them in this post for the sake that you can see all of the code. This function is called DrawHexTextured(), and is called by the DrawMap() function as the map class draws every hex in the map. The code is identical to the code that draws the map with no-textures, except that this code contains code for textures :-) :

Code:

---

void HEX_DTP::DrawHexTextured ( )
{
        //Find out which texture to use
        if ( level <= 0 )
                glBindTexture ( GL_TEXTURE_2D, texture[WATER] );
        else if ( level >= 2 )
                glBindTexture ( GL_TEXTURE_2D, texture[HILL] );
        else
                glBindTexture ( GL_TEXTURE_2D, texture[GRASS] );

        //account for elevation change at center of hex
        v[1] += level;

        //radius, x1, z1, and other variables are declared in the class declaration
        //they are also defined by other functions and by the class constructor
        //create outer vertexes of hexagon
        float vertex[6][3] =
        {
                { v[0] - radius,        v[1] - ElevationMod[0],                v[2] },
                { v[0] - x1,                v[1] - ElevationMod[1],                v[2] - z1 },
                { v[0] + x1,                v[1] - ElevationMod[2],                v[2] - z1 },
                { v[0] + radius,        v[1] - ElevationMod[3],                v[2] },
                { v[0] + x1,                v[1] - ElevationMod[4],                v[2] + z1 },
                { v[0] - x1,                v[1] - ElevationMod[5],                v[2] + z1 }
        };


        glBegin ( GL_TRIANGLES );               
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[0][0], vertex[0][1], vertex[0][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[1][0], vertex[1][1], vertex[1][2] );
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[1][0], vertex[1][1], vertex[1][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[2][0], vertex[2][1], vertex[2][2] );
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[2][0], vertex[2][1], vertex[2][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[3][0], vertex[3][1], vertex[3][2] );
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[3][0], vertex[3][1], vertex[3][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[4][0], vertex[4][1], vertex[4][2] );
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[4][0], vertex[4][1], vertex[4][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[5][0], vertex[5][1], vertex[5][2] );               
       
                glTexCoord2f(0.0f, 0.0f);
                        glVertex3f ( v[0], v[1], v[2] );       
                glTexCoord2f(1.0f, 0.0f);
                        glVertex3f ( vertex[5][0], vertex[5][1], vertex[5][2] );
                glTexCoord2f(1.0f, 1.0f);
                        glVertex3f ( vertex[0][0], vertex[0][1], vertex[0][2] );

        glEnd ( );

        v[1] -= level;
}

---

Okay, that should be all code relevant to the problem. If you would like to see any other code, just tell me and I will post it, however I think this should suffice.

If you see anything that could be causing my extreme bottleneck, please tell me. I have tried quite a bit to get this thing to go faster, but nothing seems to work.

I just don't understand why 3 small textures alone could be dropping my frame rate from 30 fps to 7 fps.

So any help is appreciated.

If I have left any information out of this post I apologize. Ask and ye shall receive.

I will post you a picture of the UNTEXTURED version of the terrain engine so you can get a feel for what it looks like. Notice the clear distinction between each hexagon on the map. It is supposed to be like that:

You ever tried profiling you rprogram to see where it is slowing down?

i know where its slowing down. its slowing down whenever I enable texture mapping. So its something dealing with those textures. Everything else runs at desired speeds.

glBindtexture is one of the most expensive calls you can make, so doing it once for every hex that can be seen is the problem.

you should not bind if the correct texture is alreay bound, and you should sort everything so that you only have to bind each texture 1 time and draw everything that needs that texture at that time.

Oh and Hi by the way, remember talking to me on IM's years ago, i admire your perserverance, you were working on this way back then.


Also in your init, you change to GL_PROJECTION, and never change back to GL_MODELVIEW

thanks.

Yeah I was really wondering how much that glBindTexture was taxing my frame rate.

Right now I currently just do a for loop and go through and draw each hex one by one.

I will change that and draw each hex by elevation. That way I will only have to bind each texture one time.

Thanks for that info, ebar kain! (hopefully now my frame rate will boost)

okay this is what I have done:

acting on Eber Kain's advice, I created three arrays of pointers:

WaterHex, GrassHex, and HillHex

Each array is composed of elements that point to hexes in the HexMap.

Now, here is how I implement these arrays:

Code:

---

void HEXMAP_DTP::LoadHeightMap ( char *fileName )
{
        ifstream load ( fileName );
        float level;

        for ( int y = 0; y < numY; y++ )
        {
                for ( int x = 0; x < numX; x++ )
                {
                        load >> level;
                        HexMap[x][y].SetLevel ( level );


                        if ( level <= 0 ) {
                                WaterHex.resize ( WaterHex.length() + 1 );
                                WaterHex [ WaterHex.length() - 1 ] = &HexMap[x][y];
                        }
                        else if ( level >= 2 )
                        {
                                HillHex.resize ( HillHex.length() + 1 );
                                HillHex [ HillHex.length() - 1 ] = &HexMap[x][y];
                        }
                        else {
                                GrassHex.resize ( GrassHex.length() + 1 );
                                GrassHex [ GrassHex.length() - 1 ] = &HexMap[x][y];
                        }
                }
        }

       

        load.close();
}

---

So as I load in the height map, I store the height in the proper location in HexMap (thats my matrix of hexes that compose my map).

I then look at the elevation I just loaded in from the file. Depending on what the elevation is, I make a new element in the proper array point to that corresponding hex in the map.

Therefore each array points to its corresponding elements. The WaterHex array points to all hexes in the map that are water, the GrassHex array points to all grass hexes, and the HillHex array points to all hexes of a "high" elevation.

Then this is how I draw now:

Code:

---

void HEXMAP_DTP::DrawMap ( void )
{
        int x;

        glBindTexture ( GL_TEXTURE_2D, texture [WATER] );               
        for ( x = 0; x < WaterHex.length(); x++ )
        {
                if ( textureMapEnabled )
                        WaterHex[x]->DrawHexTextured ( );
                else
                        WaterHex[x]->DrawHex();
        }

        glBindTexture ( GL_TEXTURE_2D, texture [GRASS] );               
        for ( x = 0; x < GrassHex.length(); x++ )
        {
                if ( textureMapEnabled )
                        GrassHex[x]->DrawHexTextured ( );
                else
                        GrassHex[x]->DrawHex();
        }

        glBindTexture ( GL_TEXTURE_2D, texture [HILL] );               
        for ( x = 0; x < HillHex.length(); x++ )
        {
                if ( textureMapEnabled )
                        HillHex[x]->DrawHexTextured ( );
                else
                        HillHex[x]->DrawHex();
        }
}

---

So I bind the texture for water, and then I draw all water hexes. Then I bind the texture for grass, and draw all grass hexes.
Then I bind the texture for hills, and draw all hill hexes.

I also deleted ALL glBindTexture code from my DrawHexTextured() code...i made sure its all gone.

So now I only bind a texture 3 times every frame. Before I took eber kain's advice i was binding textures about 600 times a frame.

However, I'm sorry to say, this has not boosted my frame rate one bit.

If I have done something wrong, point it out...but to the best of my knowledge I have implemented what Eber Kain said to do in a correct manner.

I know many people might have used a matrix instead of 3 arrays, but technically all rows of a matrix should be the same length when you resize a matrix, so I chose 3 arrays because all of them are almost definitely going to be different lengths (since there is more of one terrain type than another). Many people would have also chosen a linked list, but I felt 3 resizable arrays was easier to maintain.

So, now, any suggestions? flames? comments? persecutions? stonings? lol

Some quick stats:

Average time in milliseconds it takes to draw one frame textured: 135

Average time in milliseconds it takes to draw one frame untextured: 32

I dont see anything else that is an obvious slowdown...

how bad of a frame rate drop are we talking about?
and what are your system specs?

what type of *culling* (not clipping) do you do?

Well, we know that it slows down when you use textures. But... it seems like it's always slow - that scene was NOT complex. You aren't trying to run this on an abbacus, are you?

Anyway, seriously, USE a profiler. The profiler built into MSVC will tell you how many times each function is called, how much time was spent in each call, and how much total time was spent in each function. I think it sorts them in order of time, too. Soo.... if you do that, you'll be able to determine which functions are taking the most time, and narrow down the problem. Do it. Profilers are a great tool.

I did not have culling enabled for those tests. The reason is when I have culling enabled I have problems. Here is the culling code, it sits inside the setup_opengl() function that gets called at the beginning of the function:

glFrontFace( GL_CCW );
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );

Yes, culling does about double my frame rate, however, here is a picture of what it looks like when I use culling (this is the TEXTURED version). Compare it to my picture of when I don't use culling (the picture of me not using culling is in my first post and does not use textures):

Okay, I change it from Counter-Clockwise culling to Clock-wise culling, so now it is:

glFrontFace( GL_CW );
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );

This does culling properly so things that are supposed to be seen are seen, and other things are not. However now my frame rate has dropped yet again, not quite to what it was, but its not great.

Frame rate with no culling: 7
Frame rate with CCW culling: 18 (doesnt look right)
Frame rate with CW culling: 10

>and what are your system specs?

my system specs are:

GeForce 2 vid card, 64 MB
384 MB Ram
AMD Athlon XP 1800+ processor
40 GB hd

so the system specs are fine...

okay confuted...I did profiled, here are the results:

I ran the program for about 10 seconds (9.787 to be exact).

The function times were (in milliseconds):

Code:

---

      Func          Func+Child          Hit
        Time  %        Time      %      Count  Function
---------------------------------------------------------
    7292.425  75.0    7292.425  75.0    43200 HEX_DTP::DrawHexTextured(void) (main.obj)
    1942.619  20.0    1942.619  20.0      71 _SDL_GL_SwapBuffers (sdl.dll)
    172.387  1.8      172.387  1.8      144 _SDL_PollEvent (sdl.dll)
    116.901  1.2      116.901  1.2        2 _SDL_Init (sdl.dll)
      58.283  0.6      67.226  0.7        1 HEXMAP_DTP::HEXMAP_DTP(int,int,float) (main.obj)
      39.686  0.4      39.686  0.4        1 _SDL_SetVideoMode (sdl.dll)
      16.453  0.2      16.453  0.2      600 HEX_DTP::CreateDisplayList(void) (main.obj)
      13.584  0.1      13.584  0.1      600 HEX_DTP::CreateTexturedDisplayList(void) (main.obj)
      12.685  0.1      12.685  0.1        2 _SDL_Quit (sdl.dll)
      7.943  0.1        7.943  0.1    10736 apvector<class apvector<class HEX_DTP> >::operator[](int) (main.obj)
      7.579  0.1        7.579  0.1      180 glPrint(int,int,char *,int) (main.obj)
      6.727  0.1        6.727  0.1        5 LoadBMP(char *) (main.obj)
      5.675  0.1    9251.162  95.1      71 draw_screen(void) (main.obj)
      5.390  0.1        6.168  0.1        1 HEXMAP_DTP::LoadHeightMap(char *) (main.obj)
      4.443  0.0    7294.680  75.0      71 HEXMAP_DTP::DrawMap(void) (main.obj)
      3.153  0.0        8.658  0.1        1 HEXMAP_DTP::HeightMap(void) (main.obj)
      2.878  0.0        2.878  0.0    7788 HEX_DTP::GetLevel(void) (main.obj)
      2.870  0.0    9710.727  99.8        1 _SDL_main (main.obj)
      2.740  0.0        2.740  0.0        1 BuildFont(void) (main.obj)
      2.691  0.0        9.420  0.1        1 LoadGLTextures(void) (main.obj)
      2.649  0.0        2.649  0.0      600 HEX_DTP::SetRadius(float) (main.obj)
      0.973  0.0        0.973  0.0        1 _cleanup_output (sdl_main.obj)
      0.761  0.0    9725.205 100.0        1 _WinMain@16 (sdl_main.obj)
      0.515  0.0        8.094  0.1      71 CyclePrintBuffer(void) (main.obj)
      0.417  0.0        0.417  0.0    6276 apvector<class HEX_DTP>::operator[](int) (main.obj)
      0.406  0.0        0.406  0.0    6272 apmatrix<class HEX_DTP>::operator[](int) (main.obj)
      0.363  0.0      32.718  0.3        1 HEXMAP_DTP::CreateHexDisplayLists(void) (main.obj)
      0.338  0.0        0.338  0.0      600 HEX_DTP::SetLevel(float) (main.obj)
      0.256  0.0        0.256  0.0      640 operator delete(void *) (delop_s.obj)
      0.230  0.0        0.568  0.0        1 HEXMAP_DTP::ApplyDefaultTerrainColors(void) (main.obj)
      0.133  0.0        0.133  0.0      600 HEX_DTP::HEX_DTP(void) (main.obj)
      0.119  0.0        0.119  0.0    1140 HEX_DTP::SetRGB(float,float,float) (main.obj)
      0.118  0.0        0.254  0.0      20 apvector<class HEX_DTP>::resize(int) (main.obj)
      0.106  0.0        0.106  0.0      71 HandleMovement(void) (main.obj)
      0.100  0.0        0.123  0.0      60 apvector<class HEX_DTP *>::resize(int) (main.obj)
      0.094  0.0        0.094  0.0      71 _SDL_GetTicks (sdl.dll)
      0.092  0.0      127.618  1.3        1 setup_opengl(int,int) (main.obj)
      0.092  0.0        0.092  0.0    1140 HEX_DTP::SetOuterRGB(float,float,float) (main.obj)
      0.066  0.0        0.066  0.0        1 _$E27 (main.obj)
      0.049  0.0        0.049  0.0      600 HEX_DTP::GetZ(void) (main.obj)
      0.047  0.0        0.047  0.0      600 HEX_DTP::GetX(void) (main.obj)
      0.046  0.0        0.046  0.0      600 HEX_DTP::GetRadius(void) (main.obj)
      0.044  0.0        0.044  0.0      601 HEXMAP_DTP::SetBase(float,float,float) (main.obj)
      0.044  0.0        0.044  0.0      601 HEX_DTP::SetPosition(float,float,float) (main.obj)
      0.035  0.0        0.035  0.0      600 HEX_DTP::GetY(void) (main.obj)
      0.023  0.0        0.023  0.0      320 HEX_DTP::SetElevationMod(int,float) (main.obj)
      0.015  0.0        0.015  0.0        1 _$E22 (main.obj)
      0.015  0.0        0.015  0.0        1 _$E23 (main.obj)
      0.015  0.0    9724.442 100.0        1 _main (sdl_main.obj)
      0.012  0.0        0.016  0.0        1 apvector<class apstring>::resize(int) (main.obj)
      0.009  0.0        0.009  0.0        1 _$E20 (main.obj)
      0.006  0.0        0.006  0.0      64 apvector<class HEX_DTP *>::operator[](int) (main.obj)
      0.005  0.0        0.071  0.0        1 _$E30 (main.obj)
      0.005  0.0        0.010  0.0        5 apstring::operator=(char const *) (main.obj)
      0.005  0.0        0.005  0.0        3 Print(char *,int,int,int,int) (main.obj)
      0.004  0.0        0.007  0.0        1 apvector<class apvector<class HEX_DTP> >::resize(int) (main.obj)
      0.004  0.0        0.004  0.0        5 apstring::apstring(void) (main.obj)
      0.003  0.0        0.008  0.0        1 _$E56 (main.obj)
      0.003  0.0        0.005  0.0        1 _$E53 (main.obj)
      0.003  0.0        0.003  0.0        5 _SDL_GL_SetAttribute (sdl.dll)
      0.002  0.0        0.002  0.0        1 _SDL_EnableKeyRepeat (sdl.dll)
      0.002  0.0        0.002  0.0        1 apvector<class apvector<class HEX_DTP> >::apvector<class apvector<class HEX_DTP> >(int) (main.obj)
      0.002  0.0        0.002  0.0        2 LImporter::Clear(void) (l3ds.obj)
      0.002  0.0        0.002  0.0        2 _ParseCommandLine (sdl_main.obj)
      0.002  0.0        0.002  0.0        5 apstring::c_str(void) (main.obj)
      0.002  0.0        0.008  0.0        1 _$E18 (main.obj)
      0.001  0.0        0.004  0.0        1 _$E54 (main.obj)
      0.001  0.0        0.006  0.0        5 apstring::~apstring(void) (main.obj)
      0.001  0.0        0.027  0.0        1 InitTextureNames(void) (main.obj)
      0.001  0.0        0.003  0.0        1 LImporter::~LImporter(void) (l3ds.obj)
      0.001  0.0        0.001  0.0      20 apvector<class HEX_DTP>::apvector<class HEX_DTP>(void) (main.obj)
      0.001  0.0        0.002  0.0        1 LImporter::LImporter(void) (l3ds.obj)
      0.001  0.0        0.016  0.0        1 _$E25 (main.obj)
      0.001  0.0        0.002  0.0        1 _$E28 (main.obj)
      0.000  0.0        0.000  0.0        1 HEXMAP_DTP::EnableTextureMapping(bool) (main.obj)
      0.000  0.0        0.000  0.0        1 _$E17 (main.obj)
      0.000  0.0        0.000  0.0        1 _SDL_SetModuleHandle (sdl.dll)
      0.000  0.0        0.000  0.0        1 L3DS::L3DS(void) (l3ds.obj)
      0.000  0.0        0.000  0.0        1 L3DS::~L3DS(void) (l3ds.obj)
      0.000  0.0        0.000  0.0        1 _$E19 (main.obj)
      0.000  0.0        0.000  0.0        1 _$E24 (main.obj)
      0.000  0.0        0.000  0.0        1 _$E29 (main.obj)
      0.000  0.0        0.000  0.0        1 _$E55 (main.obj)
      0.000  0.0        0.000  0.0        1 apqueue<struct PrintBufferUnit>::apqueue<struct PrintBufferUnit>(void) (main.obj)
      0.000  0.0        0.000  0.0        1 apqueue<struct PrintBufferUnit>::~apqueue<struct PrintBufferUnit>(void) (main.obj)

---

So on average it is drawing a textured hex in 5.92 miliseconds.

can you upload your profile.dll david?

i tried but the attatch file feature on this board only allows you to upload picture files.

(thats what it told me)

So I will upload it to my website:

http://www33.brinkster.com/cyfallshs/

I assume you are talking about the one in the Visual C++ BIN directory?

Quote:

---

The daily bandwidth limit for this customer has been exceeded. Try again after midnight, EST.
Click here for more information.

---

also, about the question I've asked twice so far, what type of culling are you doing? Drawing your hexes is taking 75% of the time according to the profiler. Therefore you need to implement some sort of culling to cut down what is drawn, otherwise I doubt there is hope. You can't just 'draw everything at once'. Most of what is being drawn isn't even visible, but OpenGL still has to perform calculations on it and that takes time. Also, you have too many if statements in your drawing routine, believe it or not that's hurting performance too. What I'd do is compile every type of hex into its own list and render them separately without having to ask what type it is.

Trade memory for speed whenever possible just as long as it takes up only a reasonable amount of mem.


EDIT: taking into account I haven't seen your entire engine, so there might still be something wrong, but I believe the problem is ultimately going to involve you not having culling. You need some type of partitioned world. BSP typically isn't best for terrain, octree is best for terrain but i don't know of any octree compilers. Or, I can show you how to split polygons and you can perform your own simple compiler, whcih I don't recommend because writing a robust comiler for maps is probably the most difficult aspect of game programming, period

EDIT1: and when I say culling I don't mean back face culling, and to be honest I dont necessarily mean frustum culling. I use frustum culling and potential visibility sets but to be honest I think it (frustum culling) is a waste. Quake3 doesn't even do frustum culling, it uses potential visibility sets, and that's the most effective form of culling that there is. What I'm getting around to saying is use quake3 bsp format, there are terrain generation plugins for that.

>about the question I've asked twice so far

I have already answered your question on culling. Look up above my post about profiling. It is all there.

no no no no no! Im not talking about back face culling! I'm talking about frustum culling!! You don't do frustum culling!!

EDIT: you might believe your scene is simple but you are actually sending more polygons to the rendering pipeline than quake3 does, this is because you are trying to draw everything off to the side and behind you that you cannot ever possibly see.

to put it simply,

Are you drawing every single polygon no matter if they are on the screen or off the screen?

If you are then thats the problem. I just assumed that you made checks to only draw the poys that could be seen.

well but that's jsut it he's generating this terrain, it isn't generated from a compiler program such as Q3Radiant or Worldcraft or any modelling program that can partition (even Lightwave can partition into a BSP).

As long as the data for the terrain is stored is some sort of relational order then you could write an algoritham that would only draw what could be seen.

*slaps forehead*

good luck

I still promote just using a partitioning program, then the only check you have to do is a potential visibility set and or a frustum check

kain no offense but that's pretty impractical, I'd like to see someone actually do it (i.e have you done it?)

>I'm talking about frustum culling!!

dont got a clue on what frustum culling is...

>you might believe your scene is simple but you are actually sending more polygons to the rendering pipeline than quake3 does

i highly doubt that...my entire scene is only 3600 polygons. A GeForce 2 is able to render 25 million polygons per second...

>I still promote just using a partitioning program

bah...im using all my own code...

I don't know what to think right now. Can you go online and send me the code? i will set you up with my ftp, my aim is
OpenGLProgrammer. It looks like the msvc profiler only profiles entire functions (but i still cannot use the profiler), but what i want to do is profile each part of the drawtexturedhex function and see exactly what part is taking long, then I'll be able to solve the problem, but I'm done guessing at what 'could' be wrong.

Yes I have. Its just some basic trig to calculate if the poly can be seen. In my terrain engine, each polygon of the terrain is represented with an instance of a class, then there is an array of linked lists, one for each texture.

To draw the terrain I go through and dump pointers to all the polys that can be seen from the cameras current position into the linked list depending on which texture they have. Then the program runs through all the linked lists, binding a texture once per list, it draws a poly from the pointer and at the same time removes that pointer from that list.

Technically they are linked lists, but you could get the same functionality out of a stack.

And before you say doing all that is too slow, remember that mostly your just throwing around pointers and that is very inexpensive. The technique is called a bucket sort if your intrested.

trig? I hope you don't mean calling trig functions...because those aren't exactly fast...and when you come right down to it no matter how much you argue with me there isn't anything more robust than pre compiled potential visibility sets and or frustum culling, period. I mean, frustum tests are just dotproducts, and you'll find that whenever you can narrow a problem down to just dot products it will be much faster than having to make nasty calls to sqrt and the trig functions. I mean obviously there's some amount of sqrting and triging that must be done, but if you are calling trig functions trying to determine real time if each polygon is visibile then it seems like a waste.

>>and when you come right down to it no matter how much you argue with me there isn't anything more robust than pre compiled potential visibility sets and or frustum culling<<

correction: yet. Personally, I bet that there IS a better way to do it.

well i had a long involved reply, but i screwed it up so im gonna try a shorter one, some of this has already been covered i know!

first it seems to me that something this simple would run better than 30 fps in software on an athlon 1800, are you sure your getting HW acceleration,

second, avoid calls to glBind, glEnable/Disable, and you dont need to change the the matrix mode to modelview unless its been changed to something else.

Get backface culling working!!!! make sure all your tri's are drawing either CW or CCW they should all be drawing one or the other, try setting the front face to CW and see if the other polys show.

try using a 32 bpp bitmap, instead, see if that helps.

lastly your only using triangle's right!??!

so dont call glBegin in every call to DrawHexTextured()! only call it when you need to, like when you change textures.

Code:

---

void HEXMAP_DTP::DrawMap ( void )
{
        int x;

        glBindTexture ( GL_TEXTURE_2D, texture [WATER] );       
        glBegin();
        for ( x = 0; x < WaterHex.length(); x++ )
        {
                if ( textureMapEnabled )
                        WaterHex[x]->DrawHexTextured ( );
                else
                        WaterHex[x]->DrawHex();
        }

                glEnd();

        glBindTexture ( GL_TEXTURE_2D, texture [GRASS] );
        glBegin();
                // etc...
}

---

remove the glBegin and glEnd from DrawHexTextured().

my bet is getting the culling working will be the biggest help!

also what is you texture setup code??

no-one: thanks for the input. It did not GREATLY increase my frame rate, however, your suggestion increased both textured and non-textured mode by about 2 frames per second.

>also what is you texture setup code??

here is my texture setup code:

Code:

---

enum TEXTURE_TYPE
{
        WATER,
        GRASS,
        HILL,       
        TEXT,
        TEXT_BUMP,
        NUM_TEXTURES
};

GLuint        texture                [NUM_TEXTURES];                // Storage for textures
apvector <apstring> TextureName;

void InitTextureNames ( void )
{
        TextureName.resize ( NUM_TEXTURES );
        TextureName[0] = "water.bmp";
        TextureName[1] = "grass.bmp";
        TextureName[2] = "hill.bmp";
        TextureName[3] = "Font.bmp";
        TextureName[4] = "Bumps.bmp";
}


AUX_RGBImageRec *LoadBMP ( char *Filename )                                // Loads A Bitmap Image
{
        FILE *File=NULL;                                                                        // File Handle

        if (!Filename)                                                                                // Make Sure A Filename Was Given
        {
                return NULL;                                                                        // If Not Return NULL
        }

        File=fopen(Filename,"r");                                                        // Check To See If The File Exists

        if (File)                                                                                        // Does The File Exist?
        {
                fclose(File);                                                                        // Close The Handle
                return auxDIBImageLoad(Filename);                                // Load The Bitmap And Return A Pointer
        }

        return NULL;                                                                                // If Load Failed Return NULL
}

int LoadGLTextures()                                                                        // Load Bitmaps And Convert To Textures
{
        int Status=FALSE;                                                                        // Status Indicator

        AUX_RGBImageRec *TextureImage[NUM_TEXTURES];                                        // Create Storage Space For The Texture

        memset(TextureImage,0,sizeof(void *)*NUM_TEXTURES);                  // Set The Pointer To NULL

        // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
        for ( int x = 0; x < NUM_TEXTURES; x++ )
        {
                if ( TextureImage[x] = LoadBMP( (char *)TextureName[x].c_str() ) )
                {
                        Status=TRUE;                                                                        // Set The Status To TRUE

                        glGenTextures(1, &texture[x]);                                        // Create The Texture

                        // Typical Texture Generation Using Data From The Bitmap
                        glBindTexture(GL_TEXTURE_2D, texture[x]);
                        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[x]->sizeX, TextureImage[x]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[x]->data);
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
                }
       
                if (TextureImage[x])                                                                        // If Texture Exists
                {
                        if (TextureImage[x]->data)                                                        // If Texture Image Exists
                        {
                                free(TextureImage[x]->data);                                        // Free The Texture Image Memory
                        }
                        free(TextureImage[x]);                                                                // Free The Image Structure
                }
        }
        return Status;                                                                                // Return The Status
}

---

well, the only thing i can figure, is your doing something insane each frame or your running totally or partially in software...

just checking on preformance, i had about 4k+ polys 2 textures 512x512x32 with a single light totally unoptimized preliminary draw code, i.e. calls glBind every frame, no back face culling, and it ran around 135 fps, on ad P3 750 with a Radeon 7200(ancient)!!

so, turn off al HW acceleration on the graphics card and see how fast it runs,

in case you don't know it can be done like so,

right click on your desktop->properties->settings tab->advanced->troubleshoot tab->move the silder all the way to the left to turn off all HW accelertion,
just remember to reverse this setting when your done.

One new development:

I gave my program to a friend of mine to run on his computer. I do not know all the stats of his computer, but I do know this:

It is a laptop with integrated video

His laptop got 120 fps running my engine. (textured)

Here are some other statistics:

My engine running on another friend's computer: 60 fps (textured)
His comp stats: 1.1 Ghz Athlon, 512 MB ATI Rage Pro II+, 128 MB Ram

My engine running on another friend's computer: between 200 and 500 fps (yes those are correct numbers)
His comp stats: 1.8ghz amd, 512mb of pc3200, radeon 9800, nf2 chipset

Another friend: 60 fps
his stats: 2400+ AMD Athlon, other stats unknown

Check your video card settings.

PROBLEM SOLVED:

My frame rate is now: 60 fps (with textures)

That was the weirdest freakin thing in the world....

Seriously...

When I built this computer I installed the AGP drivers that came with the motherboard, but not my video card drivers.

After playing a few games I thought I didn't need to. All my games got GREAT frame rates. (Warcraft 3 included).

But for some reason MY project WASNT getting great frame rates. So I decided to install my vid card drivers today and boom my frame rates skyrocket....

Isnt that just so freakin gay....

>>Isnt that just so freakin gay....
No, it's common sense ;)

Sorry, I just had to say that :D

Quote:

---

Isnt that just so freakin gay....

---

The OS thinks you are gay for not giving it the driver it needs to fully tap your graphics card capabilities.

Quote:

---

Sorry, I just had to say that

---

Okay, first of all, let's get back to basics (ie, what is performance really about)-- I won't $$$$$, but this is what I've been trying to tell you all for years about understanding how your machine works.

I'm gonna address a few items, by no means all, but these alone will create dramatic improvements in performance in this code:

1) Work with 8-bit textures, not 24. This is by far the biggest time saver. In a game, the eye cannot distinguish 24-bit color sufficiently to make it useful. At best, don't go more than 16-bit. The fact that you are moving 3 bytes per pixel per frame, is INCREDIBLE the amount of work that is creating.

2) Don't waste time clearing buffers-- just put new data in them. It's faster. Remember the golden rule: Touch each pixel only once per frame.

3) Do not do a lot of testing (if's, fors, etc.) in your frame drawing-- tests are expensive in terms of time.

4) do not use local variables in your frame drawing code-- use globals, and registers where you can. Everytime you enter a function that gets and returns parameters, the system has to spend precious time setting up a stack frame. Don't waste that time.

5) Don't use functions where you don' t have to-- recode the item as a macro-- this eliminates stack-time altogether.

6) Don't use ints, and bytes for holding numbers, use the largest native word-size you can. This way, the processor doesn't have to waste time masking memory to work with just a few bits. In a 32-bit processor, you would use an unsigned long. I don't care if you're just counting to 8, use an unsigned long. It's not about the value the number will hold, it's how the processor handles it.

7) Put everything in memory so you aren't hitting the disk.

8) precalculate all your data so it's just sitting there, waiting to be displayed. Don't waste time manipulating data, if you can trade RAM for speed. Use the RAM instead of manipulation (ie. Store more data, even if redundant, if it's faster to access, rather than so, rotating a bitmap 90 degrees or whatever).

-----

Remember:

1) DON'T work with more data than you have to
2) DON'T do more work than you have to per pixel
3) DON'T do more work than you have to per frame

To get performance you trade one of two things (all are resources to you): You trade RAM for speed, or you trade code for speed.

For example:

The two fastest methods to swap the bits in a byte, end for end, come down to trading one resource or another for speed. In this case, You can use a table (uses RAM), or you can eliminate your loop and use more lines of nearly identical code-- one line for each bit being swapped)-- (uses code size).

enjoy.

>>recode the item as a macro
Just thought I would point out, inline functions are supposed to be just about the same speed :)

ah, but there's no guarantee of inlining, macro's always work.

Ah right, my bad. Although if you're using MSVC you can use __forceinline :D