Grafik-,Render-Engine,OpenGL.

dot

Ja, das wird sogar ganz bestimmt der Fehler sein. In jedem Fall solltest du lernen, wie man einen Debugger benutzt; das ist für einen Programmierer in etwa so essentiell, wie für einen Tennisspieler die Fähigkeit zu laufen...

coder++

Ok,thx.

coder++

Sorry,dass ich das Thema nochmal aufgreife,aber es funktioniert immer noch nicht(der Debugger,sagt auch nicht mehr dazu):
Wenn ich das Programm starte,kommt eine Fehlermeldung,dass der Prozedureinstiegspunkt "Glewinit()" nicht gefunden werden konnte.

Nathan

Wie erstellst du das Fenster und den OpenGL Context?

coder++

Das Fenster erstelle ich komplett mit der WinAPI und den OpenGL-Kontext direkt mit OpenGL.

cooky451

Schade nur, dass OpenGL keinen Context erstellen kann.

coder++

cooky451 schrieb:

Schade nur, dass OpenGL keinen Context erstellen kann.

Wie meinst du das?

Nathan

Du musst den OpenGL Kontext auch mit einer WinAPI-OpenGL Erweiterung erstellen, wglCreateContext(), sagt dir das was?
Zeig mal den Code fürs Fenster, da wird der Fehler liegen.

coder++

Ok.

//Bildschirmsauflösung
    BBreite = 1280;
    BHoehe = 1024;
    AufloesungX = BBreite;
    AufloesungY = BHoehe;

    WNDCLASS wclass;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG message;

    //Fenster-Klasse
    wclass.style = NULL;
    wclass.lpfnWndProc = WndProc;
    wclass.cbClsExtra = 0;
    wclass.cbWndExtra = 0;
    wclass.hInstance = hInstance;
    wclass.hIcon = LoadIcon(hInstance,(LPCSTR)EndofEarthicon);
    wclass.hCursor = LoadCursor(NULL,IDC_ARROW);
    wclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wclass.lpszMenuName = NULL;
    wclass.lpszClassName = "Fenster";
    RegisterClass(&wclass);

    //Maus unsichtbar machen
    ShowCursor(false);

    //Fenster erstellen
    hwnd = CreateWindow("Fenster","End of Earth",
                        WS_POPUPWINDOW,
                        0,0,
                        BBreite,BHoehe,
                        NULL,NULL,
                        hInstance,NULL);

cooky451

http://www.opengl.org/wiki/Creating_an_OpenGL_Context_(WGL)

coder++

Achso,das meinst du.
Hab ich auch:

PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    *hDC = GetDC (hWnd);

    ZeroMemory (&pfd,sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat(*hDC,&pfd);
    SetPixelFormat(*hDC,iFormat,&pfd);

    *hRC = wglCreateContext(*hDC);
    wglMakeCurrent(*hDC,*hRC);

Nathan

Ah, du hantierst mit Pointern rum.
Sieht gut aus - also eher schlecht.
Zeig bitte mal ein vollständiges Minimalbeispiel oder den ganzen Code, wenns nicht zuviel ist.
Es könnte aber daran liegen, dass wglCreateContext() failed, prüfe mal den Rückgabetyp.

coder++

Ok,hier main.cpp:

////////////////
//End of Earth//
////////////////

//Projekt
#include <main.h>

//Win-Main
LRESULT CALLBACK WndProc(HWND hwnd,UINT message,
                         WPARAM wParam,LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,int iCmdShow)
{
    //Bildschirmsauflösung
    BBreite = 1280;
    BHoehe = 1024;
    AufloesungX = BBreite;
    AufloesungY = BHoehe;

    WNDCLASS wclass;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG message;

    //Fenster-Klasse
    wclass.style = NULL;
    wclass.lpfnWndProc = WndProc;
    wclass.cbClsExtra = 0;
    wclass.cbWndExtra = 0;
    wclass.hInstance = hInstance;
    wclass.hIcon = LoadIcon(hInstance,(LPCSTR)EndofEarthicon);
    wclass.hCursor = LoadCursor(NULL,IDC_ARROW);
    wclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wclass.lpszMenuName = NULL;
    wclass.lpszClassName = "Fenster";
    RegisterClass(&wclass);

    //Maus unsichtbar machen
    ShowCursor(false);

    //Fenster erstellen
    hwnd = CreateWindow("Fenster","End of Earth",
                        WS_POPUPWINDOW,
                        0,0,
                        BBreite,BHoehe,
                        NULL,NULL,
                        hInstance,NULL);

    //SuperReal-Engine starten
    srStarten(hwnd,&hDC,&hRC);

    //Laden
    int Zeit = 0;
    int Zeitalt = 0;
    int Ladezeit = 0;
    int Ladezeitalt = 0;
    Ladezeitalt = GetTickCount();
    Zeitalt = GetTickCount();
    srErstelleObjekt Spieler;
    Zeit = GetTickCount();
    cout<<"\nObjekt erstellen \x22Spieler\x22 ("<<sizeof(Spieler)<<" Bytes): "<<Zeit - Zeitalt<<" ms\n";
    Zeitalt = GetTickCount();
    Spieler.LadeX("Data/Modell/Mensch.x","Data/Textur/");
    Zeit = GetTickCount();
    cout<<"\nDirectX 3D-Datei laden \x22Spieler\x22 (237.568 Bytes): "<<Zeit - Zeitalt<<" ms\n";
    Ladezeit = GetTickCount();
    cout<<"\nGeladen in "<<Ladezeit - Ladezeitalt<<" ms\n\n\n";

    //Shader
    /*
    cout<<"\nLade Shader...\n";
    srSchreibeShader("Data/Temp/Shader","void main()\n{\n    gl_Position = ftransform ();\n}","void main()\n{\n}");
    GLuint Testshader;
    srInstalliereShader(Testshader,"Data/Temp/Shader","Data/Temp/Shader");
    srLoescheShader("Data/Temp/Shader");
    cout<<"\nShader geladen\n";
    */

    //Zeige Fenster
    ShowWindow(hwnd,iCmdShow);

    //Hauptschleife
    while (!Verlassen)
    {
        //Nachrichten überprüfen
        if (PeekMessage(&message,NULL,0,0,PM_REMOVE))
        {
            if (message.message == WM_QUIT)
            {
                Verlassen = true;
            }
            else
            {
                TranslateMessage(&message);
                DispatchMessage(&message);
            }
        }
        else
        {
            //Anfang der Hauptschleife
            srSchleifenAnfang();

            //Kamera
            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
            glLoadMatrixf(ProjMatrix1);
            glViewport(0,0,AufloesungX,AufloesungY);
            gluPerspective(60.0f,(GLfloat)BBreite / (GLfloat)BHoehe,0.1f,1000.0f);
            glRotated(Kameravertikal,1.0,0.0,0.0); //Kamera vertikal drehen
            glRotated(-Kamerahorizontal + 90,0.0,1.0,0.0); //Kamera horizontal drehen
            Laufen();
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            glLoadMatrixf(ModelMatrix1);

            //Rendern
            srRender(0.0,0.5,0.75,1.0);

            //An/-Ausschalten
            glEnable(GL_NORMALIZE);
            glEnable(GL_DEPTH_TEST);
            glEnable(GL_LIGHTING);
            glEnable(GL_BLEND);
            glEnable(GL_TEXTURE_2D);
            glShadeModel(GL_SMOOTH);

            /////////
            //Szene//
            /////////

            //Licht
            glEnable(GL_LIGHT0);
            GLfloat Lichtposition1[4] = {0.0,3.0,1.0,1.0};
            GLfloat Lichtkegel1 = 180.0;
            GLfloat LichtAmbient1[4] = {0.3f,0.3f,0.3f,1.0f};
            glLightfv(GL_LIGHT0,GL_AMBIENT,&LichtAmbient1[0]);

            //Objekte
            glScalef(0.01,0.01,0.01);
            Zeitalt = GetTickCount();
            Spieler.Render();
            Zeit = GetTickCount();

            //////////////////
            //Ende der Szene//
            //////////////////

            //Matrizen holen
            glGetFloatv(GL_PROJECTION_MATRIX,&ProjMatrix[0]);
            glGetFloatv(GL_MODELVIEW_MATRIX,&ModelMatrix[0]);

            //Buffer
            srBuffer(hDC);

            //Bearbeitung
            srSofort();

            //Ausgabe
            cout<<"\rRendern von Objekten("<<sizeof(Spieler)<<" Bytes): "<<Zeit - Zeitalt<<" ms ";
            cout<<"FPS"<<FPS;

            //Ende der Hauptschleife
            srSchleifenEnde();
        }
    }
    srBeenden(hwnd,hDC,hRC);
    return 0;
}

Falls du die Dateien meiner Engine benötigst,dann schreib es bitte.

Nathan

Die srStarten() Funktion bitte.

coder++

////////////////////
//SuperReal-Engine//
////////////////////

//WinAPI
#include <windows.h>
#include <commctrl.h>

//C++
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string.h>
#include <math.h>
#include <vector>
#include <cassert>

using namespace std;

//OpenGL mit Erweiterungen
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/glui.h>
#include <GL/GLAux.h>
#include <GL/glext.h>

//Simple OpenGL Image Library
#include <SOIL.h>

//Deklerationen
bool srOpenGLaktiv = false;
int Startzeit; //Startzeit der Hauptschleife
int Endzeit; //Endzeit der Hauptschleife
int Zwischenzeit; //Zeit zwischen Endzeit und Startzeit
float FPS; //Bilder pro Sekunde(FPS)

//Engine
#include <Container/Container.h>
#include <Datei/Datei.h>
#include <Shader/Shader.h>
#include <Render/Render.h>
#include <Textur/Textur.h>
#include <Objekt/Objekt.h>
#include <Mesh/Mesh.h>

//SuperReal starten
void srStarten(HWND hWnd,HDC *hDC,HGLRC *hRC)
{
    //OpenGL initialisieren
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    *hDC = GetDC (hWnd);

    ZeroMemory (&pfd,sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat(*hDC,&pfd);
    SetPixelFormat(*hDC,iFormat,&pfd);

    *hRC = wglCreateContext(*hDC);
    wglMakeCurrent(*hDC,*hRC);
    srOpenGLaktiv = true;
}

//SuperReal beenden
void srBeenden(HWND hWnd,HDC hDC,HGLRC hRC)
{
    //OpenGL aufräumen
    wglMakeCurrent(NULL,NULL);
    wglDeleteContext(hRC);
    ReleaseDC (hWnd,hDC);
    srOpenGLaktiv = false;
}

//Anfang Hauptschleife
void srSchleifenAnfang()
{
    //Startzeit
    Startzeit = GetTickCount();

    //Zwischenzeit
    Zwischenzeit = Startzeit - Endzeit;
}

//Ende Hauptschleife
void srSchleifenEnde()
{
    //Endzeit
    Endzeit = GetTickCount();

    //FPS
    if (Endzeit > Startzeit)
    {
        FPS = (float)(1000.0 / (Endzeit - Startzeit));
    }
}

Nathan

Wo rufst du glewInit() auf?

coder++

Am Ende der srStarten-Funktion.
Hab sie jetzt nur nicht mehr drinnen,da sonst das Programm immer abbricht.

Also so:

void srStarten(HWND hWnd,HDC *hDC,HGLRC *hRC)
{
    //OpenGL initialisieren
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    *hDC = GetDC (hWnd);

    ZeroMemory (&pfd,sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat(*hDC,&pfd);
    SetPixelFormat(*hDC,iFormat,&pfd);

    *hRC = wglCreateContext(*hDC);
    wglMakeCurrent(*hDC,*hRC);
    srOpenGLaktiv = true;

    Glewinit(); //Könnte sein das ich Glewinit falsch geschrieben hab :) 
}

Geh jetzt aus dem Forum bis Morgen raus.
Also kann auf keine Fragen mehr antworten.
Ciau