[C++&OpenGL] Oggetti con texture diverse

[Ethoel]

Salve ragazzi, faccio presente che me la cavo bene con la programmazione (C,C++,Java,Php sono linguaggi che conosco bene) quindi volevo iniziare a fare qualcosa utilizzando le librerie grafiche OpenGL (dopo un bel pò di 2D con le allegro)...
Sono bloccato in un vicolo cieco dovuto alla mia poca conoscenza delle OpenGL, se faccio un solo oggetto con una texture fin lì è tutto ok, il problema sono 2 oggetti diversi con 2 texture diverse...
Io ho fatto una specie di "grosso prato" (virgolettato perchè la texture usata è veramente orrenda), e una grossa piramide al centro, quando vado ad eseguire il prato è ok, la piramide invece appare verde o.O
Vi posto le parti di codice interessate:

Texture:
int LoadGLTextures() // Load Bitmaps And Convert To Textures
{
int Status=FALSE;
AUX_RGBImageRec *TextureImage[2];
memset(TextureImage,0,sizeof(void *)*1);
// Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
if (TextureImage[0]=LoadBMP("erba.bmp"))
{
Status=TRUE;
glGenTextures(1, &texture[0]); // Create The Texture

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

free(TextureImage[0]); // Free The Image Structure
}
return Status; // Return The Status
}

Piramide:
void pyramid(float x,float z)
{
glTranslatef(x,0.0f,z);
glBegin(GL_TRIANGLES);

glVertex3f( 0.0f, 8.0f, 0.0f); // Top of triangle (front)
glVertex3f(-2.0f,0.0f, 2.0f); // Left of triangle (front)
glVertex3f( 2.0f,0.0f, 2.0f); // Right of triangle (front)

glVertex3f( 0.0f, 8.0f, 0.0f); // Top of triangle (right)
glVertex3f( 2.0f,0.0f, 2.0f); // Left of triangle (right)
glVertex3f( 2.0f,0.0f, -2.0f); // Right of triangle (right)

glVertex3f( 0.0f, 8.0f, 0.0f); // Top of triangle (back)
glVertex3f( 2.0f,0.0f, -2.0f); // Left of triangle (back)
glVertex3f(-2.0f,0.0f, -2.0f); // Right of triangle (back)


glVertex3f( 0.0f, 8.0f, 0.0f); // Top of triangle (left)
glVertex3f(-2.0f,0.0f,-2.0f); // Left of triangle (left)
glVertex3f(-2.0f,0.0f, 2.0f); // Right of triangle (left)
glEnd(); // Finished Drawing The Triangle
}

"erba":
void quad(float x, float z){
glBindTexture(GL_TEXTURE_2D, texture[0]);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0.0f,1.0f); glVertex3f(-2.0f+x, 0.0f, 2.0f+z); // Sopra a sinistra
glTexCoord2f(1.0f,1.0f); glVertex3f( 2.0f+x, 0.0f, 2.0f+z); // Sopra a destra
glTexCoord2f(1.0f,0.0f); glVertex3f( 2.0f+x, 0.0f, -2.0f+z); // Sotto a destra
glTexCoord2f(0.0f,0.0f); glVertex3f(-2.0f+x, 0.0f, -2.0f+z); //sotto a sinistra
glEnd();
glDisable(texture[0]);
}

Ah... ehm... le x e z lasciatele stare XD

Una mano?

[Don[ITA]]

Non vorrei dire una vaccata megagalattica (ho usato poco OpenGL, solo per un esame e non ricordo molto), ma per disegnare oggetti con texture diverse devi fare una chiamata di glBindTexture prima di ogni disegno, ad esempio:
glBindTexture(...texture erba...);
disegnoErba();
glBindTexture(...texture piramide...);
disegnoPiramide();
ecc ecc

byez

[fero86]

esatto, tra l'altro non mi pare che tu abbia intenzione di texturizzare la piramide: non hai associato le texture coordinates ai vertici della piramide. se vuoi disegnare un oggetto privo di texture in una scena dove hai precedentemente usato delle textures, rimuovi il binding di ogni texture precedente invocando glBindTexture con 0 come nome di texture (0 é un nome riservato che significa "nessuna texture").

oltre a questo ti faccio notare che stai usando la fixed-function pipeline: sta per uscire OpenGL 3.2 e buona parte delle funzioni che hai usato sono deprecate giá in OpenGL 3.0 (in OpenGL 3.2 gli implementatori non saranno piu obbligati a metterle perché non fanno parte del core profile, quindi potresti non ritrovartele; in OpenGL ES ad esempio non ci stanno). quello che dovresti fare é studiarti i vertex array, i buffer objects e gli shaders, e possibilmente evitare di seguire i tutorial di NeHe che ormai sono diventati troppo vecchi.

[fero86]

ah, faccio anche notare un'altra cosa:

void quad(float x, float z){
glBindTexture(GL_TEXTURE_2D, texture[0]);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0.0f,1.0f); glVertex3f(-2.0f+x, 0.0f, 2.0f+z); // Sopra a sinistra
glTexCoord2f(1.0f,1.0f); glVertex3f( 2.0f+x, 0.0f, 2.0f+z); // Sopra a destra
glTexCoord2f(1.0f,0.0f); glVertex3f( 2.0f+x, 0.0f, -2.0f+z); // Sotto a destra
glTexCoord2f(0.0f,0.0f); glVertex3f(-2.0f+x, 0.0f, -2.0f+z); //sotto a sinistra

glEnd();
glDisable(texture[0]);
} non puoi disegnare un quad specificando i vertici "a croce", devi specificarli in senso antiorario (se non abiliti il face culling anche in senso orario). o meglio ancora dovresti disegnare un triangle strip fatto da due triangoli, perché in OpenGL 3.0 sono stati deprecati anche i quadrilateri e i poligoni generici :D

non ti animare, ci sono stati ottimi motivi per deprecarli: la specifica di OpenGL non ha mai richiesto che i poligoni complessi (concavi, forati, non planari, ecc.) vengano disegnati correttamente (tra l'altro, prego, definire "correttamente" nel caso dei poligoni non planari :D) e mai lo richiederá perché non é ragionevole; nella stragrande maggioranza dei casi é preferibile tassellare i poligoni complessi, eventualmente col tassellatore GLU, e renderizzare solo triangoli.

EDIT - ok, scusate: ho letto meglio l'ordine nei commenti evidenziati e quindi quest'ultimo post non vale :stordita: :stordita:

[Ethoel]

A questo punto avete una buona guida sulle OpenGL 3.2 da consigliare?

[fero86]

A questo punto avete una buona guida sulle OpenGL 3.2 da consigliare? consulta questo materiale: http://www.opengl.org/wiki/Main_Page

ma quello che é consigliabile fare non é programmare in OpenGL 3.2 perché ancora non é del tutto disponibile agli sviluppatori (le specifiche ci sono ma sul sito ufficiale il reference risulta ancora "under construction"), bensi programmare in "forward-compatible OpenGL 2.1", cioé usare solo gli entry points documentati nel reference della versione 2.1 che peró non sono deprecati da OpenGL 3.2. dal momento che il reference della versione 3.2 ancora non c'é, l'unica maniera per sapere quali entry points sono deprecati e quali no (oltre a conoscere le tecniche da usare nell'OpenGL attuale) é consultare le specifiche ufficiali :D :stordita:
se una funzione riesci a trovarla nel PDF che descrive il core profile usala senza pensarci due volte, altrimenti cerca un'alternativa migliore. o almeno, io faccio cosi :stordita:

PS: se tu programmassi in Java ci sarebbe JOGL che é molto comodo da questo punto di vista: l'oggetto GL che definisce tutti gli entry points, sia del core profile sia del compatibility profile, implementa diverse interfacce quali GL2, GL3, GL2GL3, ... ciascuna di queste interfacce contiene solo un certo sottoinsieme degli entry points, per esempio GL2GL3 contiene tutti gli entry points del forward-compatible OpenGL 2.1.
tanto per la cronaca :)

dimenticavo, questo é il reference della versione 2.1: http://www.opengl.org/sdk/docs/man/

[Ethoel]

Grazie mille per il materiale e il reference, per il Java purtroppo sono molto....mmm.... come dire... contro, non mi piace programmare in Java, preferisco C/C++/C#, quindi sono per C++&OpenGL ;)