Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 2 of 2

Thread: University Project Submission

  1. #1
    Newbie Newbie
    Join Date
    Dec 2017
    Posts
    1

    University Project Submission

    So,I was working on a isometric view 3D game based on GLUT lib, but I ran into problems like mapping textures to objects. I just can't seem to map textures into objects. The loader can't load the files. Need a mouse control event like when Right Clicking a cylinder will be shot by the ball. Deadline is on this Sunday.
    I couldn't do all the coding.
    Using tutorials from Lighthouse 3D and some other places. I modified, added, removed many parts of the codes.

    The code is given:
    Code :
    #include <windows.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
     
    #ifdef __APPLE__
    #include <GLUT/glut.h>
    #else
    #include <GL/glut.h>
    #endif
    //camera modifiers
    int camX = 0, camY = 0, camZ= 0;
     
    // angle of rotation for the camera direction
    float angle = 0.0f;
    double refresh = 30.0;
    // actual vector representing the camera's direction
    float lx=0.0f,lz=-1.0f;
    int mouseXd,mouseYd;
    int mouseXu,mouseYu;
    // XZ position of the camera
    float x=0.0f, z=5.0f;
     
    // the key states. These variables will be zero
    // when no key is being pressesed
    float deltaAngle = 0.0f;
    float deltaMove = 0;
    int xOrigin = -1;
     
    // color for the snowman's nose
    float red = 1.0f, blue=0.5f, green=0.5f;
     
    // scale of snowman
    float scale = 1.0f;
     
    // default font
    void *font = GLUT_STROKE_ROMAN;
     
    // width and height of the window
    int h,w;
     
    // variables to compute frames per second
    int frame;
    long time, timebase;
    char s[60];
    char currentMode[80];
    float light_pos=0;
    // this string keeps the last good setting
    // for the game mode
    char gameModeString[40] = "640x480";
     
    /*POINT STRUCTURE*/
    typedef struct
    {
        float X;
        float Y;
        float Z;
    } Point;
     
    //CUBE POINTS
    Point p[22];
     
    //IMAGE DATA
    static GLubyte image[20][2048][1768][4];
     
    //a linear array to store image data
    static GLubyte linearImage[20][2048*1768*4];
     
     
    //IMAGE HEIGHT AND WIDTH
    unsigned int imagewidth=0, imageheight=0;
     
    //total size of the image file
    unsigned long fileSize;
     
     
    //texture object number
    static GLuint texName[20];
     
    void init();
     
    void changeSize(int ww, int hh)
    {
     
        h = hh;
        w = ww;
        // Prevent a divide by zero, when window is too short
        // (you cant make a window of zero width).
        if (h == 0)
            h = 1;
     
        float ratio =  w * 1.0 / h;
     
        // Use the Projection Matrix
        glMatrixMode(GL_PROJECTION);
     
        // Reset Matrix
        glLoadIdentity();
     
        // Set the viewport to be the entire window
        glViewport(0, 0, w, h);
     
        // Set the correct perspective.
        gluPerspective(45.0f, ratio, 0.1f, 100.0f);
     
        // Get Back to the Modelview
        glMatrixMode(GL_MODELVIEW);
    }
    void update(int value)
    {
        refresh += 1 ;
        light_pos += 0.1f;
        if(refresh >250)
        {
            refresh -= 250 ;
     
        }
        glutPostRedisplay() ;
        glutTimerFunc(20, update, 0) ;
    }
    void drawGround()
    {
        glBegin(GL_QUADS);
        glColor3f(0.3f,0.5f, 0.6f);
        glVertex3f(-1000.0f, 0.0f, -1000.0f);
     
        glVertex3f(-1000.0f, 0.0f,  1000.0f);
     
        glVertex3f( 1000.0f, 0.0f,  1000.0f);
     
        glVertex3f( 1000.0f, 0.0f, -1000.0f);
        glEnd();
    }
    void buildings()
    {
        //Left
        glPushMatrix();
        glTranslated(0,0,-100+refresh);
        glTranslated(-10,0,0);
        for(int loop=0; loop<10; loop++)
        {
            glTranslated(0,0,-10);
            glColor3f(0.8,0.1,0.1);
            glutSolidCube(5);
        }
     
        for(int loop=0; loop<10; loop++)
        {
            glTranslated(0,0,-100);
            glColor3f(0.8,0.1,0.1);
            glutSolidCube(5);
        }
        glPopMatrix();
        //Distant Right
        glPushMatrix();
        glTranslated(0,0,-100+refresh);
        glTranslated(30,0,5);
        for(int loop=0; loop<10; loop++)
        {
            glTranslated(0,0,-10);
            glColor3f(0.1,0.8,0.2);
            glutSolidCube(5);
        }
     
        for(int loop=0; loop<10; loop++)
        {
            glTranslated(0,0,-100);
            glColor3f(0.96,0.3,0.1);
            glutSolidCube(8);
        }
        glPopMatrix();
        //Close Right
        glPushMatrix();
        glTranslated(0,0,-100+refresh);
        glTranslated(15,0,0);
        for(int loop=0; loop<300; loop+=60)
        {
            glTranslated(0,0,-5);
            glColor3f(0.8,0.1,0.1);
            glutSolidCube(10);
        }
        glPopMatrix();
     
    }
    void character(int xUp, int xDown, int yUp, int yDown)
    {
        glPushMatrix();
        glTranslated( 10*lx,3,0);
        glColor3f(1,1,1);
        glutSolidSphere(0.5,20,20);
        glPopMatrix();
     
    }
    void drawRoad()
    {
        glBegin(GL_QUADS);
        glColor3f(0.1f,0.2f, 0.3f);
        glVertex3f(-5.0f, 1.0f, -1000.0f);
        glVertex3f(-5.0f, 1.0f,  1000.0f);
        glVertex3f( 5.0f, 1.0f,  1000.0f);
        glVertex3f( 5.0f, 1.0f, -1000.0f);
        glEnd();
    }
    void roadMark()
    {
        for(int _val=-10000; _val<50000; _val+=10)
        {
            glPushMatrix();
            glTranslated(0,0,refresh+_val);
            glBegin(GL_QUADS);
            glColor3f(0.8f,0.8f, 0.8f);
            glVertex3f(-0.5f, 1.1f, -1.0f);
            glVertex3f(-0.5f, 1.1f,  1.0f);
            glVertex3f( 0.5f, 1.1f,  1.0f);
            glVertex3f( 0.5f, 1.1f, -1.0f);
            glEnd();
            glPopMatrix();
        }
    }
    void setLight()
    {
        GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
        GLfloat mat_shininess[] = { 2 };
        GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
        glShadeModel (GL_SMOOTH);
     
        glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
        glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
        glLightfv(GL_LIGHT0, GL_POSITION, light_position);
     
     
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
     
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_COLOR_MATERIAL);
    }
    void Sun()
    {
        glColor3f(1.0f,0.6f, 0.3f);
        glTranslatef(0.0f,100.0f,0.0f);
        glutSolidSphere(0.75f,20,20);
    }
    void Tree()
    {
        glColor3f(0.3f,0.2f,0.1f);
        glTranslatef(1.0,1.0,1.0);
        glutSolidCone(0.1,50,5,20);
    }
    void drawSnowMan()
    {
     
        glScalef(scale, scale, scale);
        glColor3f(1.0f, 1.0f, 1.0f);
     
    // Draw Body
        glTranslatef(0.0f,0.75f, 0.0f);
        glutSolidSphere(0.75f,20,20);
     
    // Draw Head
        glTranslatef(0.0f, 1.0f, 0.0f);
        glutSolidSphere(0.25f,20,20);
     
    // Draw Eyes
        glPushMatrix();
        glColor3f(0.0f,0.0f,0.0f);
        glTranslatef(0.05f, 0.10f, 0.18f);
        glutSolidSphere(0.05f,10,10);
        glTranslatef(-0.1f, 0.0f, 0.0f);
        glutSolidSphere(0.05f,10,10);
        glPopMatrix();
     
    // Draw Nose
        glColor3f(red, green, blue);
        glRotatef(0.0f,1.0f, 0.0f, 0.0f);
        glutSolidCone(0.08f,0.5f,10,2);
     
        glColor3f(1.0f, 1.0f, 1.0f);
    }
     
    void renderBitmapString(
        float x,
        float y,
        float z,
        void *font,
        char *string)
    {
     
        char *c;
        glRasterPos3f(x, y,z);
        for (c=string; *c != '\0'; c++)
        {
            glutBitmapCharacter(font, *c);
        }
    }
     
    void renderStrokeFontString(
        float x,
        float y,
        float z,
        void *font,
        char *string)
    {
     
        char *c;
        glPushMatrix();
        glTranslatef(x, y,z);
        glScalef(0.002f, 0.002f, 0.002f);
        for (c=string; *c != '\0'; c++)
        {
            glutStrokeCharacter(font, *c);
        }
        glPopMatrix();
    }
     
    void restorePerspectiveProjection()
    {
     
        glMatrixMode(GL_PROJECTION);
        // restore previous projection matrix
        glPopMatrix();
     
        // get back to modelview mode
        glMatrixMode(GL_MODELVIEW);
    }
     
    void setOrthographicProjection()
    {
     
        // switch to projection mode
        glMatrixMode(GL_PROJECTION);
     
        // save previous matrix which contains the
        //settings for the perspective projection
        glPushMatrix();
     
        // reset matrix
        glLoadIdentity();
     
        // set a 2D orthographic projection
        gluOrtho2D(0, w, h, 0);
     
        // switch back to modelview mode
        glMatrixMode(GL_MODELVIEW);
    }
    void computePos(float deltaMove)
    {
     
        x += deltaMove * lx * 0.1f;
        z += deltaMove * lz * 0.1f;
    }
    void convertToLinearArray()
    {
        int len;
        int index;
        for(index=0; index<6; index++)
        {
            len=0;
            for(unsigned int r=0; r<imageheight; r++)
            {
     
                for(unsigned int c=0; c<imagewidth; c++)
                {
                    for(int k=2; k>=0; k--)
                    {
                        linearImage[index][len++] = image[index][r][c][k];
     
                    }
                    linearImage[index][len++] = (GLubyte)255;
     
                }
            }
     
        }
    }
     
    int loadImage(char *f_name,int index)
    {
        FILE *fp;
        unsigned char blueValue, redValue, greenValue;
        unsigned int r,c;
     
        //opens the file
        if(!(fp = fopen(f_name, "r")))
        {
            printf("File Open Error\n");
            return 0;
        }
     
        //seeking bytes from initial position
        fseek(fp,2,0);
     
        //reads file size
        fread(&fileSize,4,1,fp);
     
        //seeking bytes from initial position
        fseek(fp,18,0);
     
        //reading image height and width
        fread(&imagewidth,4,1,fp);
        fseek(fp,22,0);
        fread(&imageheight,4,1,fp);
     
    //	printf("%d %d\n",imagewidth,imageheight);
     
        //now starts data reading
        fseek(fp,54,0);
     
        for(r=0; r<imageheight; r++)
        {
            for(c=0; c<imagewidth; c++)
            {
                fread(&blueValue, sizeof(char), 1, fp);
                fread(&greenValue, sizeof(char), 1, fp);
                fread(&redValue, sizeof(char), 1, fp);
     
                image[index][r][c][0] = (GLubyte)blueValue;
                image[index][r][c][1] = (GLubyte)greenValue;
                image[index][r][c][2] = (GLubyte)redValue;
                image[index][r][c][3] = (GLubyte)255;
     
            }
        }
     
        //end of reading
        fclose(fp);
        return 1;
    }
     
    void initializeImages()
    {
        char file_name[100];
     
     
        //opening file with filename
        strcpy(file_name, "pic0.bmp");
     
        //loading image file
        if(!loadImage(file_name,0))
        {
            printf("\n0File Error\n");
        }
    }
     
    void renderScene(void)
    {
     
        if (deltaMove)
            computePos(deltaMove);
     
        // Clear Color and Depth Buffers
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glClearColor(0.7,0.7,0.9,1.0);
        // Reset transformations
        glLoadIdentity();
        // Set the camera
        //gluLookAt(	x, 1.0f, z,
        //		x+lx, 1.0f,  z+lz,
        //		0.0f, 1.0f,  0.0f);
     
        gluLookAt(	-10+camX-8, 15.0f+camY+9, 10+camZ-8,
                    1+camX-8, 1.0f+camY+9,  1+camZ-8,
                    0.0f, 1.0f,  0.0f);
     
    // Draw ground
        //----------------------------------
        drawGround();
        drawRoad();
        roadMark();
        character(mouseXu,mouseXd,mouseYu,mouseYd);
        buildings();
        //----------------------------------------
    // Draw 36 SnowMen
        char number[3];
        for(int i = -3; i < 3; i++)
            for(int j=-3; j < 3; j++)
            {
                glPushMatrix();
                glTranslatef(i*10.0f, 0.0f, j * 10.0f);
     
                //sprintf(number,"%d",(i+3)*6+(j+3));
                // renderStrokeFontString(0.0f, 0.5f, 0.0f, (void *)font ,number);
                glPopMatrix();
            }
     
        // Code to compute frames per second
        frame++;
     
        time=glutGet(GLUT_ELAPSED_TIME);
        if (time - timebase > 1000)
        {
            sprintf(s,"FPS:%4.2f",
                    frame*1000.0/(time-timebase));
            timebase = time;
            frame = 0;
        }
     
        setOrthographicProjection();
        void *font= GLUT_BITMAP_8_BY_13;
        glPushMatrix();
        glLoadIdentity();
        renderBitmapString(30,15,0,font,(char *)"Project: Game [Beta Testing]");
        renderBitmapString(30,30,0,font,s);
        renderBitmapString(30,45,0,font,(char *)"F1 - Game Mode  640x480 32 bits");
        renderBitmapString(30,60,0,font,(char *)"F2 - Game Mode  800x600 32 bits");
        renderBitmapString(30,75,0,font,(char *)"F3 - Game Mode 1024x768 32 bits");
        renderBitmapString(30,90,0,font,(char *)"F4 - Game Mode 1280x1024 32 bits");
        renderBitmapString(30,105,0,font,(char *)"F5 - Game Mode 1920x1200 32 bits");
        renderBitmapString(30,120,0,font,(char *)"F7 - Game Mode 1280x720 32 bits");
        renderBitmapString(30,135,0,font,(char *)"F6 - Window Mode");
        renderBitmapString(30,150,0,font,(char *)"Esc - Quit");
        renderBitmapString(30,165,0,font,currentMode);
        glPopMatrix();
     
        restorePerspectiveProjection();
     
        Sun();
     
        glutSwapBuffers();
    }
     
    // -----------------------------------
    //             KEYBOARD
    // -----------------------------------
     
    void processNormalKeys(unsigned char key, int xx, int yy)
    {
     
        switch (key)
        {
        case 27:
            if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0)
                glutLeaveGameMode();
            exit(0);
            break;
        }
    }
    void NormalKey(unsigned char key, int xx, int yy)
    {
        switch(key)
        {
        case 'w':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camZ+=1;
            break;
     
        case 'a':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camX+=1;
            break;
     
        case 's':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camZ-=1;
            break;
     
        case 'd':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camX-=1;
            break;
     
        case '8':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camY+=1;
            break;
     
        case '2':
            printf("Camera: X: %d Y: %d Z: %d\n", camX, camY, camZ);
            camY-=1;
            break;
        case '0':
            camX=0;
            camY=0;
            camZ=0;
            break;
        }
        glutPostRedisplay();
    }
    void pressKey(int key, int xx, int yy)
    {
     
        switch (key)
        {
        case GLUT_KEY_UP :
            deltaMove = 0.5f;
            break;
        case GLUT_KEY_DOWN :
            deltaMove = -0.5f;
            break;
        case GLUT_KEY_F1:
            // define resolution, color depth
            glutGameModeString("640x480:32");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"640x480:32");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        case GLUT_KEY_F2:
            // define resolution, color depth
            glutGameModeString("800x600:32");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"800x600:32");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        case GLUT_KEY_F3:
            // define resolution, color depth
            glutGameModeString("1024x768:32");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"1024x768:32");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        case GLUT_KEY_F4:
            // define resolution, color depth
            glutGameModeString("1280x1024:32");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"1280x1024:32");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        case GLUT_KEY_F5:
            // define resolution, color depth
            glutGameModeString("1920x1200");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"1920x1200");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        case GLUT_KEY_F6:
            // return to default window
            w = 800;
            h = 600;
            if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0)
            {
                glutLeaveGameMode();
                //init();
            }
            break;
        case GLUT_KEY_F7:
            // define resolution, color depth
            glutGameModeString("1280x720:32");
            // enter full screen
            if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
            {
                glutEnterGameMode();
                sprintf(gameModeString,"1280x720:32");
                // register callbacks again
                // and init OpenGL context
                init();
            }
            else
                glutGameModeString(gameModeString);
            break;
        }
        if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) == 0)
            sprintf(currentMode,"Current Mode: Window");
        else
            sprintf(currentMode,
                    "Current Mode: Game Mode %dx%d at %d hertz, %d bpp",
                    glutGameModeGet(GLUT_GAME_MODE_WIDTH),
                    glutGameModeGet(GLUT_GAME_MODE_HEIGHT),
                    glutGameModeGet(GLUT_GAME_MODE_REFRESH_RATE),
                    glutGameModeGet(GLUT_GAME_MODE_PIXEL_DEPTH));
    }
     
    void releaseKey(unsigned char key, int x, int y)
    {
     
        switch(key)
        {
        case 'w':
            camZ+=1;
            break;
     
        case 'a':
            camX+=1;
            break;
     
        case 's':
            camZ-=1;
            break;
     
        case 'd':
            camX-=1;
            break;
     
        }
    }
     
    // -----------------------------------
    //             MOUSE
    // -----------------------------------
     
    void mouseMove(int x, int y)
    {
     
        // this will only be true when the left button is down
        if (xOrigin >= 0)
        {
     
            // update deltaAngle
            deltaAngle = (x - xOrigin) * 0.001f;
     
            // update camera's direction
            lx = sin(angle + deltaAngle);
            lz = -cos(angle + deltaAngle);
        }
    }
     
    void mouseButton(int button, int state, int x, int y)
    {
     
        // only start motion if the left button is pressed
        if (button == GLUT_LEFT_BUTTON)
        {
     
            // when the button is released
            if (state == GLUT_UP)
            {
                angle += deltaAngle;
                xOrigin = -1;
            }
            else   // state = GLUT_DOWN
            {
                xOrigin = x;
            }
        }
        if ((button == GLUT_RIGHT_BUTTON)) // It's a wheel event
        {
            if(state == GLUT_UP)
            {
                glPushMatrix();
                glTranslated(10*lx,3,-refresh);
                glutSolidCone(0.5,2,20,20);
                glPopMatrix();
            }
        }
        else
        {
     
        }
     
     
    }
     
    void init()
    {
     
        // register callbacks
        glutDisplayFunc(renderScene);
        glutReshapeFunc(changeSize);
        glutIdleFunc(renderScene);
     
        glutIgnoreKeyRepeat(1);
        glutKeyboardFunc(NormalKey);
        glutSpecialFunc(pressKey);
        glutKeyboardUpFunc(releaseKey);
        glutMouseFunc(mouseButton);
        glutMotionFunc(mouseMove);
     
        // OpenGL init
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
    }
     
    // -----------------------------------
    //             MAIN
    // -----------------------------------
     
    int main(int argc, char **argv)
    {
     
        // init GLUT and create window
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
        glutInitWindowPosition(100,100);
        glutInitWindowSize(800,600);
        glutCreateWindow("Lighthouse3D - GLUT Tutorial");
     
        // register callbacks
        init();
        setLight();
        initializeImages();
     
        // enter GLUT event processing cycle
        glutTimerFunc(100, update, 0) ;
        glutMainLoop();
     
        return 1;
    }

  2. #2
    Junior Member Newbie
    Join Date
    Dec 2017
    Posts
    22
    Quote Originally Posted by sudipto019 View Post
    So,I was working on a isometric view 3D game based on GLUT lib, but I ran into problems like mapping textures to objects. I just can't seem to map textures into objects. The loader can't load the files. Need a mouse control event like when Right Clicking a cylinder will be shot by the ball. Deadline is on this Sunday.
    I couldn't do all the coding.
    Using tutorials from Lighthouse 3D and some other places. I modified, added, removed many parts of the codes.
    You are already using windows as a base. I don't know if you can do so inside of a glut function , but maybe using
    LRESULT CALLBACK WNDPROC would be an easier solution. There is plenty of literature online that makes everything easily understandable inside of that. As for textures I can't help you out with that one. I'm not seeing you bind them or declare them either so I can only assume you are using something built into GLUT. If not then look up the red book. OpenGL Redbook. It will give you a good idea of the order of operations in order to load and bind a texture. Using Windows you can extract the BITMAPFILEHEADER and BITMAPINFOHEADER.

    The code below is by far mine. I might have 1 maybe two tweeks to fit what I needed at the time. I can't remember if it's a GameDev source or not. This will easily load a 24bit .BMP file as long as it's a minimum size of 64X64 I think. However I think I quit using it because there was an issue with it not maintaining the value and always having to call it to bind the texture. I'm not sure if it will be compatible with a non window operating system. But I do know it works on a 386.


    Code :
    GLuint returnTexture ( const char* fileName )
    {
     GLuint textureID;
     glGenTextures(1,&textureID);
     
     BITMAPFILEHEADER bitmapFileHeader;
     BITMAPINFOHEADER bitmapInfoHeader;
     
     BYTE * pixelData;
     FILE * tempFile;
     
     if (!(tempFile = fopen(fileName,"r")))
     {
      glDeleteTextures(1,&textureID);
      return 0;
     }
     fread(&bitmapFileHeader,sizeof(BITMAPFILEHEADER),1,tempFile);
     DWORD bfhSize = bitmapFileHeader.bfSize;
     WORD wType=0x4D42;
     if ( bitmapFileHeader.bfType != wType )
     {
      if(fclose(tempFile))
      {
       tempFile = NULL;
      }
      glDeleteTextures(1,&textureID);
      return 0;
     }
     fread(&bitmapInfoHeader,sizeof(BITMAPINFOHEADER),1,tempFile);
     if ( bitmapInfoHeader.biBitCount != 24 )
     {
      if(fclose(tempFile))tempFile = NULL;
      glDeleteTextures(1,&textureID);
      return 0;
     }
     DWORD imageSize;
     if ( bitmapInfoHeader.biSizeImage == 0 )
     {
      imageSize = (LONG)bitmapFileHeader.bfSize - (LONG)bitmapFileHeader.bfOffBits;
     }
     else { imageSize = bitmapInfoHeader.biSizeImage; }
     fseek(tempFile,(LONG)bitmapFileHeader.bfOffBits,SEEK_SET);
     pixelData = (BYTE*)malloc(imageSize);
     if ( pixelData == NULL )
     {
      if (fclose(tempFile)) tempFile = 0;
      free(&pixelData);
      glDeleteTextures(1,&textureID);
      return 0;
     }
     fread(pixelData,imageSize,1,tempFile);
     if (fclose(tempFile))
     {
      free(pixelData);
      glDeleteTextures(1,&textureID);
      return 0;
     } 
     glBindTexture(GL_TEXTURE_2D,textureID);
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_CLAMP); 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_CLAMP);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_CLAMP);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
     glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB , bitmapInfoHeader.biWidth,bitmapInfoHeader.biHeight, 0, GL_BGR_EXT , GL_UNSIGNED_BYTE ,&pixelData[0]);
     free(pixelData);
     pixelData = NULL;
     if (glIsTexture(*&textureID) == GL_FALSE) ErrorExit(TEXT("unable to make texter \n bitmapLoader returnTexture"));
     return textureID;
    }

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •