Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » 3D Würfel geht nicht

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
11.06.2004, 21:06 Uhr
Lensflare



hallo.

ich bin das tutorial von NeHe durchgegangen und habe andere tutorials gelesen, wo beschrieben ist, wie man einen Würfel erstellt und rotieren lässt...
im prinzip hab ich ja kein problem damit, nur, wenn ich per glTranslatef() die kamera zurückbewege, damit ich nicht im würfel drin bin, passieren merkwürdige sachen...

1) Der Würfel wird von einer art wand verdeckt, die direkt vor der kamera sitzt und die selbe farbe hat, mit der ich jeden neuen frame übermale. Mit glClearColor(0.0f, 0.0f, 0.0f, 0.0f) also schwarz.

und 2) wenn der würfel sich so dreht, dass eigentlich nun die rückseite zu sehen sein müsste, dann sieht man trotzdem die vorderseite als fläche. Ich weiss zwar woran es liegt... denn die fläche, die zuletzt gezeichnet wird, übermalt alle anderen und ist somit im vordergrund.
Aber wie kann ich das verhindern?

Das komische daran ist auch, dass ich sogar den gesamten code 1:1 aus dem tutorial rauskopiert hab und es sah nicht besser aus.

Ich hab so das gefühl, als wäre bei mir der 3D Modus nicht aktiv oder so.
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
11.06.2004, 21:13 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


Hi, das problem kenn ich. Bei folgendem Würfel passiert dies glaube ich nicht, musst du mal testen:


C++:
#include <windows.h>                                        // Header File For Windows
#include <stdio.h>                                            // Header File For Standard Input/Output
#include <gl\gl.h>                                            // Header File For The OpenGL32 Library
#include <gl\glu.h>                                            // Header File For The GLu32 Library
#include <gl\glaux.h>                                        // Header File For The GLaux Library

class Vector3D
{
public:
    Vector3D(GLfloat x,GLfloat y,GLfloat z);
    GLfloat x;
    GLfloat y;
    GLfloat z;
};

Vector3D::Vector3D(GLfloat xl,GLfloat yl,GLfloat zl)
{
    x = xl;
    y = yl;
    z = zl;
}

#define TEXTURE_MAX 6

HDC   hDC  = NULL;                                            // Permanent Rendering Context
HWND  hWnd = NULL;                                            // Private GDI Device Context
HGLRC hRC  = NULL;                                            // Holds Our Window Handle

bool keys[256];                                                // Array Used For The Keyboard Routine
bool active     = TRUE;                                        // Window Active Flag Set To TRUE By Default
bool fullscreen = TRUE;                                        // Fullscreen Flag Set To Fullscreen Mode By Default

Vector3D rot(0.0f,128.0f,45.0f);                            // Rotation

Vector3D pos(0.0f,0.0f,-5.0f);                                // Position

GLuint  texture[TEXTURE_MAX];                                // Storage For One Texture

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);        // Declaration For WndProc

AUX_RGBImageRec *LoadBMP(char *Filename)                    // Loads A Bitmap Image
{
    FILE *File=NULL;                                        // File Handle
    if (!Filename)                                            // Make Sure A Filename Was Given
    {
        return NULL;                                        // If Not Return NULL
    }
    
    File=fopen(Filename,"r");                                // Check To See If The File Exists
    
    if (File)                                                // Does The File Exist?
    {
        fclose(File);                                        // Close The Handle
        return auxDIBImageLoad(Filename);                    // Load The Bitmap And Return A Pointer
    }
    return NULL;                                            // If Load Failed Return NULL
}

int LoadGLTextures()                                        // Load Bitmaps And Convert To Textures
{
    int Status=FALSE;                                        // Status Indicator
    int loop = 0;
    AUX_RGBImageRec *TextureImage[TEXTURE_MAX];                        // Create Storage Space For The Texture
    memset(TextureImage,0,sizeof(void *)*TEXTURE_MAX);                // Set The Pointer To NULL
    char filename[_MAX_PATH];
    
    for(loop=1; loop<TEXTURE_MAX+1; loop++)
    {
        sprintf(filename,"bitmap%d.bmp",loop);
        TextureImage[loop-1]=LoadBMP(filename);
    }
    
    Status=TRUE;                                        // Set The Status To TRUE
    glGenTextures(TEXTURE_MAX, &texture[0]);                        // Create Two Texture
    
    for (loop=0; loop<TEXTURE_MAX; loop++)
    {
        glBindTexture(GL_TEXTURE_2D, texture[loop]);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[loop]->sizeX, TextureImage[loop]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[loop]->data);
    }
    
    for (loop=0; loop<TEXTURE_MAX; loop++)
    {
        if (TextureImage[loop])                                // If Texture Exists
        {
            if (TextureImage[loop]->data)                    // If Texture Image Exists
            {
                free(TextureImage[loop]->data);                // Free The Texture Image Memory
            }
            free(TextureImage[loop]);                        // Free The Image Structure
        }
    }
    return Status;                                            // Return The Status
}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)            // Resize And Initialize The GL Window
{
    if (height==0)                                            // Prevent A Divide By Zero By
    {
        height=1;                                            // Making Height Equal One
    }
    
    glViewport(0, 0, width, height);                        // Reset The Current Viewport
    glMatrixMode(GL_PROJECTION);                            // Select The Projection Matrix
    glLoadIdentity();                                        // Reset The Projection Matrix
    
    // Calculate The Aspect Ratio Of The Window
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
    
    glMatrixMode(GL_MODELVIEW);                                // Select The Modelview Matrix
    glLoadIdentity();                                        // Reset The Modelview Matrix
}

int InitGL(GLvoid)                                            // All Setup For OpenGL Goes Here
{
    if (!LoadGLTextures())                                    // Jump To Texture Loading Routine
    {
        return FALSE;                                        // If Texture Didn't Load Return FALSE
    }
    
    glEnable(GL_TEXTURE_2D);                                // Enable Texture Mapping
    glShadeModel(GL_SMOOTH);                                // Enables Smooth Shading
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);                    // Black Background
    glClearDepth(1.0);                                        // Depth Buffer Setup
    glEnable(GL_DEPTH_TEST);                                // Enables Depth Testing
    glDepthFunc(GL_LEQUAL);                                    // The Type Of Depth Test To Do
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);        // Really Nice Perspective Calculations
    
    return TRUE;                                            // Initialization Went OK
}

int DrawGLScene(GLvoid)                                        // Here's Where We Do All The Drawing
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    
    glTranslatef(pos.x,pos.y,pos.z);
    
    //    xrot = 45.0f;
    //    yrot = 45.0f;
    //    zrot = 45.0f;
    
    glRotatef(rot.x,1.0f,0.0f,0.0f);                            // Rotate On The X Axis
    glRotatef(rot.y,0.0f,1.0f,0.0f);                            // Rotate On The Y Axis
    glRotatef(rot.z,0.0f,0.0f,1.0f);                            // Rotate On The Z Axis
    
    
    glBindTexture(GL_TEXTURE_2D, texture[0]);                // Bitmap mit 1
    glBegin(GL_QUADS);
    // Front Face
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
    glEnd();
    
    glBindTexture(GL_TEXTURE_2D, texture[5]);                // Bitmap mit 6
    glBegin(GL_QUADS);
    // Back Face
    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
    glEnd();
    
    glBindTexture(GL_TEXTURE_2D, texture[4]);                // Bitmap mit 5
    glBegin(GL_QUADS);
    // Top Face
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
    glEnd();
    
    glBindTexture(GL_TEXTURE_2D, texture[1]);                // Bitmap mit 2
    glBegin(GL_QUADS);
    // Bottom Face
    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
    glEnd();
    
    glBindTexture(GL_TEXTURE_2D, texture[2]);                // Bitmap mit 3
    glBegin(GL_QUADS);
    // Right face
    glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
    glEnd();
    
    glBindTexture(GL_TEXTURE_2D, texture[3]);                // Bitmap mit 4
    glBegin(GL_QUADS);
    // Left Face
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
    glEnd();
    
    //    xrot += 0.1f;
    //    yrot += 0.1f;
    //    zrot += 0.1f;
    
    return TRUE;
}




--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
11.06.2004, 21:13 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


fortsetzung:


C++:
GLvoid KillGLWindow(GLvoid)                                    // Properly Kill The Window
{
    
    if (fullscreen)                                            // Are We In Fullscreen Mode?
    {
        ChangeDisplaySettings(NULL,0);                        // If So Switch Back To The Desktop
        ShowCursor(TRUE);                                    // Show Mouse Pointer
    }
    
    if (hRC)                                                // Do We Have A Rendering Context?
    {
        if (!wglMakeCurrent(NULL,NULL))                        // Are We Able To Release The DC And RC Contexts?
        {
            
            MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
        
        if (!wglDeleteContext(hRC))                            // Are We Able To Delete The RC?
        {
            MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
        hRC=NULL;                                            // Set RC To NULL
    }
    
    if (hDC && !ReleaseDC(hWnd,hDC))                        // Are We Able To Release The DC
    {
        MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hDC=NULL;                                            // Set DC To NULL
    }
    
    if (hWnd && !DestroyWindow(hWnd))                        // Are We Able To Destroy The Window?
    {
        MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hWnd=NULL;                                            // Set hWnd To NULL
    }
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
    
    GLuint    PixelFormat;                                    // Holds The Results After Searching For A Match
    HINSTANCE hInstance;                                    // Holds The Instance Of The Application
    WNDCLASS  wc;                                            // Windows Class Structure
    DWORD     dwExStyle;                                    // Window Extended Style
    DWORD     dwStyle;                                        // Window Style
    
    fullscreen = fullscreenflag;                            // Set The Global Fullscreen Flag
    
    hInstance        = GetModuleHandle(NULL);                // Grab An Instance For Our Window
    wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;    // Redraw On Move, And Own DC For Window
    wc.lpfnWndProc   = (WNDPROC) WndProc;                    // WndProc Handles Messages
    wc.cbClsExtra    = 0;                                    // No Extra Window Data
    wc.cbWndExtra    = 0;                                    // No Extra Window Data
    wc.hInstance     = hInstance;                            // Set The Instance
    wc.hIcon         = LoadIcon(NULL, IDI_WINLOGO);            // Load The Default Icon
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);            // Load The Arrow Pointer
    wc.hbrBackground = NULL;                                // No Background Required For GL
    wc.lpszMenuName  = NULL;                                // We Don't Want A Menu
    wc.lpszClassName = "OpenGL";                            // Set The Class Name
    
    if (!RegisterClass(&wc))                                // Attempt To Register The Window Class
    {
        MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Exit And Return FALSE
    }
    
    if (fullscreen)                                            // Attempt Fullscreen Mode?
    {
        
        DEVMODE dmScreenSettings;                            // Device Mode
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));    // Makes Sure Memory's Cleared
        dmScreenSettings.dmSize=sizeof(dmScreenSettings);    // Size Of The Devmode Structure
        dmScreenSettings.dmPelsWidth        = width;        // Selected Screen Width
        dmScreenSettings.dmPelsHeight        = height;        // Selected Screen Height
        dmScreenSettings.dmBitsPerPel        = bits;        // Selected Bits Per Pixel
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
        
        // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
            
        {
            // If The Mode Fails, Offer Two Options.  Quit Or Run In A Window.
            if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
            {
                fullscreen=FALSE;                            // Select Windowed Mode (Fullscreen=FALSE)
            }
            else
            {
                
                // Pop Up A Message Box Letting User Know The Program Is Closing.
                MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
                return FALSE;                                // Exit And Return FALSE
            }
        }
    }
    
    if (fullscreen)                                            // Are We Still In Fullscreen Mode?
    {
        
        dwExStyle=WS_EX_APPWINDOW;                            // Window Extended Style
        dwStyle=WS_POPUP;                                    // Windows Style
        ShowCursor(FALSE);                                    // Hide Mouse Pointer
    }
    else
    {
        
        dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;        // Window Extended Style
        dwStyle=WS_OVERLAPPEDWINDOW;                        // Windows Style
        // Window Style
        
    }
    
    if (!(hWnd=CreateWindowEx(        dwExStyle,            // Extended Style For The Window
        "OpenGL",                                            // Class Name
        title,                                                // Window Title
        WS_CLIPSIBLINGS |                                    // Required Window Style
        WS_CLIPCHILDREN |                                    // Required Window Style
        dwStyle,                                            // Selected Window Style
        0, 0,                                                // Window Position
        width, height,                                        // Selected Width And Height
        NULL,                                                // No Parent Window
        NULL,                                                // No Menu
        hInstance,                                            // Instance
        NULL)))                                                // Don't Pass Anything To WM_CREATE
        
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    static PIXELFORMATDESCRIPTOR pfd =                        // pfd Tells Windows How We Want Things To Be
    {
        sizeof(PIXELFORMATDESCRIPTOR),                        // Size Of This Pixel Format Descriptor
            1,                                                // Version Number
            PFD_DRAW_TO_WINDOW |                            // Format Must Support Window
            PFD_SUPPORT_OPENGL |                            // Format Must Support OpenGL
            PFD_DOUBLEBUFFER,                                // Must Support Double Buffering
            PFD_TYPE_RGBA,                                    // Request An RGBA Format
            bits,                                            // Select Our Color Depth
            0, 0, 0, 0, 0, 0,                                // Color Bits Ignored
            0,                                                // No Alpha Buffer
            0,                                                // Shift Bit Ignored
            0,                                                // No Accumulation Buffer
            0, 0, 0, 0,                                        // Accumulation Bits Ignored
            16,                                                // 16Bit Z-Buffer (Depth Buffer)
            0,                                                // No Stencil Buffer
            0,                                                // No Auxiliary Buffer
            PFD_MAIN_PLANE,                                    // Main Drawing Layer
            0,                                                // Reserved
            0, 0, 0                                            // Layer Masks Ignored
    };
    
    if (!(hDC=GetDC(hWnd)))                                    // Did We Get A Device Context?
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))            // Did Windows Find A Matching Pixel Format?
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    if(!SetPixelFormat(hDC,PixelFormat,&pfd))                // Are We Able To Set The Pixel Format?
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    if (!(hRC=wglCreateContext(hDC)))                        // Are We Able To Get A Rendering Context?
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    if(!wglMakeCurrent(hDC,hRC))                            // Try To Activate The Rendering Context
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    ShowWindow(hWnd,SW_SHOW);                                // Show The Window
    SetForegroundWindow(hWnd);                                // Slightly Higher Priority
    SetFocus(hWnd);                                            // Sets Keyboard Focus To The Window
    ReSizeGLScene(width, height);                            // Set Up Our Perspective GL Screen
    
    if (!InitGL())                                            // Initialize Our Newly Created GL Window
    {
        KillGLWindow();                                        // Reset The Display
        MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                        // Return FALSE
    }
    
    return TRUE;                                            // Success
}

void checkkey(int key)
{
    switch(key)
    {
    case 'G':
        {
            rot.x -= 0.4f;
        } break;
        
    case 'J':
        {
            rot.x += 0.4f;
        } break;
        
    case 'Z':
        {
            rot.y += 0.4f;
        } break;
        
    case 'H':
        {
            rot.y -= 0.4f;
        } break;
        
    case 'T':
        {
            rot.z -= 0.4f;
        } break;
        
    case 'U':
        {
            rot.z += 0.4f;
        } break;
        
    case 'A':
        {
            pos.x -= 0.1f;
        } break;
    case 'D':
        {
            pos.x += 0.1f;
        } break;
    case 'W':
        {
            pos.y += 0.1f;
        } break;
    case 'S':
        {
            pos.y -= 0.1f;
        } break;
    case 'Q':
        {
            pos.z -= 0.1f;
        } break;
    case 'E':
        {
            pos.z += 0.1f;
        } break;
    }
}



--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
11.06.2004, 21:14 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


fortsetzung:


C++:
LRESULT CALLBACK WndProc(HWND   hWnd,                        // Handle For This Window
                         UINT   uMsg,                        // Message For This Window
                         WPARAM wParam,                        // Additional Message Information
                         LPARAM lParam)                        // Additional Message Information
{
    switch (uMsg)                                            // Check For Windows Messages
    {
        
    case WM_ACTIVATE:                                        // Watch For Window Activate Message
        {
            if (!HIWORD(wParam))                            // Check Minimization State
            {
                active=TRUE;                                // Program Is Active
            }
            else
            {
                active=FALSE;                                // Program Is No Longer Active
            }
            
            return 0;                                        // Return To The Message Loop
        }
        
    case WM_KILLFOCUS:
        {
            active=FALSE;                                    // Program Is No Longer Active
            return 0;
        }
        
    case WM_SYSCOMMAND:                                        // Intercept System Commands
        {
            switch (wParam)                                    // Check System Calls
            {
            case SC_SCREENSAVE:                                // Screensaver Trying To Start?
            case SC_MONITORPOWER:                            // Monitor Trying To Enter Powersave?
                return 0;                                    // Prevent From Happening
            }
            break;                                            // Exit
        }
        
    case WM_CLOSE:                                            // Did We Receive A Close Message?
        {
            PostQuitMessage(0);                                // Send A Quit Message
            return 0;                                        // Jump Back
        }
        
    case WM_KEYDOWN:                                        // Is A Key Being Held Down?
        {
            keys[wParam] = TRUE;                            // If So, Mark It As TRUE
            return 0;                                        // Jump Back
        }
        
    case WM_KEYUP:                                            // Has A Key Been Released?
        {
            keys[wParam] = FALSE;                            // If So, Mark It As FALSE
            return 0;                                        // Jump Back
        }
        
    case WM_SIZE:                                            // Resize The OpenGL Window
        {
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));    // LoWord=Width, HiWord=Height
            return 0;                                        // Jump Back
        }
    
    case WM_TIMER:
        {
            for(int x = 0; x < 256; x++)
            {
                if(keys[x]==TRUE)
                {
                    checkkey(x);
                }
            }
        } break;
    }
    
    // Pass All Unhandled Messages To DefWindowProc
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
    
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR     lpCmdLine,int       nCmdShow)
{
    MSG         msg;                                        // Windows Message Structure
    BOOL        done=FALSE;                                    // Bool Variable To Exit Loop
    
    // Ask The User Which Screen Mode They Prefer
    if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
    {
        fullscreen=FALSE;                                    // Windowed Mode
    }
    
    // Create Our OpenGL Window
    if (!CreateGLWindow("OpenGL Würfel Steuerung: AWSD, GZHJ",800,600,16,fullscreen))
    {
        return 0;                                            // Quit If Window Was Not Created
    }
    
    SetTimer(hWnd,1,1,NULL);
    
    while(!done)                                            // Loop That Runs Until done=TRUE
    {
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))            // Is There A Message Waiting?
        {
            if (msg.message==WM_QUIT)                        // Have We Received A Quit Message?
            {
                done=TRUE;                                    // If So done=TRUE
            }
            else                                            // If Not, Deal With Window Messages
            {
                TranslateMessage(&msg);                        // Translate The Message
                DispatchMessage(&msg);                        // Dispatch The Message
            }
        }
        else                                                // If There Are No Messages
        {
            // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
            if ((active && !DrawGLScene()) || keys[VK_ESCAPE])    // Updating View Only If Active
            {
                done=TRUE;                                    // ESC or DrawGLScene Signalled A Quit
            }
            else                                            // Not Time To Quit, Update Screen
            {
                SwapBuffers(hDC);                            // Swap Buffers (Double Buffering)
            }
        }
    }
    
    // Shutdown
    KillGLWindow();                                            // Kill The Window
    return (msg.wParam);                                    // Exit The Program
}


--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
11.06.2004, 23:28 Uhr
Lensflare



Puhh... also erstmal hab ich das ganze mal kopiert und in ein neues projekt gespeichert, doch beim kompilieren gibts folgende 2 fehler:

[Linker error] undefined reference to `auxDIBImageLoadA@4'
[Linker error] undefined reference to `gluPerspective@32'

Könntest du den code bitte auf die stelle beschränken, die wichtig für das "würfelproblem" ist?
Ich weiss einfach nicht ob ich das alles brauche, vielleicht ist es nur eine kleine funktion, die ich einfügen muss, mehr nicht?
Ich bin zwar extrem neugierig, wie man texturen benutzt, aber ich sollte erst einmal die grundlegenden sachen lernen.

Danke im Voraus.
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
12.06.2004, 09:49 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


du kannst dir das komplette Projekt mal hier runterladen
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: