编译器和模板处理

Question

jdoseIOO

Asked:2024-07-25 15:17:36 +0000 UTC2024-07-25 15:17:36 +0000 UTC 2024-07-25 15:17:36 +0000 UTC

OpenGL 着色器程序已停止将着色器附加到自身

772

在将一个库从头库转移到一个简单库（通过 cmake 组装，类型 *.a）时，我遇到了一个问题。调用Program类后，出现错误error: no shaders attached to the program。这是程序类的旧实现（我将仅显示更改）和新实现，以及着色器类。代码：

#include <iostream>
#include <vector>
#include <glad/glad.h>
#include <GLFW/glfw3.h>

using namespace std;

const GLchar* shader1 = "#version 460 core\nout vec4 FragColor;\nvoid main() { FragColor = vec4(1.0); }";
const GLchar* shader2 = "#version 460 core\nvoid main() { gl_Position = vec4(1.0); }";

#define LogSize 1024

// class Shader
class Shader
{
  public:
    GLuint shader;
    Shader(GLenum type, const GLchar* source)
    {
        shader = glCreateShader(type);
        glShaderSource(shader, 1, &source, NULL);
        glCompileShader(shader);
        GLint error = 0; GLchar log[LogSize];
        glGetShaderiv(shader, GL_COMPILE_STATUS, &error);
        if (error == GL_FALSE)
        {
            glGetShaderInfoLog(shader, LogSize, NULL, log);
            printf("%s", log);
        }
    }
    void del() { glDeleteShader(shader); }
};

class Program
{
  public:
    GLuint ID;
    Program(vector<Shader> &shaders);
    Program(Shader* shaders, size_t len);
};

// new class Program
Program::Program(vector<Shader> &shaders)
{
    ID = glCreateProgram();
    for (size_t i = 0; i < shaders.size(); i++) glAttachShader(ID, shaders[i].shader);
    glLinkProgram(ID);

    GLint error = 0; GLchar log[LogSize]; // LogSize = 1024
    glGetProgramiv(ID, GL_LINK_STATUS, &error);
    if (error == GL_FALSE) 
    {
        glGetProgramInfoLog(ID, LogSize, NULL, log);
        printf("%s", log);
    }
}
// old class Program
Program::Program(Shader* shaders, size_t len)
{
    ID = glCreateProgram();
    for (size_t i = 0; i < len; i++) glAttachShader(ID, shaders[i].shader);
    glLinkProgram(ID);

    GLint error = 0; GLchar log[LogSize]; // LogSize = 1024
    glGetProgramiv(ID, GL_LINK_STATUS, &error);
    if (error == GL_FALSE) 
    {
        glGetProgramInfoLog(ID, LogSize, NULL, log);
        printf("%s", log);
    }
 }

void framebuffer_size_callback(GLFWwindow* win, int a, int b) {}
void mouse_callback(GLFWwindow*, double a, double b) {}
void processInput(GLFWwindow* win) {}

int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    GLFWwindow* window = glfwCreateWindow(400, 400, "", NULL, NULL);
    if (window == NULL) 
    {
       std::cout << "Fail to create window!";
       glfwTerminate();
       return -1;
    }

    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, mouse_callback);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
         std::cout << "Failed to initialize GLAD" << std::endl;
            
 
    // main
    Shader shader1(GL_VERTEX_SHADER, "path to shader");
    Shader shader2(GL_FRAGMENT_SHADER, "path to shader");

    // new program
    vector<Shader> shaders = {shader1, shader2};
    Program program(shaders);
    // old program
    Shader shaders2[] = {shader1, shader2};
    Program program2(shaders2, 2);

    // и в старой и в новой
    shader1.del();
    shader2.del();
}

正如您所看到的，代码几乎没有改变，但是现在，当返回到旧版本时，没有任何作用。请帮忙，我不明白为什么它停止工作，需要一点说明，我使用glad、glfw3和OpenGL 4.6。这是编译 g++（或任何其他编译器） main.cpp -o main -I path_to_glfw3_headers_and_glad -L path_to_glfw3_library_and_glad -lglad -lglfw3 的命令

2 个回答

Voted

evo · Answer 1 · 2024-07-26T18:16:50Z

好吧，经过这么多次尝试，TS 终于在代码中添加了这样的内容，以便我们可以假设那里出了什么问题，但是，我想说，问题没有重现，也许又是，TS 隐藏了一些东西，并没有说什么。

编写工作代码：

主.cxx：

#include <vector>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <open/gl/shader.hxx>
#include <open/gl/program.hxx>
#include <open/gl/vertex_shader.hxx>
#include <open/gl/fragment_shader.hxx>

static std::string fragment_source
  = "#version 460 core\nout vec4 FragColor;\nvoid main() { FragColor = vec4(1.0); }";

static std::string vertex_source
  = "#version 460 core\nvoid main() { gl_Position = vec4(1.0); }";

int
main(int argc, char *argv[]) {
  glfwInit();

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  GLFWwindow* window = glfwCreateWindow(640, 480, "Some Window", NULL, NULL);
  glfwMakeContextCurrent(window);

  gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);

  std::vector<open::gl::shader *> shaders {
    new open::gl::vertex_shader(vertex_source),
    new open::gl::fragment_shader(fragment_source))
  };

  open::gl::program program(shaders);

  for (open::gl::shader *shader : shaders) {
    delete shader;
  }

  shaders.clear();
}

着色器.hxx：

#pragma once

#include <string>
#include <filesystem>
#include <glad/glad.h>

namespace open::gl {
  struct shader {
    using handle = ::GLuint;

    handle id() const;

    ~shader();

    shader(shader &&other);
    shader(shader const &) = delete;
    shader &operator =(shader &&other);
    shader &operator =(shader const &) = delete;

  protected:
    enum class type {
      vertex = GL_VERTEX_SHADER,
      fragment = GL_FRAGMENT_SHADER
    };

    shader(shader::type type);
    shader(shader::type type, std::filesystem::path const &path);
    shader(shader::type type, std::string const &src);

    void set_source(std::string const &src) const;
    void compile();

  private:
    handle m_handle_;
  };
} // namespace open::gl

着色器.cxx：

#include "shader.hxx"
#include "utils.hxx"
#include <utility>

namespace open::gl {
  shader::handle
  shader::id() const {
    return m_handle_;
  }

  shader::~shader() {
    glDeleteShader(m_handle_);
  }

  shader::shader(shader &&other)
    : m_handle_(std::exchange(other.m_handle_, 0))
  { }

  shader
  &shader::operator=(shader &&other) {
    if (&other != this) {
      m_handle_ = std::exchange(other.m_handle_, 0);
    }
    return *this;
  }

  shader::shader(shader::type type)
    : m_handle_{glCreateShader(static_cast<GLuint>(type))} {
    if (!glIsShader(m_handle_)) {
      throw std::runtime_error("Failed to create shader");
    }
  }

  shader::shader(shader::type type, std::filesystem::path const &path)
      : shader(type, utils::path_to_content(path))
  { }

  shader::shader(shader::type type, std::string const &src)
    : shader(type) {
    set_source(src);
    compile();
  }

  void
  shader::set_source(std::string const &src) const {
    GLchar const *data = src.data();
    GLint data_size = src.length();
    glShaderSource(m_handle_, 1, &data, &data_size);
  }

  void
  shader::compile() {
    glCompileShader(m_handle_);
    // need some more checks for error's call glGetError()

    GLint has_compiled {};
    glGetShaderiv(m_handle_, GL_COMPILE_STATUS, &has_compiled);

    if (GL_TRUE != has_compiled) {
      GLint error_size {};
      glGetShaderiv(m_handle_, GL_INFO_LOG_LENGTH, &error_size);
      std::string error_message(static_cast<size_t>(error_size + 1), '\0');
      glGetShaderInfoLog(m_handle_, error_size, nullptr, error_message.data());
      glDeleteShader(m_handle_);
      m_handle_ = 0;
      throw std::runtime_error("Shader failed to compile with reason: " + error_message);
    }
  }
} // namespace open::gl

程序.hxx：

#pragma once

#include <vector>
#include <glad/glad.h>

namespace open::gl {
  struct shader;

  struct program {
    using handle = GLuint;

    program();
    program(shader const &shader);
    program(std::vector<open::gl::shader *> const &shaders);

    handle id() const;
    void attach(open::gl::shader const &shader);
    void link() const;

    program(program && other) noexcept;
    program(program const &other) = delete;

    program &operator =(program const &other) = delete;
    program &operator =(program &&other) noexcept;

  private:
    handle m_handle_;
  };
} // namespace open::gl

程序.cxx：

#include "program.hxx"
#include "shader.hxx"
#include <utility>
#include <stdexcept>

namespace open::gl {
  program::program()
    : m_handle_(glCreateProgram()) {
    // error checking...
  }

  program::program(open::gl::shader const &shader)
    : program() {
    attach(shader);
    link();
  }

  program::program(std::vector<open::gl::shader *> const &shaders)
    : program() {
    for (open::gl::shader const *shader : shaders) {
      attach(*shader);
    }

    link();
  }

  program::handle
  program::id() const {
    return m_handle_;
  }

  void program::attach(open::gl::shader const &shader) {
    glAttachShader(m_handle_, shader.id());
    // error checking...
  }

  void program::link() const {
    glLinkProgram(m_handle_);
    GLint compile_status {};

    glGetProgramiv(m_handle_, GL_LINK_STATUS, &compile_status);

    if (!compile_status) {
      size_t log_length {};
      glGetProgramiv(m_handle_, GL_INFO_LOG_LENGTH,
                     reinterpret_cast<GLint *>(&log_length));
      if (log_length > 0) {
        std::string error_message(log_length, '\0');
        glGetProgramInfoLog(m_handle_, log_length, nullptr, error_message.data());
        throw std::runtime_error("Failed to link program with reason :" + error_message);
      }
      throw std::runtime_error("Failed to link program with unknown reason");
    }
  }

  program::program(program &&other) noexcept
    : m_handle_(std::exchange(other.m_handle_, 0))
  { }

  program
  &program::operator =(program &&other) noexcept {
    if (&other != this) {
      m_handle_ = std::exchange(other.m_handle_, 0);
    }

    return *this;
  }

} // namespace open::gl

fragment_shader.hxx：

#pragma once

#include "shader.hxx"

namespace open::gl {
  struct fragment_shader
    : public shader {
    fragment_shader(std::string const &src);
    fragment_shader(std::filesystem::path const &path);
  };
} // namespace open::gl

fragment_shader.cxx：

#include "fragment_shader.hxx"

namespace open::gl {
  fragment_shader::fragment_shader(std::string const &src)
    : shader(shader::type::fragment, src)
  { }

  fragment_shader::fragment_shader(std::filesystem::path const &path)
    : shader(shader::type::fragment, path)
  { }
} // namespace open::gl

vertex_shader.hxx：

#pragma once

#include "shader.hxx"

namespace open::gl {
  struct vertex_shader
    : public shader {
    vertex_shader(std::string const &src);
    vertex_shader(std::filesystem::path const &path);
  };
} // namespace open::gl

vertex_shader.cxx：

#include "vertex_shader.hxx"

namespace open::gl {
  vertex_shader::vertex_shader(std::string const &src)
    : shader(shader::type::vertex, src)
  { }

  vertex_shader::vertex_shader(std::filesystem::path const &path)
    : shader(shader::type::vertex, path)
  { }
} // namespace open::gl

utils.hxx：

#pragma once

#include <string>
#include <fstream>
#include <iostream>
#include <filesystem>

namespace open::gl::utils {
  std::string
  path_to_content(std::filesystem::path const &path) {
    try {
      std::ifstream resource(path.string());
      std::streamsize file_length
        = resource
            .seekg(0, std::ios::end)
            .tellg();
      resource.seekg(0, std::ios::beg);
      std::string content(file_length, '\0');
      resource.read(content.data(), file_length);
      return content;
    } catch (std::iostream::failure const &ex) {
      std::cerr << "Failed to open input file: " << ex.what() << '\n';
      throw;
    }
  }
} // namespace open::gl::utils

jdoseIOO · Answer 2 · 2024-07-27T13:30:15Z

Best Answer

jdoseIOO

2024-07-27T13:30:15Z2024-07-27T13:30:15Z

感谢@evo，在他的话之后“复制视频卡资源，包括着色器，是不可能的，你不能复制着色器类，它必须是唯一的，就像程序类一样，你可能已经在析构函数中删除了着色器，并且之后它不可用”。听完他的话，我决定更改我的代码。和以前一样（有错误）：

// класс Program
Program::Program(vector<Shader> shaders);

// в main
vector<Shader> shaders = {shader1, shader2, ...};
Program program(shaders);

这是错误的选择。我传递给程序的不是着色器的链接，而是着色器的副本，因此，调用析构函数，从视频卡的内存中删除着色器。在新版本中，我传递了对着色器的引用，因此不会调用析构函数。现在是这样（没有错误）：

// класс Program
Program::Program(vector<Shader*> &shaders);

// в main
vector<Shader*> shaders = {&shader1, &shader2, ...};
Program program(shaders);

现在没有错误了，感谢@evo 的帮助。

0

OpenGL 着色器程序已停止将着色器附加到自身

我看不懂措辞

请求的模块“del”不提供名为“default”的导出

"!+tab" 在 HTML 的 vs 代码中不起作用

我正在尝试解决“猜词”的问题。Python

可以使用哪些命令将当前指针移动到指定的提交而不更改工作目录中的文件？

Python解析野莓

问题：“警告：检查最新版本的 pip 时出错。”

帮助编写一个用值填充变量的循环。解决这个问题

尽管依赖数组为空，但在渲染上调用了 2 次 useEffect

数据不通过 Telegram.WebApp.sendData 发送

OpenGL 着色器程序已停止将着色器附加到自身

2 个回答

相关问题