Laul

    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    FILE* vertexFile;
    FILE* fragmentFile;
    fopen_s(&vertexFile, vertexFilePath.c_str(), "r");
    fopen_s(&fragmentFile, fragmentFilePath.c_str(), "r");

    std::string vertexShaderCode = "";
    std::string fragmentShaderCode = "";

    if(vertexFile && fragmentFile) {
        char cV = fgetc(vertexFile);
        while(cV != EOF) {
            vertexShaderCode += cV;
            cV = fgetc(vertexFile);
        }
        char cF = fgetc(fragmentFile);
        while(cF != EOF) {
            fragmentShaderCode += cF;
            cF = fgetc(fragmentFile);
        }
        fclose(vertexFile);
        fclose(fragmentFile);

        const char* vertexShaderCodeCStr = vertexShaderCode.c_str();
        const char* fragmentShaderCodeCStr = fragmentShaderCode.c_str();
        glShaderSource(vertexShader, 1, &vertexShaderCodeCStr, NULL);
        glShaderSource(fragmentShader, 1, &fragmentShaderCodeCStr, NULL);

        glCompileShader(vertexShader);
        GLint vertexSuccess = 0;
        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vertexSuccess);
        if(!vertexSuccess) {
            GLint infoLogLength = 0;
            glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &infoLogLength);

            std::vector<GLchar> errorLog(infoLogLength);
            glGetShaderInfoLog(vertexShader, infoLogLength, &infoLogLength, &errorLog[0]);

            printf("VERTEX SHADER COMPILE ERROR (%s):\n%s\n", vertexFilePath.c_str(), &errorLog[0]);
        }
        glCompileShader(fragmentShader);
        GLint fragmentSuccess = 0;
        glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fragmentSuccess);
        if(!fragmentSuccess) {
            GLint infoLogLength = 0;
            glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &infoLogLength);

            std::vector<GLchar> errorLog(infoLogLength);
            glGetShaderInfoLog(fragmentShader, infoLogLength, &infoLogLength, &errorLog[0]);

            printf("FRAGMENT SHADER COMPILE ERROR (%s):\n%s\n", fragmentFilePath.c_str(), &errorLog[0]);
        }

        this->program = glCreateProgram();
        glAttachShader(this->program, vertexShader);
        glAttachShader(this->program, fragmentShader);

        glLinkProgram(this->program);
        GLint linkSuccess = 0;
        glGetProgramiv(this->program, GL_LINK_STATUS, &linkSuccess);
        if(!linkSuccess) {
            GLint infoLogLength = 0;
            glGetProgramiv(this->program, GL_INFO_LOG_LENGTH, &infoLogLength);

            std::vector<GLchar> errorLog(infoLogLength);
            glGetProgramInfoLog(this->program, infoLogLength, &infoLogLength, &errorLog[0]);

            printf("PROGRAM LINK ERROR:\n%s\n", &errorLog[0]);
        }
    } else {
        if(!vertexFile) {
            printf("Shader(Vertex): %s couldn't be opened!\n", vertexFilePath.c_str());
        } else {
            fclose(vertexFile);
        }
        if(!fragmentFile) {
            printf("Shader(Fragment): %s couldn't be opened!\n", fragmentFilePath.c_str());
        } else {
            fclose(fragmentFile);
        }
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);