OpenGL Programm für Windows unter Linux kompilieren?

Dieses Thema im Forum "C/C++" wurde erstellt von cyberclaw, 24.03.2007.

  1. #1 cyberclaw, 24.03.2007
    cyberclaw

    cyberclaw Grünschnabel

    Dabei seit:
    24.03.2007
    Beiträge:
    2
    Zustimmungen:
    0
    Huhu!
    Habe ein kleines OpenGL Programm unter Linux geschrieben und möchte das nun auch unter Windows starten können.

    Gibt es da irgendeine gute Möglichkeit mir auch unter Linux ne windowsfähige Version zu kompilieren.

    Habs auch schon unter Windows versucht zu kompilieren, aber das hat nicht geklappt. Verstehe nicht so richtig, wie ich 1. freeglut installiere 2. den code für windows umschreiben kann.

    Anbei auch mal der Code.

    Code:
    #include <GL/glut.h>    // Header File For The GLUT Library 
    #include <GL/gl.h>	// Header File For The OpenGL32 Library
    #include <GL/glu.h>	// Header File For The GLu32 Library
    #include <stdio.h>      // Header file for standard file i/o.
    #include <stdlib.h>     // Header file for malloc/free.
    #include <unistd.h>     // needed to sleep.
    
    
    float move=0.0f;
    
    /* storage for one texture  */
    int texture[1];
    
    /* Image type - contains height, width, and data */
    struct Image {
        unsigned long sizeX;
        unsigned long sizeY;
        char *data;
    };
    typedef struct Image Image;
    
    // quick and dirty bitmap loader...for 24 bit bitmaps with 1 plane only.  
    // See http://www.dcs.ed.ac.uk/~mxr/gfx/2d/BMP.txt for more info.
    int ImageLoad(char *filename, Image *image) {
        FILE *file;
        unsigned long size;                 // size of the image in bytes.
        unsigned long i;                    // standard counter.
        unsigned short int planes;          // number of planes in image (must be 1) 
        unsigned short int bpp;             // number of bits per pixel (must be 24)
        char temp;                          // temporary color storage for bgr-rgb conversion.
    
        // make sure the file is there.
        if ((file = fopen(filename, "rb"))==NULL)
        {
    	printf("File Not Found : %s\n",filename);
    	return 0;
        }
        
        // seek through the bmp header, up to the width/height:
        fseek(file, 18, SEEK_CUR);
    
        // read the width
        if ((i = fread(&image->sizeX, 4, 1, file)) != 1) {
    	printf("Error reading width from %s.\n", filename);
    	return 0;
        }
        printf("Width of %s: %lu\n", filename, image->sizeX);
        
        // read the height 
        if ((i = fread(&image->sizeY, 4, 1, file)) != 1) {
    	printf("Error reading height from %s.\n", filename);
    	return 0;
        }
        printf("Height of %s: %lu\n", filename, image->sizeY);
        
        // calculate the size (assuming 24 bits or 3 bytes per pixel).
        size = image->sizeX * image->sizeY * 3;
    
        // read the planes
        if ((fread(&planes, 2, 1, file)) != 1) {
    	printf("Error reading planes from %s.\n", filename);
    	return 0;
        }
        if (planes != 1) {
    	printf("Planes from %s is not 1: %u\n", filename, planes);
    	return 0;
        }    glTexCoord2f(0.0,1.0); 
    
        // read the bpp
        if ((i = fread(&bpp, 2, 1, file)) != 1) {
    	printf("Error reading bpp from %s.\n", filename);
    	return 0;
        }
        if (bpp != 24) {
    	printf("Bpp from %s is not 24: %u\n", filename, bpp);
    	return 0;
        }
    	
        // seek past the rest of the bitmap header.
        fseek(file, 24, SEEK_CUR);
    
        // read the data. 
        image->data = (char *) malloc(size);
        if (image->data == NULL) {
    	printf("Error allocating memory for color-corrected image data");
    	return 0;	
        }
    
        if ((i = fread(image->data, size, 1, file)) != 1) {
    	printf("Error reading image data from %s.\n", filename);
    	return 0;
        }
    
        for (i=0;i<size;i+=3) { // reverse all of the colors. (bgr -> rgb)
    	temp = image->data[i];
    	image->data[i] = image->data[i+2];
    	image->data[i+2] = temp;
        }
        
        // we're done.
        return 1;
    }
        
    // Load Bitmaps And Convert To Textures
    void LoadGLTextures() {	
        // Load Texture
        Image *image1;
        
        // allocate space for texture
        image1 = (Image *) malloc(sizeof(Image));
        if (image1 == NULL) {
    	printf("Error allocating space for image");
    	exit(0);
        }
    
        if (!ImageLoad("msn.bmp", image1)) {
    	exit(1);
        }        
    
        // Create Texture	
        glGenTextures(1, &texture[0]);
        glBindTexture(GL_TEXTURE_2D, texture[0]);   // 2d texture (x and y size)
    
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture
    
        // 2d texture, level of detail 0 (normal), 3 components (red, green, blue), x size from image, y size from image, 
        // border 0 (normal), rgb color data, unsigned byte data, and finally the data itself.
        glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data);
    };
    
    void init(void)
    {
      glClearColor(0.0, 0.0, 0.0, 0.0);
      
      LoadGLTextures();				// Load The Texture(s) 
      glEnable(GL_TEXTURE_2D);			// Enable Texture Mapping
    
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
    
      glOrtho(-5.0, 5.0, -5.0, 5.0, -5.0, 5.0);
      glMatrixMode(GL_MODELVIEW);
    }
    
    void display(void)
    
    {
    
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        glLoadIdentity();
        move+=0.03f;
    
        glClearDepth(1.0);
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LESS);
        
    
        //Koordinatensystem f. linken Wuerfel anzeigen
    /*  glPushMatrix();
        glTranslatef(-2.0, 0.0, 0.0);
        glRotatef(move,0.5,0.7,0.3);
        glRotatef(move,0.0,0.5,0.0);
    
        glLineWidth(2.0);
        glBegin(GL_LINES);
        glColor3f(1.0,1.0,1.0);
        glVertex3f(-5.0,0.0,0.0);
        glVertex3f(5.0,0.0,0.0);
    
        glVertex3f(0.0,-5.0,0.0);
        glVertex3f(0.0,5.0,0.0);
    
        glVertex3f(0.0,0.0,-5.0);
        glVertex3f(0.0,0.0,5.0);
        glEnd();
        glPopMatrix();
    */
    
        //linken Wuerfel anzeigen
        glPushMatrix();
        glColor3f(1.0,1.0,1.0);
    
        glTranslatef(0.0, 0.0, 0.0);  //Punkt um den sich der Würfel dreht
    
        glRotatef(move,0.5,0.7,0.3);
        glRotatef(move,0.0,0.5,0.0);
    
        glTranslatef(-3.0,0.0,0.0);   //Startpunkt des Würfels
    
        glRotatef(move,0.5,0.7,0.3);
        glRotatef(move,0.0,0.5,0.0);
    
    
        glBindTexture(GL_TEXTURE_2D, texture[0]);   //Welche Textur soll benutzt werden
    
        glBegin(GL_QUADS);
        //Vorderseite X
        //glColor3f(1.0, 0.0, 0.0);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.5, 0.5, 0.5);  //Oben Links
        glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.5, 0.5, 0.5);  //Oben Rechts
        glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5,-0.5, 0.5);  //Unten Rechts
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5,-0.5, 0.5);  //Unten Links
    
        //Rückseite X
        //glColor3f(0.0, 1.0, 0.0);
        glTexCoord2f(0.0,1.0); glVertex3f(-0.5, 0.5, -0.5);  //Oben Links
        glTexCoord2f(1.0,1.0); glVertex3f( 0.5, 0.5, -0.5);  //Oben Rechts
        glTexCoord2f(1.0,0.0); glVertex3f( 0.5,-0.5, -0.5);  //Unten Rechts
        glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5, -0.5);  //Unten Links 
    
        //Unterseite X
        //glColor3f(0.0, 0.0, 1.0);
        glTexCoord2f(0.0,1.0); glVertex3f(-0.5,-0.5, 0.5);
        glTexCoord2f(1.0,1.0); glVertex3f( 0.5,-0.5, 0.5);
        glTexCoord2f(1.0,0.0); glVertex3f( 0.5,-0.5,-0.5);
        glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
    
        //Oberseite X
        //glColor3f(1.0, 1.0, 0.0);
        glTexCoord2f(0.0,1.0); glVertex3f(-0.5, 0.5, 0.5);
        glTexCoord2f(1.0,1.0); glVertex3f( 0.5, 0.5, 0.5);
        glTexCoord2f(1.0,0.0); glVertex3f( 0.5, 0.5,-0.5);
        glTexCoord2f(0.0,0.0); glVertex3f(-0.5, 0.5,-0.5);
    
        //linke Seite X
        //glColor3f(1.0, 0.5, 0.6);
        glTexCoord2f(0.0,1.0); glVertex3f(-0.5, 0.5,-0.5);
        glTexCoord2f(1.0,1.0); glVertex3f(-0.5, 0.5, 0.5);
        glTexCoord2f(1.0,0.0); glVertex3f(-0.5,-0.5, 0.5);
        glTexCoord2f(0.0,0.0); glVertex3f(-0.5,-0.5,-0.5);
    
        //rechte Seite X
        //glColor3f(1.0, 0.8, 0.2);
        glTexCoord2f(0.0,1.0); glVertex3f(0.5, 0.5,-0.5);
        glTexCoord2f(1.0,1.0); glVertex3f(0.5, 0.5, 0.5);
        glTexCoord2f(1.0,0.0); glVertex3f(0.5,-0.5, 0.5);
        glTexCoord2f(0.0,0.0); glVertex3f(0.5,-0.5,-0.5);
        glEnd();
        glPopMatrix();
    
        //Koordinatensystem f. rechten Wuerfel anzeigen
        glPushMatrix();
        glTranslatef(0.0, 0.0, 0.0);
        glRotatef(move,0.2,0.3,0.8);
        glRotatef(move,0.0,1.0,0.0);
        glLineWidth(2.0);
    
        glBegin(GL_LINES);
        glColor3f(1.0,1.0,1.0);
        glVertex3f(-2.0,0.0,0.0);
        glVertex3f(2.0,0.0,0.0);
    
        glVertex3f(0.0,-2.0,0.0);
        glVertex3f(0.0,2.0,0.0);
    
        glVertex3f(0.0,0.0,-2.0);
        glVertex3f(0.0,0.0,2.0);
        glEnd();
        glPopMatrix();
    
        //rechten Wuerfel anzeigen
        glPushMatrix();
        glTranslatef(0.0, 0.0, 0.0);
        glRotatef(move,0.2,0.3,0.8);
        glRotatef(move,0.0,1.0,0.0);
    
        glBegin(GL_QUADS);
        //Vorderseite X
        glColor3f(0.0, 1.0, 0.0);
        glVertex3f(-1.0, 1.0, -1.0);
        glColor3f(1.0, 1.0, 0.0);
        glVertex3f( 1.0, 1.0, -1.0);
        glColor3f(1.0, 0.0, 0.0);
        glVertex3f( 1.0,-1.0, -1.0);
        glColor3f(0.0, 0.0, 0.0);
        glVertex3f(-1.0,-1.0, -1.0);
    
        //Rückseite X
        glColor3f(0.0, 1.0, 1.0);
        glVertex3f(-1.0, 1.0, 1.0);
        glColor3f(1.0, 1.0, 1.0);
        glVertex3f( 1.0, 1.0, 1.0);
        glColor3f(1.0, 0.0, 1.0);
        glVertex3f( 1.0,-1.0, 1.0);
        glColor3f(0.0, 0.0, 1.0);
        glVertex3f(-1.0,-1.0, 1.0);
    
        //Unterseite X
        glColor3f(0.0, 0.0, 1.0);
        glVertex3f(-1.0,-1.0, 1.0);
        glColor3f(1.0, 0.0, 1.0);
        glVertex3f( 1.0,-1.0, 1.0);
        glColor3f(1.0, 0.0, 0.0);
        glVertex3f( 1.0,-1.0,-1.0);
        glColor3f(0.0, 0.0, 0.0);
        glVertex3f(-1.0,-1.0,-1.0);
    
        //Oberseite X
        glColor3f(0.0, 1.0, 1.0);
        glVertex3f(-1.0, 1.0, 1.0);
        glColor3f(1.0, 1.0, 1.0);
        glVertex3f( 1.0, 1.0, 1.0);
        glColor3f(1.0, 1.0, 0.0);
        glVertex3f( 1.0, 1.0,-1.0);
        glColor3f(0.0, 1.0, 0.0);
        glVertex3f(-1.0, 1.0,-1.0);
    
        //linke Seite X
        glColor3f(0.0, 1.0, 0.0);
        glVertex3f(-1.0, 1.0,-1.0);
        glColor3f(0.0, 1.0, 1.0);
        glVertex3f(-1.0, 1.0, 1.0);
        glColor3f(0.0, 0.0, 1.0);
        glVertex3f(-1.0,-1.0, 1.0);
        glColor3f(0.0, 0.0, 0.0);
        glVertex3f(-1.0,-1.0,-1.0);
    
        //rechte Seite X
        glColor3f(1.0, 1.0, 0.0);
        glVertex3f(1.0, 1.0,-1.0);
        glColor3f(1.0, 1.0, 1.0);
        glVertex3f(1.0, 1.0, 1.0);
        glColor3f(1.0, 0.0, 1.0);
        glVertex3f(1.0,-1.0, 1.0);
        glColor3f(1.0, 0.0, 0.0);
        glVertex3f(1.0,-1.0,-1.0);
        glEnd();
        glPopMatrix();
    
        glutSwapBuffers();
    
    }
    
    
    
    void idle(void){
        display();
    }
    
    int main(int argc, char** argv){
    
      glutInit(&argc, argv);
    
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    
      glutInitWindowSize(800,800);
    
      glutInitWindowPosition(100, 100);
    
      glutCreateWindow("Wuerfel, die sich umeinander drehen");
    
      init();
      glutDisplayFunc(display);
      glutIdleFunc(idle);
    
      glutMainLoop();
    
      return 0;
    
    }
    
    
    Gruß
    CyberClaw
     
  2. Anzeige

    Schau dir mal diese Kategorie an. Dort findest du bestimmt etwas.
    Registrieren bzw. einloggen, um diese und auch andere Anzeigen zu deaktivieren
  3. #2 SkydiverBS, 24.03.2007
    SkydiverBS

    SkydiverBS Tripel-As

    Dabei seit:
    15.01.2005
    Beiträge:
    207
    Zustimmungen:
    0
    Ort:
    Freising
    Willkommen!

    1. Zum Einrichten von OpenGL unter Windows findest du sicher etwas bei Google oder in Windows-Foren. Ich kann allgemein dieses Tutorial empfehlen: http://nehe.gamedev.net/. Informationen zu GLUT gibts auch hier: http://www.3dsource.de/faq/index.htm. Welchen Compiler verwendest du?

    2. Wenn du OpenGL unter Windows zum laufen gebracht hast kannst du dich ja wieder melden. Ich habe nur einen kurzen Blick über dein Programm geworfen aber ich denke es dürfte nicht viel Arbeit sein es unter Windows zum Laufen zu bringen.

    Gruß,
    Philip
     
  4. #3 cyberclaw, 24.03.2007
    cyberclaw

    cyberclaw Grünschnabel

    Dabei seit:
    24.03.2007
    Beiträge:
    2
    Zustimmungen:
    0
    Habs jetzt hinbekommen. Arbeite nun mit DevC++ und kompilieren klappt auch ohne Probleme, abbbberrrr :)
    die Geschwindigkeit der Bewegungen sind unterschiedlich:
    Notebook -> Langsam
    PC -> normal
    PC von Bekanntem -> normal
    PC von meinem Dad -> langsam

    Womit kann das zusammenhängen?

    http://www.badongo.com/file/2557276
    Das ist das kompilierte Programm.

    Gruß
    CyberClaw
     
Thema:

OpenGL Programm für Windows unter Linux kompilieren?

Die Seite wird geladen...

OpenGL Programm für Windows unter Linux kompilieren? - Ähnliche Themen

  1. openGL+C Programmen richtig kompelieren

    openGL+C Programmen richtig kompelieren: hab angefangen OpenGL zu lernen, nun hab festgestellt, dass ich meine C-Quelle unter FreeBSD nicht kompellieren kann, bzw. ich sehe keine fehler...
  2. Mesa 11.0 bringt OpenGL 4.1

    Mesa 11.0 bringt OpenGL 4.1: Die Entwickler der freien 3D-Grafikbibliothek Mesa haben die Version 11.0 veröffentlicht. Diese vorläufig noch experimentelle Version hebt die...
  3. Khronos: Fortschritte bei Vulkan und Erweiterungen für openGL und OpenGL ES

    Khronos: Fortschritte bei Vulkan und Erweiterungen für openGL und OpenGL ES: Die Khronos Group, ein Branchenkonsortium zum Entwickeln von Grafik- und Parallelberechnungs-Standards, hat die Spezifikation OpenGL ES in Version...
  4. OpenGL-Nachfolger Vulkan angekündigt

    OpenGL-Nachfolger Vulkan angekündigt: Die Khronos Group hat den Nachfolger der Standardschnittstelle für 3D-Grafik enthüllt. Die kommende Spezifikation trägt den Namen Vulkan und steht...
  5. Khronos kündigt Next-Gen-Version von OpenGL an

    Khronos kündigt Next-Gen-Version von OpenGL an: Die Khronos Group, das Inustriekonsortium hinter dem Standard für die plattform- und programmiersprachenunabhängige 3D-Grafik-Entwicklung, hat...