3dmax

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctime>
#include <malloc.h>
#include <math.h>



int screenWidth = 600;
int screenHeight = 600;
int fps = 60;

GLdouble cameraPos[] = {0.0, 0.0, 25.0};
double rotation = 0.0;

GLfloat lightAmb[] = {1.0, 0.0, 0.0, 1.0};
GLfloat lightDif[] = {0.7, 0.7, 0.7, 1.0};
GLfloat lightPos[] = {10, 10, 10, 1.0};
GLfloat lightSpec[] = {1, 1, 1, 1};

GLuint tex[1];

typedef struct {
    GLuint bpp;     // ilość bitów na piksel
    GLuint width;   // rozmiary w pikselach
    GLuint height;
} TARGAINFO;



typedef struct {
    unsigned short vertices;
    unsigned short normals;
    unsigned short indices;
    unsigned short texCoords;

    float verticesArray[10000];
    float normalsArray[10000];
    unsigned short indicesArray[10000];
    float texCoordsArray[10000];
} _3DSOBJ;

_3DSOBJ *ship;





GLubyte *LoadTGAImage(const char *filename, TARGAINFO *info)
{
    GLubyte TGAHeader[12]={0,0,2,0,0,0,0,0,0,0,0,0};    // Nagłówek TGA bez kompresji
    GLubyte TGACompare[12];         // Tu się załaduje dane z pliku
    GLubyte Header[6];          // Pierwsze potrzebne 6 bajtów z pliku
    GLubyte *Bits = NULL;   // Wskaźnik na bufor z danymi pikseli

    FILE *plik = fopen(filename, "rb"); // Próba otwarcia do odczytu
    if(plik)
    {
        fread(TGACompare, 1, sizeof(TGACompare), plik); // Odczytanie nagłówka pliku
        if(memcmp(TGAHeader, TGACompare, sizeof(TGAHeader)) == 0)   // Nagłówek identyczny?
        {
            fread(Header, 1, sizeof(Header), plik); // Odczyt użytecznych danych

            // Wyłuskanie informacji o rozmiarach
            info->width  = Header[1] * 256 + Header[0];
            info->height = Header[3] * 256 + Header[2];
            info->bpp = Header[4];

            // Sprawdzenie czy rozmiary > 0 oraz czy bitmapa 24 lub 32-bitowa
            if(info->width>0 && info->height>0 && (info->bpp==24 || info->bpp==32))
            {
                long ImageSize = info->height * info->width * info->bpp / 8;    // Obliczenie ilości danych
                Bits = (GLubyte*)malloc(ImageSize); // Alokacja pamięci na dane

                if(Bits)
                {
                    fread(Bits, 1, ImageSize, plik);    // Odczyt właściwych danych pikseli z pliku

                    // Konwersja BGR -> RGB
                    int i;
                    GLubyte tmp;    // Miejsce przechowania jednej wartości koloru

                    for(i=0;i < ImageSize;i += info->bpp / 8)   // Wszystkie wartości RGB lub RGBA
                    {
                        tmp = Bits[i];
                        Bits[i] = Bits[i+2];
                        Bits[i+2] = tmp;
                    }
                }
            }
        }

        fclose(plik);
    }

    return(Bits);
}


bool LoadTGATexture(const char *filename)
{
    TARGAINFO info; // Dane o bitmapie
    GLubyte *bits;  // Dane o pikselach

    // ładowanie pliku
    bits = LoadTGAImage(filename, &info);   // Próba wczytania tekstury
    if(bits == NULL)    return(FALSE);  // ERROR

    // Ustawienie parametrów tekstury
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    if(info.bpp == 24)  // Bitmapa z danymi RGB
        glTexImage2D(GL_TEXTURE_2D, 0, 3, info.width, info.height, 0, GL_RGB, GL_UNSIGNED_BYTE, bits);
    else    // Bitmapa z danymi RGBA
        glTexImage2D(GL_TEXTURE_2D, 0, 4, info.width, info.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bits);

    free(bits);
    return(TRUE);
}

bool LoadTGAMipmap(const char *filename)
{
    TARGAINFO info; // Dane o bitmapie
    GLubyte *bits;  // Dane o pikselach

    // ładowanie pliku
    bits = LoadTGAImage(filename, &info);   // Próba wczytania tekstury
    if(bits == NULL)    return(FALSE);  // ERROR

    // Ustawienie parametrów tekstury
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    if(info.bpp == 24)  // Bitmapa z danymi RGB
        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, info.width, info.height, GL_RGB, GL_UNSIGNED_BYTE, bits);
    else    // Bitmapa z danymi RGBA
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, info.width, info.height, GL_RGBA, GL_UNSIGNED_BYTE, bits);

    free(bits);
    return(TRUE);
}






_3DSOBJ *load3DSObject(const char *filename){
    FILE *f = fopen(filename, "rb");
    _3DSOBJ *object = (_3DSOBJ*)malloc(sizeof(_3DSOBJ));

    int size;
    unsigned short id = 0;
    unsigned int next = 0;

    if(f != NULL){
        fseek(f, 0, SEEK_END);
        size = ftell(f);
        fseek(f, 0, SEEK_SET);

        while(ftell(f) < size){
            id = 0;
            next = 0;

            fread(&id, 2, 1, f);
            fread(&next, 4, 1, f);

            switch(id){
                case 0x4D4D:
                    printf("MAIN3DS\n");
                    break;
                case 0x3D3D:
                    printf("EDIT3DS\n");
                    break;
                case 0x4000:
                    printf("EDIT_OBJECT\n");
                    char c;
                    printf("\tObject name: ");
                    do {
                        fread(&c, 1, 1, f);
                        printf("%c", c);
                    } while(c != '\0');
                    printf("\n");
                    break;
                case 0x4100:
                    printf("OBJ_TRIMESH\n");
                    break;
                case 0x4110:
                    printf("TRI_VERTEXL\n");
                    fread(&object->vertices, sizeof(unsigned short), 1, f);
                    printf("\tVertices: %d\n", object->vertices);
                    for(int i = 0; i < object->vertices * 3; i++){
                        fread(&object->verticesArray[i], sizeof(float), 1, f);
                        if((i + 1) % 3 == 0)
                            printf("\t\tVertex %d: (%.3f, %.3f, %.3f)\n", (i + 1) / 3, object->verticesArray[i - 2], object->verticesArray[i - 1], object->verticesArray[i]);
                    }
                    break;
                case 0x4120:
                    printf("TRI_POLYGONL\n");
                    fread(&object->indices, sizeof(unsigned short), 1, f);
                    printf("\tIndices: %d\n", object->indices);
                    GLushort tmp;
                    int i2;
                    i2 = 0;
                    for(int i = 0; i < object->indices * 4; i++){
                        if((i + 1) % 4 == 0) {
                            fread(&tmp, sizeof(unsigned short), 1, f);
                            printf("\t\tPolygon %d: (%d, %d, %d)\n", i2 / 3, object->indicesArray[i2 - 3], object->indicesArray[i2 - 2], object->indicesArray[i2 - 1]);
                        } else {
                            fread(&object->indicesArray[i2], sizeof(unsigned short), 1, f);
                            i2++;
                        }
                    }
                    break;
                case 0x4140:
                    printf("TRI_MAPPINGCOORS\n");
                    fread(&object->texCoords, sizeof(unsigned short), 1, f);
                    printf("\tTex indices: %d\n", object->texCoords);
                    for(int i = 0; i < object->texCoords * 2; i++){
                        fread(&object->texCoordsArray[i], sizeof(float), 1, f);
                        if((i + 1) % 2 == 0)
                            printf("\t\tTex index %d: (%.3f, %.3f)\n", (i + 1) / 2, object->texCoordsArray[i - 1], object->texCoordsArray[i]);
                    }
                    break;
                default:
                    fseek(f, next - 6, SEEK_CUR);
            }
        }

        for(int i = 0; i < object->indices; i++){
                GLfloat p1x = object->verticesArray[object->indicesArray[i * 3] * 3];
                GLfloat p1y = object->verticesArray[object->indicesArray[i * 3] * 3 + 1];
                GLfloat p1z = object->verticesArray[object->indicesArray[i * 3] * 3 + 2];

                GLfloat p2x = object->verticesArray[object->indicesArray[i * 3 + 1] * 3];
                GLfloat p2y = object->verticesArray[object->indicesArray[i * 3 + 1] * 3 + 1];
                GLfloat p2z = object->verticesArray[object->indicesArray[i * 3 + 1] * 3 + 2];

                GLfloat p3x = object->verticesArray[object->indicesArray[i * 3 + 2] * 3];
                GLfloat p3y = object->verticesArray[object->indicesArray[i * 3 + 2] * 3 + 1];
                GLfloat p3z = object->verticesArray[object->indicesArray[i * 3 + 2] * 3 + 2];

                GLfloat nx1 = (p2y - p1y) * (p3z - p1z) - (p2z - p1z) * (p3y - p1y);
                GLfloat ny1 = (p2z - p1z) * (p3x - p1x) - (p2x - p1x) * (p3z - p1z);
                GLfloat nz1 = (p2x - p1x) * (p3y - p1y) - (p2y - p1y) * (p3x - p1x);

                GLfloat l1 = sqrtf(powf(nx1, 2) + powf(ny1, 2) + powf(ny1, 2));

                nx1 /= l1;
                ny1 /= l1;
                nz1 /= l1;

                GLfloat nx2 = (p1y - p2y) * (p3z - p2z) - (p1z - p2z) * (p3y - p2y);
                GLfloat ny2 = (p1z - p2z) * (p3x - p2x) - (p1x - p2x) * (p3z - p2z);
                GLfloat nz2 = (p1x - p2x) * (p3y - p2y) - (p1y - p2y) * (p3x - p2x);

                GLfloat l2 = sqrtf(pow(nx2, 2) + pow(ny2, 2) + pow(ny2, 2));

                nx2 /= l2;
                ny2 /= l2;
                nz2 /= l2;

                GLfloat nx3 = (p2y - p3y) * (p1z - p3z) - (p2z - p3z) * (p1y - p3y);
                GLfloat ny3 = (p2z - p3z) * (p1x - p3x) - (p2x - p3x) * (p1z - p3z);
                GLfloat nz3 = (p2x - p3x) * (p1y - p3y) - (p2y - p3y) * (p1x - p3x);

                GLfloat l3 = sqrtf(pow(nx3, 2) + pow(ny3, 2) + pow(ny3, 2));

                nx3 /= l3;
                ny3 /= l3;
                nz3 /= l3;

                object->normals += 9;
                object->normalsArray[i * 9] = nx1;
                object->normalsArray[i * 9 + 1] = ny1;
                object->normalsArray[i * 9 + 2] = nz1;
                object->normalsArray[i * 9 + 3] = nx2;
                object->normalsArray[i * 9 + 4] = ny2;
                object->normalsArray[i * 9 + 5] = nz2;
                object->normalsArray[i * 9 + 6] = nx3;
                object->normalsArray[i * 9 + 7] = ny3;
                object->normalsArray[i * 9 + 8] = nz3;
            }

        fclose(f);

        return object;
    } else {
        printf("Can't open file\n");
        return NULL;
    }
}

void init(){
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_NORMALIZE);
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_AUTO_NORMAL);
    glEnable(GL_NORMALIZE);
    glEnable(GL_LIGHT0);

    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmb);
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDif);
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpec);

    glMaterialfv(GL_FRONT, GL_SPECULAR, lightSpec);
    glMateriali(GL_FRONT, GL_SHININESS, 100);

    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

    glGenTextures(1, tex);
    glBindTexture(GL_TEXTURE_2D, tex[0]);
    LoadTGATexture("tekstura.tga");

    ship = load3DSObject("obiekt.3DS");
    if(ship != NULL) {
        printf("Success!!\n");
    }
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor(0.5, 0.5, 0.5, 1.0);
    glLoadIdentity ();

    gluLookAt(cameraPos[0], cameraPos[1], cameraPos[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

    glPointSize(3);
    glScalef(0.05, 0.05, 0.05);
    glRotatef(rotation, 1, 1, 1);

    glBegin(GL_TRIANGLES);
        for(int i = 0; i < ship->indices * 3; i++){
            glTexCoord2fv(&ship->texCoordsArray[ship->indicesArray[i] * 2]);
            glNormal3fv(&ship->normalsArray[ship->indicesArray[i] * 3]);
            glVertex3fv(&ship->verticesArray[ship->indicesArray[i] * 3]);
        }
    glEnd();

    glFlush();
    glutPostRedisplay();
    glutSwapBuffers();
}

void reshape(int w, int h) {
    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    gluPerspective(45.0, (GLfloat)w / (GLfloat)h, 1.5, 50.0);

    glMatrixMode(GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y){
    switch(key){
        case 27 :
        case 'q':
            free(ship);
            exit(0);
            break;
    }
}

void timerfunc(int p){
    rotation +=  1;

    glutPostRedisplay();
    glutTimerFunc(1000/fps, &timerfunc, 0);
}

void menu(int value) {
    switch(value) {
        case 0:
            exit(0);
            break;
    }
}

int main(int argc, char *argv[]) {
    srand(time(NULL));
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(screenWidth, screenHeight);
    glutCreateWindow(argv[0]);
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutTimerFunc(1000/fps, &timerfunc, 0);

    glutCreateMenu(menu);
    glutAddMenuEntry("Wyjscie", 0);

    glutAttachMenu(GLUT_RIGHT_BUTTON);

    init();

    glutMainLoop();

    return 0;
}