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.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

No one has an idea of what cause ATI 9700 to be slow with this simple model of light and not with shader?

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]

ok thx i will try this and tell you if it's better

sorry for beeing impatient ;)

i tried with GL_FLOAT and even GL_UNSIGNED_BYTE (to be sure), it's not better.

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?)

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.

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);