Sign in to follow this  
ioda

slow rendering with ATI

Recommended Posts

When i draw triangles like this with classic light : glEnable(GL_TEXTURE_2D); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(3, GL_DOUBLE, 0, pt_ptsGL); glNormalPointer(GL_DOUBLE, 0, pt_normalsGL); glTexCoordPointer(2, GL_DOUBLE, 0, pTexGL); for(int i = 0; i < nb_triangles_reels; i++) { glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, pt_triangles[i].vertexIndices); } glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); It's ok with Nvidia Graphic card but it's very slow with ATI card (9700 last drivers). And when i use shader by adding these lines, it's still ok with Nvidia card and it's ok too for ATI card (very much faster then without shader) shader_object.glUseProgramObjectARB(shader_object.g_programObjTex); shader_object.SetShaderConstantsTexture(Ka, Kd, Ks, nspecular, ambientProperties, diffuseProperties, specularProperties, light_pos); shader_object.SetShaderTexture(texture[0]); ...code higher if (shader_active == TRUE) shader_object.glUseProgramObjectARB(NULL); Anyone has an idea of why with simple light it's so slow with ATI card? Thx

Share this post


Link to post
Share on other sites
more out of intrest than anything else, why on earth are you using GL_DOUBLE for the data? They arent even remotely native to the GPU, GL_FLOAT is the prefered and advised data type. My guess is that under the fixed function pipeline you've fallen off the accelerated path on the 9700 and yet the shader does something to either cover it up or help in some way

oh, and just a polite note for future reference, 3hours isnt that long in the life of the msg board, so before bumping wait a little longer please [smile]

Share this post


Link to post
Share on other sites
Its definitely the GL_DOUBLE. A while ago I was using GL_FLOAT for sending color data to my ATI 9800 and I was getting horrible frame rates. So I switched to GL_UNSIGNED_BYTE and the framerate went up by about 50x. I'm not sure why, probably a driver problem, but it worked.

Share this post


Link to post
Share on other sites
you've changed all the double code to floats, yes?
colours are the only thing you should send down as unsigned bytes (and even then you need to send rgba to keep it properly aligned).

How many triangles are you sending per batch?
Which NV card are you testing on?
What other states are active?
What format is the texture in?
Are you mipmaping the texture at all?
What are you doing with teh z-buffer?
What format is your triangle data in? (strip'd list? raw random triangles?)

Share this post


Link to post
Share on other sites
ATI is very, very, vera sensitive to the data format you supply vertex arrays. nvidia optimized pretty much every possible data type. But ATI have a few highly optimized paths, and all others are slow beyond belief.

There used to be an ATI performance FAQ that addressed these issues, and listed the data formats to use. I can't find the link, unfortunately.

As far as I remember, vertex positions need to be 3 x GL_FLOAT, colours need to be 4 x GL_UNSIGNED_BYTE, and I don't remember about texture coordinates. Might have been either 2 x float, 3 x float, or 2 x short.

Share this post


Link to post
Share on other sites
Yes i've changed all the double code to floats (declaration and in the functions).
Even with no texture it's slow.
The NVIDIA CARD is FX5200 but it's ok with my old 4200 (but shader are black???) and it's ok on my laptop with a NV 5600GO.

Triangle are not in strip, they are drawn 1 by 1.

Initialisations :

glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glShadeModel(GL_SMOOTH);

float lumiere_position_not_shader[] = {0.0f, 0.0f, 1.0f, 0.0f};

glLightfv(GL_LIGHT0, GL_AMBIENT, this_file.ambientProperties);
glLightfv(GL_LIGHT0, GL_DIFFUSE, this_file.diffuseProperties);
glLightfv(GL_LIGHT0, GL_SPECULAR, this_file.specularProperties);
glLightfv(GL_LIGHT0, GL_POSITION, lumiere_position_not_shader);
glEnable(GL_LIGHT0);
//glEnable(GL_LIGHTING); //enabled when i render

glClearColor(m_ClearColorRed,m_ClearColorGreen,m_ClearColorBlue,1.0f);
glClearDepth(1.0f);

// Perspective
CRect rect;
GetClientRect(&rect);
double aspect = (rect.Height() == 0) ? rect.Width() : (double)rect.Width()/(double)rect.Height();
gluPerspective(45,aspect,0.1,10000.0);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

// Default : blending
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);

// Default : material
float MatAmbient[] = {0.0f, 0.33f, 0.50f, 1.0f};
float MatDiffuse[] = {0.5f, 0.5f, 0.5f, 1.0f};
float MatSpecular[] = {0.1f, 0.1f, 0.1f, 1.0f};
float MatShininess[] = { 84 };
float MatEmission[] = {0.5f, 0.5f, 0.5f, 1.0f};

// Back : green
float MatAmbientBack[] = {0.0f, 0.5f, 0.0f, 0.1f};

glEnable(GL_DEPTH_TEST);

// Modulate : texture lighting

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this