DGL • Thema anzeigen - Würfel in VBO

Würfel in VBO

Moderator: DGL-Team

Seite 1 von 1

[ 12 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

framueller

Betreff des Beitrags: Würfel in VBO

Verfasst: Mo Sep 03, 2007 20:20

DGL Member

Registriert: Fr Aug 31, 2007 07:25
Beiträge: 12

Hallo!Hab nun einen Würfel mit Hilfe von Vertex Arrays dargestellt,würd jetzt gern das gleiche machen mit Vertex Buffer Object,aber weiss nicht wie es funktioniert!Hab mir zwar das Tutorial auf der Wiki Seite durchgelesen,aber kann es nicht auf den Würfel anwenden...Würd mich riesig über Hilfe freuen!!!
Hier mal das Programm,würd es gerne als Dateianhang machen,aber keine Ahnung wie...

Code:

#include <windows.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
// Daten für den Würfel
static GLfloat corners[] = { -25.0f, 25.0f, 25.0f, // 0 // Front of cube
                              25.0f, 25.0f, 25.0f, // 1
                              25.0f, -25.0f, 25.0f,// 2
                             -25.0f, -25.0f, 25.0f,// 3
                             -25.0f, 25.0f, -25.0f,// 4  // Back of cube
                              25.0f, 25.0f, -25.0f,// 5
                              25.0f, -25.0f, -25.0f,// 6
                             -25.0f, -25.0f, -25.0f };// 7
 
// Index-Array um Würfel zu zeichnen
static GLubyte indexes[] = { 0, 1, 2, 3,   // Front Face
                             4, 5, 1, 0,    // Top Face
                             3, 2, 6, 7,    // Bottom Face
                             5, 4, 7, 6,    // Back Face
                             1, 5, 6, 2,    // Right Face
                             4, 0, 3, 7 }; // Left Face
// Farb-Definition                           
static GLfloat color[] =  {1.0f,0.0f,0.0f,
                           1.0f,1.0f,0.0f,
                           1.0f,0.0f,1.0f,
                           0.0f,0.0f,0.0f,
                           1.0f,0.0f,1.0f,
                           0.0f,1.0f,1.0f,
                           0.0f,0.0f,0.0f,
                           1.0f,1.0f,1.0f};
 
 
static GLfloat xRot = 0.0f;
static GLfloat yRot = 0.0f;
 
 
 
// Called to draw scene
void RenderScene(void)
    {
    // Clear the window with current clearing color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    // Make the cube a wire frame
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    
    // Save the matrix state
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, -200.0f);
    glRotatef(xRot, 1.0f, 0.0f, 0.0f);
    glRotatef(yRot, 0.0f, 0.0f, 1.0f);
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, corners);
    glColorPointer(3, GL_FLOAT, 0, color);
 
    glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, indexes);
    glPopMatrix();
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
    // Swap buffers
    glutSwapBuffers();
    }
 
 
// This function does any needed initialization on the rendering
// context. 
void SetupRC()
    {
    // Black background
    glClearColor(1.0f, 1.0f, 0.0f, 0.0f );
    glEnable(GL_DEPTH_TEST);    
    glEnable(GL_DITHER);
    //glShadeModel(GL_FLAT);
    //glColor3f(1,0,0);
    }
 
///////////////////////////////////////////////////////////////////////////////
// Process arrow keys
void SpecialKeys(int key, int x, int y)
    {
    if(key == GLUT_KEY_UP)
        xRot-= 5.0f;
 
    if(key == GLUT_KEY_DOWN)
        xRot += 5.0f;
 
    if(key == GLUT_KEY_LEFT)
        yRot -= 5.0f;
 
    if(key == GLUT_KEY_RIGHT)
        yRot += 5.0f;
 
    if(key > 356.0f)
        xRot = 0.0f;
 
    if(key < -1.0f)
        xRot = 355.0f;
 
    if(key > 356.0f)
        yRot = 0.0f;
 
    if(key < -1.0f)
        yRot = 355.0f;
 
    // Refresh the Window
    glutPostRedisplay();
    }
 
 
void ChangeSize(int w, int h)
    {
    // Prevent a divide by zero
    if(h == 0)
        h = 1;
 
    // Set Viewport to window dimensions
    glViewport(0, 0, w, h);
 
    // Reset coordinate system
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    // Establish clipping volume (left, right, bottom, top, near, far)
    gluPerspective(35.0f, (float)w/(float)h, 1.0f, 1000.0f);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    }
 
int main(int argc, char* argv[])
    {
    glutInit(&argc, argv);
 
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800,600);
    glutCreateWindow("Cube DX");
    glutReshapeFunc(ChangeSize);
    glutSpecialFunc(SpecialKeys);
    glutDisplayFunc(RenderScene);
 
    SetupRC();
 
    glutMainLoop();
    return 0;
    }

Nach oben

Conan

Betreff des Beitrags:

Verfasst: Di Sep 04, 2007 12:37

DGL Member

Registriert: Di Nov 07, 2006 13:37
Beiträge: 83
Wohnort: Partenheim

Hallo framueller,

da ich leider nicht weiß, an welcher Stelle des VBO-Tutorials du dich nicht mehr mit dem dort Beschriebenen und deinem bisherigen Code vereinbaren kannst, beschreib' ich grob den Übergabe- und den Render-Vorgang, wie er mit deinem Würfel aussähe.

Gehen wir also davon aus, du entscheidest dich für Variante 1 der Übergabe der Vertexdaten, wie es im VBO-Tutorial beschrieben ist. Du legst dir also, wenn du es nicht schon getan hast, ein TVertex-Objekt an, packst da in korrekter Reihenfolge (entspr. GL_T2F_V3F, ...) Textur-Koordinaten, Normalen, Farben und deine Koordinaten (corners) rein oder wie bei dir: Farben und Koordinaten. Den Rest machst du, wie im Tutorial beschrieben: Bei der Übergabe der Daten an die Grafikkarte kannst du dir nun überlegen, ob du lediglich nacheinander deine 8 Vertizen, oder ob du insgesamt die 6 Faces deines Würfels übergibst. Mit der ersten Methode sparst du Platz im Grafikkarten-RAM, mit der zweiten sparst du dir das Index-Array.

Hast du die Vertexdaten nach der ersten Methode übergeben, renderst du deinen Würfel via

Code:

glInterleavedArrays(dein VertexFormat, ...);
glDrawRangeElements(..., dein IndexArray);

Bei zweiter Methode genügt

Code:

glInterleavedArrays(dein VertexFormat, ...);
glDrawArrays(...);

Conan

_________________
THE TRUTH IS NOT OUT THERE!

Nach oben

framueller

Betreff des Beitrags:

Verfasst: Di Sep 04, 2007 18:30

DGL Member

Registriert: Fr Aug 31, 2007 07:25
Beiträge: 12

Oh sorry,ich bekomme es einfach nicht hin!Ist es nicht möglich,mit den von mir angelegten Arrays ganz schnell und einfach mit VBOs weiterzuarbeiten???

Grüße und dank für eure Hilfe
Frank

Nach oben

Conan

Betreff des Beitrags:

Verfasst: Mi Sep 05, 2007 12:20

DGL Member

Registriert: Di Nov 07, 2006 13:37
Beiträge: 83
Wohnort: Partenheim

Doch, das ist es ... :wink:

Wie gesagt, mit erster beschriebener Methode ändert sich nicht viel in deinem Code, da du ja das Index-Array schon vorliegen hast. Jedoch ist die zweite Methode in Sascha Willems VBO-Tutorial beschreiben.

Wo liegt denn genau dein Problem?
Kommt 'ne Fehlermeldung? Siehst du nur 'nen Teil des Würfels oder gar nichts?

Conan

_________________
THE TRUTH IS NOT OUT THERE!

Nach oben

framueller

Betreff des Beitrags:

Verfasst: Mi Sep 05, 2007 12:32

DGL Member

Registriert: Fr Aug 31, 2007 07:25
Beiträge: 12

So,habe jetzt noch mal ausprobiert,einen Würfel mit vier verschiedenen Methoden zu übergeben und darzustellen!Wenn ich die VBOs ausklammern würde,dann klappt es,bei allen vier zeigt er mir Fehlermeldung bei Öffnen der exe an:-(
Hier mal der Code,hoffe mir sagt einer was ich falsch mache...ich bekomm es einfach nicht auf die Rolle...

Code:

///////////////////////////////////////////////////////////////////////////////
// main.cpp
// ========
// testing vertex array (glDrawElements, glDrawArray)
//
//  AUTHOR: Song Ho Ahn (song.ahn@gmail.com)
// CREATED: 2005-10-04
// UPDATED: 2005-10-28
///////////////////////////////////////////////////////////////////////////////
 
#include <GL/glut.h>
#include "glext.h"
#include <iostream>
#include <sstream>
#include <iomanip>
using std::stringstream;
using std::cout;
using std::endl;
using std::ends;
 
 
// GLUT CALLBACK functions
void displayCB();
void reshapeCB(int w, int h);
void timerCB(int millisec);
void keyboardCB(unsigned char key, int x, int y);
void mouseCB(int button, int stat, int x, int y);
void mouseMotionCB(int x, int y);
 
void initGL();
int  initGLUT(int argc, char **argv);
bool initSharedMem();
void clearSharedMem();
void initLights();
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ);
void drawString(const char *str, int x, int y, float color[4], void *font);
void drawString3D(const char *str, float pos[3], float color[4], void *font);
void draw1();
void draw2();
void draw3();
void draw4();
 
// global variables
void *font = GLUT_BITMAP_8_BY_13;
bool mouseLeftDown;
bool mouseRightDown;
bool mouseMiddleDown;
float mouseX, mouseY;
float cameraAngleX;
float cameraAngleY;
float cameraDistance;
int drawMode = 0;
int maxVertices;
int maxIndices;
 
// function pointer to OpenGL extensions
PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements = 0;
 
 
// Würfel //
//    v6----- v5
//   /|      /|
//  v1------v0|
//  | |     | |
//  | |v7---|-|v4
//  |/      |/
//  v2------v3
// vertex array
GLfloat vertices[] = {1,1,1,  -1,1,1,  -1,-1,1,  1,-1,1,        // v0-v1-v2-v3
                      1,1,1,  1,-1,1,  1,-1,-1,  1,1,-1,        // v0-v3-v4-v5
                      1,1,1,  1,1,-1,  -1,1,-1,  -1,1,1,        // v0-v5-v6-v1
                      -1,1,1,  -1,1,-1,  -1,-1,-1,  -1,-1,1,    // v1-v6-v7-v2
                      -1,-1,-1,  1,-1,-1,  1,-1,1,  -1,-1,1,    // v7-v4-v3-v2
                      1,-1,-1,  -1,-1,-1,  -1,1,-1,  1,1,-1};   // v4-v7-v6-v5
// normal array
GLfloat normals[] = {0,0,1,  0,0,1,  0,0,1,  0,0,1,             // v0-v1-v2-v3
                     1,0,0,  1,0,0,  1,0,0, 1,0,0,              // v0-v3-v4-v5
                     0,1,0,  0,1,0,  0,1,0, 0,1,0,              // v0-v5-v6-v1
                     -1,0,0,  -1,0,0, -1,0,0,  -1,0,0,          // v1-v6-v7-v2
                     0,-1,0,  0,-1,0,  0,-1,0,  0,-1,0,         // v7-v4-v3-v2
                     0,0,-1,  0,0,-1,  0,0,-1,  0,0,-1};        // v4-v7-v6-v5
// color array
GLfloat colors[] = {1,1,1,  1,1,0,  1,0,0,  1,0,1,              // v0-v1-v2-v3
                    1,1,1,  1,0,1,  0,0,1,  0,1,1,              // v0-v3-v4-v5
                    1,1,1,  0,1,1,  0,1,0,  1,1,0,              // v0-v5-v6-v1
                    1,1,0,  0,1,0,  0,0,0,  1,0,0,              // v1-v6-v7-v2
                    0,0,0,  0,0,1,  1,0,1,  1,0,0,              // v7-v4-v3-v2
                    0,0,1,  0,0,0,  0,1,0,  0,1,1};             // v4-v7-v6-v5
// index array of vertex array for glDrawElements()
GLubyte indices[] = {0,1,2,3,
                     4,5,6,7,
                     8,9,10,11,
                     12,13,14,15,
                     16,17,18,19,
                     20,21,22,23};
 
#ifdef _WIN32
PFNGLGENBUFFERSARBPROC pglGenBuffersARB = 0;                     // VBO Name Generation Procedure
PFNGLBINDBUFFERARBPROC pglBindBufferARB = 0;                     // VBO Bind Procedure
PFNGLBUFFERDATAARBPROC pglBufferDataARB = 0;                     // VBO Data Loading Procedure
PFNGLBUFFERSUBDATAARBPROC pglBufferSubDataARB = 0;               // VBO Sub Data Loading Procedure
PFNGLDELETEBUFFERSARBPROC pglDeleteBuffersARB = 0;               // VBO Deletion Procedure
PFNGLGETBUFFERPARAMETERIVARBPROC pglGetBufferParameterivARB = 0; // return various parameters of VBO
PFNGLMAPBUFFERARBPROC pglMapBufferARB = 0;                       // map VBO procedure
PFNGLUNMAPBUFFERARBPROC pglUnmapBufferARB = 0;                   // unmap VBO procedure
#define glGenBuffersARB           pglGenBuffersARB
#define glBindBufferARB           pglBindBufferARB
#define glBufferDataARB           pglBufferDataARB
#define glBufferSubDataARB        pglBufferSubDataARB
#define glDeleteBuffersARB        pglDeleteBuffersARB
#define glGetBufferParameterivARB pglGetBufferParameterivARB
#define glMapBufferARB            pglMapBufferARB
#define glUnmapBufferARB          pglUnmapBufferARB
#endif
///////////////////////////////////////////////////////////////////////////////
// draw 1, immediate mode
// 54 calls = 24 glVertex*() calls + 24 glColor*() calls + 6 glNormal*() calls
///////////////////////////////////////////////////////////////////////////////
void draw1()
{
    glPushMatrix();
    glTranslatef(-2, 2, 0); // move to upper left corner
    glBegin(GL_QUADS);
        // face v0-v1-v2-v3
        glNormal3f(0,0,1);
        glColor3f(1,1,1);
        glVertex3f(1,1,1);
        glColor3f(1,1,0);
        glVertex3f(-1,1,1);
        glColor3f(1,0,0);
        glVertex3f(-1,-1,1);
        glColor3f(1,0,1);
        glVertex3f(1,-1,1);
 
        // face v0-v3-v4-v6
        glNormal3f(1,0,0);
        glColor3f(1,1,1);
        glVertex3f(1,1,1);
        glColor3f(1,0,1);
        glVertex3f(1,-1,1);
        glColor3f(0,0,1);
        glVertex3f(1,-1,-1);
        glColor3f(0,1,1);
        glVertex3f(1,1,-1);
 
        // face v0-v5-v6-v1
        glNormal3f(0,1,0);
        glColor3f(1,1,1);
        glVertex3f(1,1,1);
        glColor3f(0,1,1);
        glVertex3f(1,1,-1);
        glColor3f(0,1,0);
        glVertex3f(-1,1,-1);
        glColor3f(1,1,0);
        glVertex3f(-1,1,1);
 
        // face  v1-v6-v7-v2
        glNormal3f(-1,0,0);
        glColor3f(1,1,0);
        glVertex3f(-1,1,1);
        glColor3f(0,1,0);
        glVertex3f(-1,1,-1);
        glColor3f(0,0,0);
        glVertex3f(-1,-1,-1);
        glColor3f(1,0,0);
        glVertex3f(-1,-1,1);
 
        // face v7-v4-v3-v2
        glNormal3f(0,-1,0);
        glColor3f(0,0,0);
        glVertex3f(-1,-1,-1);
        glColor3f(0,0,1);
        glVertex3f(1,-1,-1);
        glColor3f(1,0,1);
        glVertex3f(1,-1,1);
        glColor3f(1,0,0);
        glVertex3f(-1,-1,1);
 
        // face v4-v7-v6-v5
        glNormal3f(0,0,-1);
        glColor3f(0,0,1);
        glVertex3f(1,-1,-1);
        glColor3f(0,0,0);
        glVertex3f(-1,-1,-1);
        glColor3f(0,1,0);
        glVertex3f(-1,1,-1);
        glColor3f(0,1,1);
        glVertex3f(1,1,-1);
    glEnd();
 
    glPopMatrix();
}
 
void draw2()
{   glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    glNormalPointer(GL_FLOAT, 0, normals);
    glColorPointer(3, GL_FLOAT, 0, colors);
    glVertexPointer(3, GL_FLOAT, 0, vertices);
 
    glPushMatrix();
    glTranslatef(2, 2, 0);                  
 
    glDrawArrays(GL_QUADS, 0, 24);
 
    glPopMatrix();
 
    glDisableClientState(GL_VERTEX_ARRAY);  
    glDisableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
}
void draw3()
{
    glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    glNormalPointer(GL_FLOAT, 0, normals);
    glColorPointer(3, GL_FLOAT, 0, colors);
    glVertexPointer(3, GL_FLOAT, 0, vertices);
 
    glPushMatrix();
    glTranslatef(-2, -2, 0);                
    glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, indices);
    glPopMatrix();
    glDisableClientState(GL_VERTEX_ARRAY); 
    glDisableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
}
void draw4()
{       GLuint vboId = 0;    
        glGenBuffersARB(1, &vboId);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(vertices)+sizeof(normals)+sizeof(colors), 0, GL_STATIC_DRAW_ARB);                                      // When buffer object is bound with its ID, all pointers in gl*Pointer()
                                          // are treated as offset instead of real pointer.
 
        // enable vertex arrays
        glEnableClientState(GL_NORMAL_ARRAY);
        glEnableClientState(GL_COLOR_ARRAY);
        glEnableClientState(GL_VERTEX_ARRAY);
 
        // before draw, specify vertex and index arrays with their offsets
        glNormalPointer(GL_FLOAT, 0, (void*)sizeof(vertices));
        glColorPointer(3, GL_FLOAT, 0, (void*)(sizeof(vertices)+sizeof(normals)));
        glVertexPointer(3, GL_FLOAT, 0, 0);
        glPushMatrix();
        glTranslatef(-2, 2, 0);                
        glDrawArrays(GL_QUADS, 0, 24);
        glPopMatrix();
        glDisableClientState(GL_VERTEX_ARRAY);  // disable vertex arrays
        glDisableClientState(GL_COLOR_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);
 
        // it is good idea to release VBOs with ID 0 after use.
        // Once bound with 0, all pointers in gl*Pointer() behave as real
        // pointer, so, normal vertex array operations are re-activated
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
        glDeleteBuffersARB(1, &vboId);
}
 
 
 
 
 
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    initSharedMem();
 
    // init GLUT and GL
    initGLUT(argc, argv);
    initGL();
 
 
    // check max of elements vertices and elements indices that your video card supports
    // Use these values to determine the range of glDrawRangeElements()
    // The constants are defined in glext.h
    glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &maxVertices);
    glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &maxIndices);
 
    // get function pointer to glDrawRangeElements
    glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)wglGetProcAddress("glDrawRangeElements");
 
 
    // the last GLUT call (LOOP)
    // window will be shown and display callback is triggered by events
    // NOTE: this call never return main().
    glutMainLoop(); /* Start GLUT event-processing loop */
 
    return 0;
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize GLUT for windowing
///////////////////////////////////////////////////////////////////////////////
int initGLUT(int argc, char **argv)
{
    // GLUT stuff for windowing
    // initialization openGL window.
    // it is called before any other GLUT routine
    glutInit(&argc, argv);
 
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);   // display mode
 
    glutInitWindowSize(400, 300);               // window size
 
    glutInitWindowPosition(100, 100);           // window location
 
    // finally, create a window with openGL context
    // Window will not displayed until glutMainLoop() is called
    // it returns a unique ID
    int handle = glutCreateWindow(argv[0]);     // param is the title of window
 
    // register GLUT callback functions
    glutDisplayFunc(displayCB);
    glutTimerFunc(100, timerCB, 100);             // redraw only every given millisec
    glutReshapeFunc(reshapeCB);
    glutKeyboardFunc(keyboardCB);
    glutMouseFunc(mouseCB);
    glutMotionFunc(mouseMotionCB);
 
    return handle;
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize OpenGL
// disable unused features
///////////////////////////////////////////////////////////////////////////////
void initGL()
{
    glShadeModel(GL_SMOOTH);                    // shading mathod: GL_SMOOTH or GL_FLAT
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);      // 4-byte pixel alignment
 
    // enable /disable features
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    //glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    //glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
 
     // track material ambient and diffuse from surface color, call it before glEnable(GL_COLOR_MATERIAL)
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
 
    glClearColor(0, 0, 0, 0);                   // background color
    glClearStencil(0);                          // clear stencil buffer
    glClearDepth(1.0f);                         // 0 is near, 1 is far
    glDepthFunc(GL_LEQUAL);
 
    initLights();
    setCamera(0, 0, 10, 0, 0, 0);
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// write 2d text using GLUT
// The projection matrix must be set to orthogonal before call this function.
///////////////////////////////////////////////////////////////////////////////
void drawString(const char *str, int x, int y, float color[4], void *font)
{
    glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT); // lighting and color mask
    glDisable(GL_LIGHTING);     // need to disable lighting for proper text color
 
    glColor4fv(color);          // set text color
    glRasterPos2i(x, y);        // place text position
 
    // loop all characters in the string
    while(*str)
    {
        glutBitmapCharacter(font, *str);
        ++str;
    }
 
    glEnable(GL_LIGHTING);
    glPopAttrib();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// draw a string in 3D space
///////////////////////////////////////////////////////////////////////////////
void drawString3D(const char *str, float pos[3], float color[4], void *font)
{
    glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT); // lighting and color mask
    glDisable(GL_LIGHTING);     // need to disable lighting for proper text color
 
    glColor4fv(color);          // set text color
    glRasterPos3fv(pos);        // place text position
 
    // loop all characters in the string
    while(*str)
    {
        glutBitmapCharacter(font, *str);
        ++str;
    }
 
    glEnable(GL_LIGHTING);
    glPopAttrib();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize global variables
///////////////////////////////////////////////////////////////////////////////
bool initSharedMem()
{
    mouseLeftDown = mouseRightDown = mouseMiddleDown = false;
 
    return true;
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// clean up shared memory
///////////////////////////////////////////////////////////////////////////////
void clearSharedMem()
{
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize lights
///////////////////////////////////////////////////////////////////////////////
void initLights()
{
    // set up light colors (ambient, diffuse, specular)
    GLfloat lightKa[] = {.2f, .2f, .2f, 1.0f};  // ambient light
    GLfloat lightKd[] = {.7f, .7f, .7f, 1.0f};  // diffuse light
    GLfloat lightKs[] = {1, 1, 1, 1};           // specular light
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightKs);
 
    // position the light
    float lightPos[4] = {0, 0, 20, 1}; // positional light
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 
    glEnable(GL_LIGHT0);                        // MUST enable each light source after configuration
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// set camera position and lookat direction
///////////////////////////////////////////////////////////////////////////////
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX, posY, posZ, targetX, targetY, targetZ, 0, 1, 0); // eye(x,y,z), focal(x,y,z), up(x,y,z)
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// display info messages
///////////////////////////////////////////////////////////////////////////////
void showInfo()
{
    // backup current model-view matrix
    glPushMatrix();                     // save current modelview matrix
    glLoadIdentity();                   // reset modelview matrix
 
    // set to 2D orthogonal projection
    glMatrixMode(GL_PROJECTION);        // switch to projection matrix
    glPushMatrix();                     // save current projection matrix
    glLoadIdentity();                   // reset projection matrix
    gluOrtho2D(0, 400, 0, 300);         // set to orthogonal projection
 
    float color[4] = {1, 1, 1, 1};
 
    stringstream ss;
    ss << std::fixed << std::setprecision(3);
 
    ss << "Max Elements Vertices: " << maxVertices << ends;
    drawString(ss.str().c_str(), 1, 286, color, font);
    ss.str("");
 
    ss << "Max Elements Indices: " << maxIndices << ends;
    drawString(ss.str().c_str(), 1, 272, color, font);
    ss.str("");
 
    // unset floating format
    ss << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
 
    // restore projection matrix
    glPopMatrix();                   // restore to previous projection matrix
 
    // restore modelview matrix
    glMatrixMode(GL_MODELVIEW);      // switch to modelview matrix
    glPopMatrix();                   // restore to previous modelview matrix
}
 
 
 
 
 
 
//=============================================================================
// CALLBACKS
//=============================================================================
 
void displayCB()
{
    // clear buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
    // save the initial ModelView matrix before modifying ModelView matrix
    glPushMatrix();
 
    // tramsform camera
    glTranslatef(0, 0, cameraDistance);
    glRotatef(cameraAngleX, 1, 0, 0);   // pitch
    glRotatef(cameraAngleY, 0, 1, 0);   // heading
 
    draw1();        // with immediate mode, glBegin()-glEnd() block
    draw2();        // with glDrawArrays()
    draw3();        // with glDrawElements()
    draw4();        // with glDrawRangeElements()
 
 
    // print 2D text
    float pos[4] = {-4.0f,3.5f,0,1};
    float color[4] = {1,1,1,1};
    drawString3D("Ohne Array", pos, color, font);
    pos[0] = 0.5f;
    drawString3D("glDrawArrays()", pos, color, font);
    pos[0] = -5.0f; pos[1] = -4.0f;
    drawString3D("glDrawElements()", pos, color, font);
    pos[0] = 0.5f;
    drawString3D("VBO", pos, color, font);
    
 
    showInfo();     // print max range of glDrawRangeElements
 
 
    glPopMatrix();
 
    glutSwapBuffers();
}
 
 
void reshapeCB(int w, int h)
{
    // set viewport to be the entire window
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
 
    // set perspective viewing frustum
    float aspectRatio = (float)w / h;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //glFrustum(-aspectRatio, aspectRatio, -1, 1, 1, 100);
    gluPerspective(60.0f, (float)(w)/h, 1.0f, 1000.0f); // FOV, AspectRatio, NearClip, FarClip
 
    // switch to modelview matrix in order to set scene
    glMatrixMode(GL_MODELVIEW);
}
 
 
void timerCB(int millisec)
{
    glutTimerFunc(millisec, timerCB, millisec);
    glutPostRedisplay();
}
 
 
void keyboardCB(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 27: // ESCAPE
        clearSharedMem();
        exit(0);
        break;
 
    case 'd': // switch rendering modes (fill -> wire -> point)
    case 'D':
        drawMode = ++drawMode % 3;
        if(drawMode == 0)        // fill mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            glEnable(GL_DEPTH_TEST);
            glEnable(GL_CULL_FACE);
        }
        else if(drawMode == 1)  // wireframe mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            glDisable(GL_DEPTH_TEST);
            glDisable(GL_CULL_FACE);
        }
        else                    // point mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
            glDisable(GL_DEPTH_TEST);
            glDisable(GL_CULL_FACE);
        }
        break;
 
    default:
        ;
    }
    glutPostRedisplay();
}
 
 
void mouseCB(int button, int state, int x, int y)
{
    mouseX = x;
    mouseY = y;
 
    if(button == GLUT_LEFT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseLeftDown = true;
        }
        else if(state == GLUT_UP)
            mouseLeftDown = false;
    }
 
    else if(button == GLUT_RIGHT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseRightDown = true;
        }
        else if(state == GLUT_UP)
            mouseRightDown = false;
    }
 
    else if(button == GLUT_MIDDLE_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseMiddleDown = true;
        }
        else if(state == GLUT_UP)
            mouseMiddleDown = false;
    }
}
 
 
void mouseMotionCB(int x, int y)
{
    if(mouseLeftDown)
    {
        cameraAngleY += (x - mouseX);
        cameraAngleX += (y - mouseY);
        mouseX = x;
        mouseY = y;
    }
    if(mouseRightDown)
    {
        cameraDistance += (y - mouseY) * 0.2f;
        mouseY = y;
    }
 
    glutPostRedisplay();
}
 

Nach oben

Conan

Betreff des Beitrags:

Verfasst: Do Sep 06, 2007 11:53

DGL Member

Registriert: Di Nov 07, 2006 13:37
Beiträge: 83
Wohnort: Partenheim

Hallo Frank!

Ich bin nicht so sehr vertraut mit C++, daher kann ich dir nicht genau sagen, was mit deinem Code alles nicht stimmt, aber so einiges fällt mir da schon auf. :lol:

Die Initialisierung des VBOs würde ich z.B. nicht während des Renderns ausführen.
Ich hab' dir mal ein bisschen ungetesteten (es ist wohl eher Pseudo-) Code gebastelt.
Alle "<>"-Kommentare sind Platzhalter für entsprechenden C++-Code.
Ich hab' die Methode ohne IndexArray benutzt, da sie einfacher zu verstehen ist. Jeglicher, VBO-bezogener, Code ist hier enthalten. Beim Rendern sparst du dir also alle übrigen VBO-Funktionen wie glVertexPointer, glEnableClientState, ...

Viel Erfolg (davon gehe ich aus),
Conan

Code:

struct TVertex;
{
  GLFloat ColR;
  GLFloat ColG;
  GLFloat ColB;
  GLFloat ColA;
  GLFloat NorX;
  GLFloat NorY;
  GLFloat NorZ;
  GLFloat X;
  GLFloat Y;
  GLFloat Z;
}
 
 
int main()
{
  ...
  // Create VBO:
  glGenBuffersARB(1, @vboId);
  // Bind VBO:
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId);
  glEnableClientState(GL_VERTEX_ARRAY);
  // Set VBOs size:
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, <SIZE>, nil, GL_STATIC_DRAW_ARB);
  // Get Pointer to write into VBO:
  VBOPointer = glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
 
 
  <Create a Pointer to your TVertex (here: VertPointer)>
 
  // For each Face do ...
  for (...)
    // For each Face's Vertex do ...
    for (...)
    {
      // Upload the VertexData into the VBO:
      VertPointer      = VBOPointer;
      VertPointer.ColR = <the "R"-Value of this Vertex' Color>
      VertPointer.ColG = <the "G"-Value of this Vertex' Color>
      VertPointer.ColB = <the "B"-Value of this Vertex' Color>
      VertPointer.ColA = <the "A"-Value of this Vertex' Color>
      VertPointer.NorX = <the "X"-Value of this Vertex' Normal>
      VertPointer.NorY = <the "Y"-Value of this Vertex' Normal>
      VertPointer.NorZ = <the "Z"-Value of this Vertex' Normal>
      VertPointer.X    = <the "X"-Coord of this Vertex>
      VertPointer.Y    = <the "Y"-Coord of this Vertex>
      VertPointer.Z    = <the "Z"-Coord of this Vertex>
 
      <include VBOPointer by Size of TVertex (here: 40 bytes)>
    }
 
  // Unmap, to enable VBO:
  glUnMapBufferARB(GL_ARRAY_BUFFER_ARB);
}
 
 
void Draw()
{
  // Draw VBO:
  glInterleavedArrays(GL_C4F_N3F_V3F, <Size Of TVertex (here: 40 bytes)>, nil);
  glDrawArrays(GL_QUADS, 0, <Count of uploaded Vertices>);
}

_________________
THE TRUTH IS NOT OUT THERE!

Nach oben

framueller

Betreff des Beitrags:

Verfasst: Fr Sep 07, 2007 13:38

DGL Member

Registriert: Fr Aug 31, 2007 07:25
Beiträge: 12

Sorry,ich verstehe es nicht,liegt vielleicht aber auch daran,dass ich mit c++ programmiere... :-(

((Hab jetzt mehrere Dinge probiert,aber es klappt nicht

Nach oben

Conan

Betreff des Beitrags:

Verfasst: Sa Sep 08, 2007 13:41

DGL Member

Registriert: Di Nov 07, 2006 13:37
Beiträge: 83
Wohnort: Partenheim

Nicht aufgeben :wink:

Ich schick' mal 'nen Link zu diesem Thread an jemanden, der sich besser mit C++ auskennt.

Conan

_________________
THE TRUTH IS NOT OUT THERE!

Nach oben

framueller

Betreff des Beitrags:

Verfasst: Sa Sep 08, 2007 16:52

DGL Member

Registriert: Fr Aug 31, 2007 07:25
Beiträge: 12

super,sehr nett von dir!!!

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Di Jan 08, 2008 16:57

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

ups.

man bin ich blöd.

hab antworten statt neuer Thread geklickt.

Bitte löschen.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Nach oben

Pellaeon

Betreff des Beitrags:

Verfasst: Di Jan 08, 2008 17:53

DGL Member

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464

Debugge doch erstmal das Programm um zu schauen, an welcher Stelle der Fehler auftritt

_________________
__________
"C++ is the best language for garbage collection principally because it creates less garbage." Bjarne Stroustrup

Zuletzt geändert von Pellaeon am Di Jan 08, 2008 17:57, insgesamt 1-mal geändert.

Nach oben

Pellaeon

Betreff des Beitrags:

Verfasst: Di Jan 08, 2008 17:57

DGL Member

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464

Code:

glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(vertices)+sizeof(normals)+sizeof(colors), 0, GL_STATIC_DRAW_ARB);

Du füllst das VBO garnicht. Da wo deine 0 steht kommt normalerweise der Zeiger auf die Daten hin. Oder du musst mappen und die Daten dann direkt in das VBO schreiben.

_________________
__________
"C++ is the best language for garbage collection principally because it creates less garbage." Bjarne Stroustrup

Nach oben

Seite 1 von 1

[ 12 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.