QT_OPENGL-------- 5.model

在qt中实现opengl obj模型导入：

main.cpp

#include<GL/glew.h>

#include <GLFW/glfw3.h>

#include<stdio.h>

#include<glm/glm.hpp>

#include<glm/ext.hpp>

#include"misc.h"

#include"model.h"

GLfloat deltaTime = 0.0f;

GLfloat lastFrame = 0.0f;

GLint CreateGPUProgram(const char*vsShaderPath,const char*fsShaderPath)

{

    GLuint vsShader=glCreateShader(GL_VERTEX_SHADER);

    GLuint fsShader=glCreateShader(GL_FRAGMENT_SHADER);

    const char*vsCode=LoadFileContent(vsShaderPath);

    const char*fsCode=LoadFileContent(fsShaderPath);

    glShaderSource(vsShader,,&vsCode,nullptr);

    glShaderSource(fsShader,,&fsCode,nullptr);

    glCompileShader(vsShader);

    glCompileShader(fsShader);

    GLuint program=glCreateProgram();

    glAttachShader(program,vsShader);

    glAttachShader(program,fsShader);

    glLinkProgram(program);

    glDetachShader(program,vsShader);

    glDetachShader(program,fsShader);

    glDeleteShader(vsShader);

    glDeleteShader(fsShader);

    return program;

}

void framebuffer_size_callback(GLFWwindow* window, int width, int height)

{

    glViewport(, , width, height);

}

int main(void)

{

    GLFWwindow* window;

    if (!glfwInit())

        return -;

    window = glfwCreateWindow(, , "Hello World", NULL, NULL);

    if (!window)

    {

        glfwTerminate();

        return -;

    }

    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;

    // 还需要注册这个函数，告诉GLFW我们希望每当窗口调整大小的时候调用这个函数。

    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    glewInit();

    GLuint program = CreateGPUProgram("/home/jun/OpenGL/model/sample.vs", "/home/jun/OpenGL/model/sample.fs");

    GLint posLocation, texcoordLocation,normalLocation, MLocation, VLocation, PLocation;

    posLocation = glGetAttribLocation(program, "pos");

    texcoordLocation = glGetAttribLocation(program, "texcoord");

    normalLocation = glGetAttribLocation(program, "normal");

    MLocation = glGetUniformLocation(program, "M");

    VLocation = glGetUniformLocation(program, "V");

    PLocation = glGetUniformLocation(program, "P");

    unsigned int *indexes = nullptr;

    int vertexCount = , indexCount = ;

    VertexData*vertexes = LoadObjModel("/home/jun/OpenGL/model/MODEL/niutou.obj", &indexes, vertexCount, indexCount);

    if (vertexes==nullptr)

    {

        printf("load obj model fail\n");

    }

    //obj model -> vbo & ibo

    GLuint vbo = CreateBufferObject(GL_ARRAY_BUFFER, sizeof(VertexData) * vertexCount, GL_STATIC_DRAW, vertexes);

    GLuint ibo = CreateBufferObject(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * indexCount, GL_STATIC_DRAW, indexes);

    printf("vertex count %d index count %d\n",vertexCount,indexCount);

    glClearColor(41.0f / 255.0f, 71.0f / 255.0f, 121.0f / 255.0f, 1.0f);

    //ShowWindow(hwnd, SW_SHOW);

    //UpdateWindow(hwnd);

    float identity[] = {

        ,,,,

        ,,,,

        ,,,,

        ,,,

    };

   //创建一个投影矩阵

   glm::mat4 model;

   model = glm::translate(model, glm::vec3(0.0f, 0.0f, -54.0f));

    model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f));

   glm::mat4 projection=glm::perspective(45.0f,800.0f/600.0f,0.1f,1000.0f);

   glEnable(GL_DEPTH_TEST);

   glEnable(GL_CULL_FACE);

    while (!glfwWindowShouldClose(window))

    {

        GLfloat currentFrame = (GLfloat)glfwGetTime();

        deltaTime = currentFrame - lastFrame;

        lastFrame = currentFrame;

        glfwPollEvents();

       // glClearColor(1.0f, 0.04f, 0.14f, 1.0f);

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        glUseProgram(program);

        glUniformMatrix4fv(MLocation, , GL_FALSE, glm::value_ptr(model));

        glUniformMatrix4fv(VLocation, , GL_FALSE, identity);

        glUniformMatrix4fv(PLocation, , GL_FALSE, glm::value_ptr(projection));

        glBindBuffer(GL_ARRAY_BUFFER, vbo);

        glEnableVertexAttribArray(posLocation);

        glVertexAttribPointer(posLocation, , GL_FLOAT, GL_FALSE, sizeof(VertexData), (void*));

        glEnableVertexAttribArray(texcoordLocation);

        glVertexAttribPointer(texcoordLocation, , GL_FLOAT, GL_FALSE, sizeof(VertexData), (void*)(sizeof(float) * ));

        glEnableVertexAttribArray(normalLocation);

        glVertexAttribPointer(normalLocation, , GL_FLOAT, GL_FALSE, sizeof(VertexData), (void*)(sizeof(float) * ));

        glBindBuffer(GL_ARRAY_BUFFER, );

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

        glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, );

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, );

        glUseProgram();

        glfwSwapBuffers(window);

    }

    glfwTerminate();

    return ;

}

mish.h

#include<GL/glew.h>

GLuint CreateBufferObject(GLenum bufferType, GLsizeiptr size, GLenum usage, void*data = nullptr);

char *LoadFileContent(const char*path);

mish.cpp

#include "misc.h"

#include <stdio.h>

GLuint CreateBufferObject(GLenum bufferType, GLsizeiptr size, GLenum usage, void*data /* = nullptr */)

{

    GLuint object;

    glGenBuffers(, &object);

    glBindBuffer(bufferType, object);

    glBufferData(bufferType, size, data, usage);

    glBindBuffer(bufferType, );

    return object;

}

char *LoadFileContent(const char*path)

{

    FILE*pFile = fopen(path, "rb");

    if (pFile)

    {

        fseek(pFile, , SEEK_END);

        int nLen = ftell(pFile);

        char*buffer = nullptr;

        if (nLen!=)

        {

            buffer=new char[nLen + ];

            rewind(pFile);

            fread(buffer, nLen, , pFile);

            buffer[nLen] = '\0';

        }

        else

        {

            printf("load file fail %s content len is 0\n", path);

        }

        fclose(pFile);

        return buffer;

    }

    else

    {

        printf("open file %s fail\n",path);

    }

    fclose(pFile);

    return nullptr;

}

model.h

struct VertexData

{

    float position[];

    float texcoord[];

    float normal[];

};

VertexData*LoadObjModel(const char* filePath,unsigned int **indexes,int&vertexCount,int&indexCount);

model.cpp

#include "model.h"

#include "misc.h"

#include <stdio.h>

#include <string.h>

#include <sstream>

#include <vector>

VertexData*LoadObjModel(const char* filePath, unsigned int **indexes, int&vertexCount, int&indexCount)

{

    char*fileContent = LoadFileContent(filePath);

    if (fileContent!=nullptr)

    {

        //obj model decode

        struct VertexInfo

        {

            float v[];

        };

        struct VertexDefine

        {

            int positionIndex;

            int texcoordIndex;

            int normalIndex;

        };

        std::vector<VertexInfo> positions;

        std::vector<VertexInfo> texcoords;

        std::vector<VertexInfo> normals;

        std::vector<unsigned int> objIndexes;// -> opengl indexes

        std::vector<VertexDefine> vertices;// -> opengl vertexes

        std::stringstream ssObjFile(fileContent);

        char szOneLine[];

        std::string temp;

        while (!ssObjFile.eof())

        {

            memset(szOneLine, , );

            ssObjFile.getline(szOneLine,);

            if (strlen(szOneLine)>)

            {

                std::stringstream ssOneLine(szOneLine);

                if (szOneLine[]=='v')

                {

                    if (szOneLine[]=='t')

                    {

                        //vertex coord

                        ssOneLine >> temp;

                        VertexInfo vi;

                        ssOneLine >> vi.v[];

                        ssOneLine >> vi.v[];

                        texcoords.push_back(vi);

                        printf("%s %f,%f\n", temp.c_str(), vi.v[], vi.v[]);

                    }

                    else if(szOneLine[]=='n')

                    {

                        //normal

                        ssOneLine >> temp;

                        VertexInfo vi;

                        ssOneLine >> vi.v[];

                        ssOneLine >> vi.v[];

                        ssOneLine >> vi.v[];

                        normals.push_back(vi);

                        printf("%s %f,%f,%f\n", temp.c_str(), vi.v[], vi.v[], vi.v[]);

                    }

                    else

                    {

                        //position

                        ssOneLine >> temp;

                        VertexInfo vi;

                        ssOneLine >> vi.v[];

                        ssOneLine >> vi.v[];

                        ssOneLine >> vi.v[];

                        positions.push_back(vi);

                        printf("%s %f,%f,%f\n",temp.c_str(), vi.v[], vi.v[], vi.v[]);

                    }

                }

                else if (szOneLine[] == 'f')

                {

                    //face

                    ssOneLine >> temp;// 'f'

                    std::string vertexStr;

                    for (int i=;i<;i++)

                    {

                        ssOneLine >> vertexStr;

                        size_t pos = vertexStr.find_first_of('/');

                        std::string positionIndexStr = vertexStr.substr(, pos);

                        size_t pos2 = vertexStr.find_first_of('/', pos + );

                        std::string texcoordIndexStr = vertexStr.substr(pos + , pos2 - pos - );

                        std::string normalIndexStr = vertexStr.substr(pos2 + , vertexStr.length() - pos2 - );

                        VertexDefine vd;

                        vd.positionIndex = atoi(positionIndexStr.c_str())-;

                        vd.texcoordIndex = atoi(texcoordIndexStr.c_str()) - ;

                        vd.normalIndex = atoi(normalIndexStr.c_str()) - ;

                        int nCurrentIndex = -;//indexes

                        //check if exist

                        size_t nCurrentVerticeCount = vertices.size();

                        for (size_t j = ; j < nCurrentVerticeCount; j++)

                        {

                            if (vertices[j].positionIndex == vd.positionIndex&&

                                vertices[j].texcoordIndex == vd.texcoordIndex&&

                                vertices[j].normalIndex == vd.normalIndex)

                            {

                                nCurrentIndex = j;

                                break;

                            }

                        }

                        if (nCurrentIndex==-)

                        {

                            //create new vertice

                            nCurrentIndex = vertices.size();

                            vertices.push_back(vd);//vertexes define

                        }

                        objIndexes.push_back(nCurrentIndex);

                    }

                }

            }

        }

        printf("face count %u\n",objIndexes.size()/);

        //objIndexes->indexes buffer -> ibo

        indexCount = (int)objIndexes.size();

        *indexes = new unsigned int[indexCount];

        for (int i=;i<indexCount;i++)

        {

            (*indexes)[i] = objIndexes[i];

        }

        //vertices -> vertexes -> vbo

        vertexCount = (int)vertices.size();

        VertexData*vertexes = new VertexData[vertexCount];

        for (int i=;i<vertexCount;++i)

        {

            memcpy(vertexes[i].position, positions[vertices[i].positionIndex].v, sizeof(float) * );

            memcpy(vertexes[i].texcoord, texcoords[vertices[i].texcoordIndex].v, sizeof(float) * );

            memcpy(vertexes[i].normal, normals[vertices[i].normalIndex].v, sizeof(float) * );

        }

        return vertexes;

    }

    return nullptr;

}

model.pro

TEMPLATE = app

CONFIG += console c++

CONFIG -= app_bundle

CONFIG -= qt

SOURCES += main.cpp \

    misc.cpp \

    model.cpp

LIBS+= -L/usr/lib64 -lGLEW

LIBS +=-L/usr/local/lib -lglfw3 -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -lGL -lpthread -ldl

HEADERS += \

    misc.h \

    model.h

最后的效果：

巴特西

QT_OPENGL-------- 5.model

最新文章

热门文章