La creazione di una sfera 3D in Opengl utilizzando Visual C++

Io non sono in grado di creare una semplice sfera 3D utilizzando la libreria OpenGL funzione glutSolidSphere() in C++.

Ecco cosa ho provato:

#include<GL/glu.h> 
void display() 
{ 
    glClear(GL_COLOR_BUFFER_BIT); 
    glColor3f(1.0,0.0,0.0); 
    glLoadIdentity(); 
    glutSolidSphere( 5.0, 20.0, 20.0); 
    glFlush(); 
} 

void myInit() 
{
    glClearColor(1.0,1.0,1.0,1.0); 
    glColor3f(1.0,0.0,0.0); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluOrtho2D(0.0,499.0,0.0,499.0); 
    glMatrixMode(GL_MODELVIEW); 
} 

void main(int argc,char **argv) 
{ 
    qobj = gluNewQuadric(); 
    glutInit(&argc,argv); 
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); 
    glutInitWindowSize(500,500); 
    glutCreateWindow("pendulum");         
    glutDisplayFunc(display); 
    myInit(); 
    glutMainLoop(); 
}
InformationsquelleAutor Lloyd | 2011-05-13



6 Replies
  1. 74

    In OpenGL non creano oggetti, disegnare loro. Una volta disegnato, OpenGL non è più interessato a che la geometria è inviato.

    glutSolidSphere è solo l’invio di comandi di disegno per OpenGL. Tuttavia non c’è niente di speciale su di esso. E poiché è legato all’ECCESSO, mi piacerebbe non la utilizza. Invece, se si ha realmente bisogno di qualche sfera nel codice, che ne dite di creare se per te?

    #define _USE_MATH_DEFINES
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <vector>
    #include <cmath>
    
    //your framework of choice here
    
    class SolidSphere
    {
    protected:
        std::vector<GLfloat> vertices;
        std::vector<GLfloat> normals;
        std::vector<GLfloat> texcoords;
        std::vector<GLushort> indices;
    
    public:
        SolidSphere(float radius, unsigned int rings, unsigned int sectors)
        {
            float const R = 1./(float)(rings-1);
            float const S = 1./(float)(sectors-1);
            int r, s;
    
            vertices.resize(rings * sectors * 3);
            normals.resize(rings * sectors * 3);
            texcoords.resize(rings * sectors * 2);
            std::vector<GLfloat>::iterator v = vertices.begin();
            std::vector<GLfloat>::iterator n = normals.begin();
            std::vector<GLfloat>::iterator t = texcoords.begin();
            for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) {
                    float const y = sin( -M_PI_2 + M_PI * r * R );
                    float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R );
                    float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R );
    
                    *t++ = s*S;
                    *t++ = r*R;
    
                    *v++ = x * radius;
                    *v++ = y * radius;
                    *v++ = z * radius;
    
                    *n++ = x;
                    *n++ = y;
                    *n++ = z;
            }
    
            indices.resize(rings * sectors * 4);
            std::vector<GLushort>::iterator i = indices.begin();
            for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) {
                    *i++ = r * sectors + s;
                    *i++ = r * sectors + (s+1);
                    *i++ = (r+1) * sectors + (s+1);
                    *i++ = (r+1) * sectors + s;
            }
        }
    
        void draw(GLfloat x, GLfloat y, GLfloat z)
        {
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            glTranslatef(x,y,z);
    
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_NORMAL_ARRAY);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    
            glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
            glNormalPointer(GL_FLOAT, 0, &normals[0]);
            glTexCoordPointer(2, GL_FLOAT, 0, &texcoords[0]);
            glDrawElements(GL_QUADS, indices.size(), GL_UNSIGNED_SHORT, &indices[0]);
            glPopMatrix();
        }
    };
    
    SolidSphere sphere(1, 12, 24);
    
    void display()
    {
        int const win_width  = …; //retrieve window dimensions from
        int const win_height = …; //framework of choice here
        float const win_aspect = (float)win_width / (float)win_height;
    
        glViewport(0, 0, win_width, win_height);
    
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45, win_aspect, 1, 10);
    
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
    
    #ifdef DRAW_WIREFRAME
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    #endif
        sphere.draw(0, 0, -5);
    
        swapBuffers();
    }
    
    int main(int argc, char *argv[])
    {
        //initialize and register your framework of choice here
        return 0;
    }
    • Cose eccellenti – avete il codice per generare la texture co-parole così?
    • Dipende da che tipo di mappatura siete interessati. Le sfere sono due poli, a cui è difficile fornire una corretta coordinate di texture. Ma una buona scelta è semplicemente utilizzando le coordinate sferiche, mappata a ST. Vedere la mia modifica.
    • Molte grazie. Mi piace il tuo approccio, per me questo sarebbe parte di un Model classe in cui i vertici, calibri, ecc sono gli attributi e solidSphere() sarebbe uno dei tanti metodi utilizzati per generare la geometria che, in seguito viene disegnato utilizzando draw().
    • Mi piacerebbe fare questo due classi: Modello e la Maglia. E invece di avere una Sfera di classe implementare generatore di funzioni, che consente di creare il desiderato maglia. Perché dopo la rete viene creata è solo una maglia. Modello consiste di un numero di maglie.
    • Ok, mi guarderò in quello. Ho implementato il codice sopra (presumo il glDrawElement() chiamata dovrebbe essere utilizzando GL_UNSIGNED_INT dato il vettore negozi GLuints), ma è solo la generazione di quarto inferiore della sfera e anche backface culling è l’abbattimento al di fuori della sfera, a meno di non utilizzare glFrontFace(GL_CW) per cambiare l’avvolgimento. Potete aiutare con questi problemi? Mi dispiace di essere un dolore, so cosa significa cercare di aiutare e quindi farsi carico le richieste di supporto :-/
    • Sì, ho copiato il codice da un altro esempio, e perso. Tuttavia ti suggerisco di cambiare il tipo di dati da GLuint per GLushort, in quanto le attuali Gpu migliore prestazione con unsigned short indici.
    • OK, farò – e il problema con il rendering? Sei sicuro che gli indici vengono compilati correttamente?
    • Per esempio l’indice di popolazione di codice utilizza la stessa r/s loop valori come vertici, normali, tex-coord, quindi, non potrebbe essere spostati in loop? Ma ogni indice dovrebbe rappresentare un unico 3-float vertice, e quindi non dovrebbe esserci qualcosa di simile a 1/4 o 1/3 il numero di indici, come ci sono i vertici?
    • Sì, il ciclo le variabili sono le stesse, quindi in teoria potrebbero essere unite. Tuttavia non ho più cache amichevole. L’indice dell’array generazione utilizza diversi registri e ha una diversa modalità di accesso; il ciclo è quasi gratis, cache località è molto più importante. Anche dare un’occhiata sul dimensionamento della vertex array e indice di array: Ogni anello al settore/segmento ha 4 vertici, in modo che l’indice di dimensione della matrice è rings * sectors * 4, mentre il vertex array è creato tra le facce; solo perché una sfera è ciclico coordina i passanti sembrano identici.
    • Risposta eccellente.
    • Il disegno di questo codice con GL_TRIANGLE_STRIP porta a cattivi risultati.Sembra che gli indici gen è sbagliato.
    • Triangolo Strisce richiedono una completamente diversa ordine di indice di quad. Nessuna meraviglia che la sfera sembra strano, se utilizzato con qualcosa di diverso da GL_QUADS
    • Grazie per la headups. Sì ho cambiato TRIANGOLI e ha lavorato con alcune piccole modifiche 🙂
    • Cercato di attuare questo e corse in problemi. Vedere il seguente question per i dettagli. Una modifica può essere posto in essere per questa domanda.
    • Grazie per il testa a testa. Vado a vedere in esso.
    • Ok, ho risolto tutti i problemi.
    • Mi piace il tuo uso del const modificatore dopo il tipo. Non vedi che abbastanza spesso. 🙂
    • Ho provato a controllare la tua pagina per un contatto info, ma non ho trovato nulla. Forse questo sarà il lavoro. Ho un Q (vedi il mio prof). Provato a implementare Un in OSG, ma non sono riuscito a farlo (molto difficile). Avete qualche esperienza con OSG? Ps.: Il dominio scadrà il 04 gennaio.
    • Ho segnato la tua domanda e attendono il distacco di un frammento di codice per lavorare con.
    • Sarebbe bene avere la fissa del codice postato, per favore. Come inviato quando viene ruotato attorno all’asse Y, il tetxure sembra che ruotano direzione opposta… il che suggerisce che vedo facce posteriori. Ive stato a giocare con questo e l’ho trovato funziona come previsto SE inverto le normali E impostare il cull per il senso ANTIORARIO. Sento come un avvolgimento problema, ma Im sicuri di come risolvere il tuo codice…
    • Va bene, se inverto le normali e le tortuose funziona correttamente abbattuti e unculled. Fisso di codice riportato di seguito:
    • ehi, che cosa è M_PI ? =)
    • M_PI è un pi numero ~ 3.14159, M_PI_2 è un mezzo di esso.
    • mi scusi per un noobish domanda, ma come faccio a rendere la funzione di visualizzazione sullo schermo? Finora ho questo: pastebin.com/cXugwcYg
    • Il codice che ho dato in StackOverflow risposta utilizza vecchio stile OpenGL 1.1 lato client vertex array. Il programma stub utilizza gli shader e lato server vertice attributo matrici. Questi sono molto simili, ma dovrete porto la mia sfera di generazione di codice per l’utilizzo con shader prima. Altrimenti non vedrete nulla di utile.
    • potrebbe, per favore, mi punto nella giusta direzione, in modo da non ottenere ancora di più perso? Grazie!
    • La dimensione del vettore di indici dovrebbe essere (rings-1) * (sectors-1) * 4. Si potrebbe desiderare di correzione.
    • Io non sono sicuro di cosa intendi, ma la creazione di un vettore di rings * sectors * 4 indici, ma solo la scrittura (rings - 1) * (sectors - 1) * 4 indici del vettore sembra male comunque ? Hai unset indici alla fine. O vuoi dire che questi ultimi indici di dovrebbe essere 0 ?
    • Ohh, ora vedo cosa vuoi dire. Il termine del Loop condizioni. Buona pesca.

  2. 20

    Non sembra come nessuno finora ha affrontato il problema con il codice originale, così ho pensato di farlo anche se la questione è abbastanza vecchio, a questo punto.

    Il problema, in origine, aveva a che fare con la proiezione in relazione al raggio e la posizione della sfera. Penso che il problema non è troppo complicato. Effettivamente il programma funziona correttamente, è solo che cosa rappresenta il disegno è molto difficile da vedere.

    Prima, una proiezione ortogonale è stato creato utilizzando la chiamata

    gluOrtho2D(0.0, 499.0, 0.0, 499.0);

    che “è equivalente alla chiamata glOrtho con vicino = -1 e far = 1.” Questo significa che la visualizzazione tronco ha una profondità di 2. Così una sfera con un raggio di qualcosa di più grande di 1 (diametro = 2) non si adatta completamente all’interno della visualizzazione tronco.

    Allora le chiamate

    glLoadIdentity();
    glutSolidSphere(5.0, 20.0, 20.0);

    sono utilizzati, che carica la matrice identità di model-view matrix e poi “[r]enders una sfera centrata in modellazione coordinate di origine di raggio specificato.” Significato, la sfera viene reso all’origine, (x, y, z) = (0, 0, 0), e con un raggio di 5.

    Ora, il problema è triplice:

    1. Dal momento che la finestra di 500×500 pixel e la larghezza e l’altezza di visualizzazione tronco di quasi 500 (499.0), il piccolo raggio della sfera (5.0) fa la sua area proiettata solo leggermente più di un cinquantesimo (2*5/499) la dimensione della finestra di ogni dimensione. Questo significa che la dimensione apparente della sfera sarebbe di circa 1/2,500 ° (in realtà pi*5^2/499^2, che è più vicino a circa 1/3170th) di tutta la finestra, in modo potrebbe essere difficile vedere. Questo è supponendo che il cerchio è disegnato all’interno dell’area della finestra. Non è, tuttavia, come vedremo nel punto 2.
    2. Dal momento che la visualizzazione tronco ha lasciato aereo in x = 0 e fondo piano y = 0 il campo sarà reso con il suo centro geometrico in basso a sinistra della finestra, in modo che solo un quadrante del proiettata sfera sarà visibile! Questo significa che ciò che si sarebbe visto è ancora più piccolo, circa 1/10,000 th (in realtà pi*5^2/(4*499^2), che è più vicino a 1/12,682 nd) delle dimensioni della finestra. Questo renderebbe ancora più difficile vedere. Soprattutto dal momento che la sfera è resa così vicino ai bordi/angoli dello schermo in cui si potrebbe non pensare al look.
    3. Dal momento che la profondità della visione tronco è significativamente più piccolo del diametro della sfera (meno della metà), solo un frammento della sfera sarà entro la visualizzazione tronco, rendering, è solo una parte. Così si otterrà più come un hollow circle sullo schermo di un solido sfera/cerchio. Come accade, lo spessore del nastro potrebbe rappresentare meno di 1 pixel sullo schermo, il che significa che si potrebbe anche vedere nulla sullo schermo, anche se parte della sfera è infatti all’interno della visualizzazione tronco.

    La soluzione è semplice per cambiare la visualizzazione tronco e il raggio della sfera. Per esempio,

    gluOrtho2D(-5.0, 5.0, -5.0, 5.0);
    glutSolidSphere(5.0, 20, 20);

    rende l’immagine seguente.

    La creazione di una sfera 3D in Opengl utilizzando Visual C++

    Come si può vedere, solo una piccola parte è visibile in tutto il “equatore”, di una sfera con un raggio di 5. (Ho cambiato la proiezione per riempire la finestra con la sfera.) Un altro esempio,

    gluOrtho2D(-1.1, 1.1, -1.1, 1.1);
    glutSolidSphere(1.1, 20, 20);

    rende l’immagine seguente.

    La creazione di una sfera 3D in Opengl utilizzando Visual C++

    L’immagine sopra mostra più la sfera all’interno della visualizzazione tronco, ma la sfera è di 0,2 unità di misura della profondità maggiore di visualizzazione tronco. Come si può vedere, le “calotte” della sfera sono mancanti, sia da nord che da sud. Così, se si desidera che l’intera sfera adatta la visualizzazione di tronco che ha profondità di 2, dobbiamo fare in modo che il raggio inferiore o uguale a 1.

    gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
    glutSolidSphere(1.0, 20, 20);

    rende l’immagine seguente.

    La creazione di una sfera 3D in Opengl utilizzando Visual C++

    Spero che questo ha aiutato qualcuno. Fate attenzione!

    • Questo dovrebbe essere accettato risposta per la domanda dall’OP.
    • Grazie per il feedback, @legends2k. Ho aggiunto qualche dettaglio in più per quanto riguarda le proporzioni esatte di area proiettata che rende il cerchio molto difficile da vedere quando si è trascinato in un angolo della finestra. Questo per spiegare chiaramente dove ricevo i miei numeri e perché il cerchio non viene visualizzato anche se è in fase di elaborazione.
  3. 8

    Non capisco come si può datenwolf indice di generazione può essere corretto. Ma ancora trovare la sua soluzione, piuttosto chiaro. Questo è quello che ottengo dopo qualche pensiero:

    inline void push_indices(vector<GLushort>& indices, int sectors, int r, int s) {
        int curRow = r * sectors;
        int nextRow = (r+1) * sectors;
    
        indices.push_back(curRow + s);
        indices.push_back(nextRow + s);
        indices.push_back(nextRow + (s+1));
    
        indices.push_back(curRow + s);
        indices.push_back(nextRow + (s+1));
        indices.push_back(curRow + (s+1));
    }
    
    void createSphere(vector<vec3>& vertices, vector<GLushort>& indices, vector<vec2>& texcoords,
                 float radius, unsigned int rings, unsigned int sectors)
    {
        float const R = 1./(float)(rings-1);
        float const S = 1./(float)(sectors-1);
    
        for(int r = 0; r < rings; ++r) {
            for(int s = 0; s < sectors; ++s) {
                float const y = sin( -M_PI_2 + M_PI * r * R );
                float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R );
                float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R );
    
                texcoords.push_back(vec2(s*S, r*R));
                vertices.push_back(vec3(x,y,z) * radius);
                push_indices(indices, sectors, r, s);
            }
        }
    }
    • Si dovrebbe indicare che questa risposta non utilizza glutSolidSphere come la questione chiamato per esso.
    • 🙂 è un diritto. Ho appena trovato questa domanda è in cerca di un manuale metodo di generazione dei SENZA glutSolidSphere…
    • btw datenwolf indice di generazione sembra essere corretta. Ma io non so ogl capacità di disegnare un quadrato invece di triangolo. Io sono noob in questo.
    • Questa è la versione migliore per il buffer di creazione di un oggetto per avere maggiore velocità di disegno mentre elliminating pci-e azioni?
    • uno quesiton da uno sviluppatore java: che cosa è M_PI_2 ??
    • ou appena trovato. il suo mezzo di pi. ma perché qui?
    • ma… qualcuno potrebbe spiegare come implementare questa indicizzate disegno ora???? grazie!
    • Che cosa si intende per indicizzati disegno? Quanto sopra è un indicizzati poligono. Se intendi l’immediata modalità di disegno, poi basta scorrere l’array risultante e impostare il coords.

  4. 2

    Ecco il codice:

    glPushMatrix();
    glTranslatef(18,2,0);
    glRotatef(angle, 0, 0, 0.7);
    glColor3ub(0,255,255);
    glutWireSphere(3,10,10);
    glPopMatrix();
    • È sempre bello se si lascia qualche parola che descrive il tuo codice.
  5. 2

    Mi piace la risposta di moneta. E ‘ semplice da capire e lavora con i triangoli. Tuttavia gli indici del suo programma sono a volte oltre i limiti. Così I post qui il suo codice con due piccole correzioni:

    inline void push_indices(vector<GLushort>& indices, int sectors, int r, int s) {
        int curRow = r * sectors;
        int nextRow = (r+1) * sectors;
        int nextS = (s+1) % sectors;
    
        indices.push_back(curRow + s);
        indices.push_back(nextRow + s);
        indices.push_back(nextRow + nextS);
    
        indices.push_back(curRow + s);
        indices.push_back(nextRow + nextS);
        indices.push_back(curRow + nextS);
    }
    
    void createSphere(vector<vec3>& vertices, vector<GLushort>& indices, vector<vec2>& texcoords,
                      float radius, unsigned int rings, unsigned int sectors)
    {
        float const R = 1./(float)(rings-1);
        float const S = 1./(float)(sectors-1);
    
        for(int r = 0; r < rings; ++r) {
            for(int s = 0; s < sectors; ++s) {
                float const y = sin( -M_PI_2 + M_PI * r * R );
                float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R );
                float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R );
    
                texcoords.push_back(vec2(s*S, r*R));
                vertices.push_back(vec3(x,y,z) * radius);
                if(r < rings-1)
                    push_indices(indices, sectors, r, s);
            }
        }
    }
    • Grazie per il tuo Codice! Mi ha aiutato molto 🙂
  6. 2

    Datanewolf codice è QUASI giusto. Ho dovuto invertire sia l’avvolgimento e normali per farlo funzionare correttamente con la fixed pipeline. Il seguito funziona correttamente con cull si o no per me:

    std::vector<GLfloat> vertices;
    std::vector<GLfloat> normals;
    std::vector<GLfloat> texcoords;
    std::vector<GLushort> indices;
    
    float const R = 1./(float)(rings-1);
    float const S = 1./(float)(sectors-1);
    int r, s;
    
    vertices.resize(rings * sectors * 3);
    normals.resize(rings * sectors * 3);
    texcoords.resize(rings * sectors * 2);
    std::vector<GLfloat>::iterator v = vertices.begin();
    std::vector<GLfloat>::iterator n = normals.begin();
    std::vector<GLfloat>::iterator t = texcoords.begin();
    for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) {
        float const y = sin( -M_PI_2 + M_PI * r * R );
        float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R );
        float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R );
    
        *t++ = s*S;
        *t++ = r*R;
    
        *v++ = x * radius;
        *v++ = y * radius;
        *v++ = z * radius;
    
        *n++ = -x;
        *n++ = -y;
        *n++ = -z;
    }
    
    indices.resize(rings * sectors * 4);
    std::vector<GLushort>::iterator i = indices.begin();
    for(r = 0; r < rings-1; r++)
        for(s = 0; s < sectors-1; s++) {
           /* 
            *i++ = r * sectors + s;
            *i++ = r * sectors + (s+1);
            *i++ = (r+1) * sectors + (s+1);
            *i++ = (r+1) * sectors + s;
            */
             *i++ = (r+1) * sectors + s;
             *i++ = (r+1) * sectors + (s+1);
            *i++ = r * sectors + (s+1);
             *i++ = r * sectors + s;
    
    }

    Edit: C’era una domanda su come disegnare questo… nel mio codice ho incapsulare questi valori in un G3DModel classe. Questo è il mio codice per l’installazione del telaio, disegnare il modello, e fine:

    void GraphicsProvider3DPriv::BeginFrame()const{
            int win_width;
            int win_height;//framework of choice here
            glfwGetWindowSize(window, &win_width, &win_height); //retrieve window
            float const win_aspect = (float)win_width / (float)win_height;
            //set lighting
            glEnable(GL_LIGHTING);
            glEnable(GL_LIGHT0);
            glEnable(GL_DEPTH_TEST);
            GLfloat lightpos[] = {0, 0.0, 0, 0.};
            glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
            GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
            glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
            glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
            //set up world transform
            glClearColor(0.f, 0.f, 0.f, 1.f);
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT|GL_ACCUM_BUFFER_BIT);
            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
    
            gluPerspective(45, win_aspect, 1, 10);
    
            glMatrixMode(GL_MODELVIEW);
    
        }
    
    
        void GraphicsProvider3DPriv::DrawModel(const G3DModel* model, const Transform3D transform)const{
            G3DModelPriv* privModel = (G3DModelPriv *)model;
            glPushMatrix();
            glLoadMatrixf(transform.GetOGLData());
    
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_NORMAL_ARRAY);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    
            glVertexPointer(3, GL_FLOAT, 0, &privModel->vertices[0]);
            glNormalPointer(GL_FLOAT, 0, &privModel->normals[0]);
            glTexCoordPointer(2, GL_FLOAT, 0, &privModel->texcoords[0]);
    
            glEnable(GL_TEXTURE_2D);
            //glFrontFace(GL_CCW);
            glEnable(GL_CULL_FACE);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, privModel->texname);
    
            glDrawElements(GL_QUADS, privModel->indices.size(), GL_UNSIGNED_SHORT, &privModel->indices[0]);
            glPopMatrix();
            glDisable(GL_TEXTURE_2D);
    
        }
    
        void GraphicsProvider3DPriv::EndFrame()const{
            /* Swap front and back buffers */
            glDisable(GL_LIGHTING);
            glDisable(GL_LIGHT0);
            glDisable(GL_CULL_FACE);
            glfwSwapBuffers(window);
    
            /* Poll for and process events */
            glfwPollEvents();
        }
    • I vostri normali indicare nella direzione opposta, come in questo caso – sei sicuro di non vedere la tua sfera dentro?

Lascia un commento