4

我对使用 SDL、OpenGL 和 C++ 的游戏开发相当深入，并且正在寻找方法来优化游戏在 GLSL 着色器之间切换的方式，以处理不同类型的许多不同对象。这更像是一个 C++ 问题，而不是 OpenGL 问题。但是，我仍然想提供尽可能多的上下文，因为我觉得需要一些理由来说明为什么我需要的提议的 Shader 类需要按原样创建/删除。

前四个部分是我的理由，旅程和尝试导致这一点，但是我的问题很可能仅通过最后一部分来回答，我特意把它写成一个 tldr。

Shader 类的必要性：

当在游戏过程中创建游戏对象时，我已经看到许多在同一函数中创建、编译和删除 OpenGL 着色器的在线实现。事实证明，这在我的游戏的特定部分效率低下且速度太慢。因此，我需要一个在加载期间创建和编译着色器的系统，然后在游戏期间间歇性地在它们之间使用/交换，然后再被删除。

这导致了Shader管理 OpenGL 着色器的类（）的创建。该类的每个实例都应管理一个唯一的 OpenGL 着色器，并包含围绕着色器类型的一些复杂行为，它从哪里加载，在哪里使用，它采用的统一变量等。

话虽如此，这个类最重要的作用是存储从 中返回的GLuint变量，并通过这个来管理所有与 OpenGL 着色器相关的 OpenGL 调用。我知道鉴于 OpenGL 的全局性质，这实际上是徒劳的（因为程序中的任何地方都可以在技术上调用匹配并破坏类），但是为了有意将所有 OpenGL 调用封装到整个代码库中非常特定的区域，这系统将大大降低代码复杂度。idglCreateShader()idglDeleteShader()id

问题从哪里开始...

管理 this 的最“自动”方式GLuint id是调用glCreateShader()对象的构造和glDeleteShader()对象的销毁。void createShader()这保证（在 OpenGL 限制内）OpenGL 着色器将存在于 C++ 着色器对象的整个生命周期中，并且无需调用某些deleteShader()函数。

这一切都很好，但是当考虑复制这个对象会发生什么时，很快就会出现问题。如果这个对象的副本被破坏了怎么办？这意味着glDeleteShader()它将被调用并有效地破坏着色器对象的所有副本。

像意外调用std::vector::push_back()着色器向量这样的简单错误呢？各种std::vector方法可以调用其类型的构造函数/复制构造函数/析构函数，这可能会导致与上述相同的问题。

好吧……即使很乱，我们也可以创建一些void createShader()和方法怎么样？deleteShader()不幸的是，这只是推迟了上述问题，因为任何修改 OpenGL 着色器的调用都会取消同步/彻底破坏具有相同id. 我在这个例子中限制了 OpenGL 调用以glCreateShader()保持glDeleteShader()简单，但是我应该注意，类中还有许多其他 OpenGL 调用会导致创建各种实例/静态变量来跟踪实例副本过于复杂证明这样做是合理的。

在进入下面的类设计之前，我想说的最后一点是，对于像原始 C++、OpenGL 和 SDL 游戏这样大的项目，如果我犯的任何潜在的 OpenGL 错误会生成编译器错误而不是图形问题，我更愿意更难追踪。这可以反映在下面的类设计中。

类的第一个版本Shader：

基于以上原因，我选择了：

  • 制作构造函数private。
  • 提供一个公共static create函数，该函数返回一个指向新 Shader 对象的指针来代替构造函数。
  • 制作复制构造函数private。
  • 制作operator= private（尽管这可能不是必需的）。
  • 将析构函数设为私有。
  • glCreateShader()在构造函数和析构函数中调用glDeleteShader()，以使 OpenGL 着色器在该对象的生命周期中存在。
  • 当create函数调用new关键字（并返回指向它的指针）时，Shader::create()必须delete手动调用外部调用的地方（稍后会详细介绍）。

据我了解，前两个要点使用工厂模式，如果尝试创建类的非指针类型，则会生成编译器错误。第三、第四和第五个要点然后防止对象被复制。然后，第七个要点确保 OpenGL 着色器将在 C++ 着色器对象的相同生命周期内存在。

智能指针和主要问题：

上面我唯一不喜欢的就是new/delete调用。glDeleteShader()考虑到类试图实现的封装，它们还使对象的析构函数中的调用感觉不合适。鉴于此，我选择：

  • 更改create函数以返回类型的 astd::unique_ptr而Shader不是Shader指针。

然后create函数看起来像这样：

std::unique_ptr<Shader> Shader::create() {
    return std::make_unique<Shader>();
}

但是随后出现了一个新问题……std::make_unique不幸的是，它要求构造函数是public，这会干扰上一节中描述的必需品。幸运的是，我找到了一个解决方案，将其更改为：

std::unique_ptr<Shader> Shader::create() {
    return std::unique_ptr<Shader>(new Shader());
}

但是......现在std::unique_ptr要求析构函数是公开的！这……更好但不幸的是，这意味着可以在类外部手动调用析构函数，这反过来意味着glDeleteShader()可以从类外部调用该函数。

Shader* p = Shader::create();
p->~Shader(); // Even though it would be hard to do this intentionally, I don't want to be able to do this.
delete p;

最后一课：

为简单起见，我删除了大部分实例变量、函数/构造函数参数和其他属性，但最终提议的类（大部分）如下所示：

class GLSLShader {

public:
    ~GLSLShader() { // OpenGL delete calls for id }; // want to make this private.

    static std::unique_ptr<GLSLShader> create() { return std::unique_ptr<GLSLShader>(new GLSLShader()); };

private:
    GLSLShader() { // OpenGL create calls for id };

    GLSLShader(const GLSLShader& glslShader);
    GLSLShader& operator=(const GLSLShader&);

    GLuint id;

};

除了析构函数是公共的这一事实之外，我对这个类中的所有内容都很满意。我已经对这个设计进行了测试，性能提升非常明显。尽管我无法想象我会不小心手动调用Shader对象的析构函数，但我不喜欢它被公开。我也觉得我可能会不小心漏掉一些东西，比如std::vector::push_back第二部分的考虑。

对于这个问题，我找到了两种可能的解决方案。我想对这些或其他解决方案提出一些建议。

  1. 使std::unique_ptr或类。std::make_unique_ 我一直在阅读诸如this one之类的线程，但是这是为了使构造函数可访问，而不是析构函数。我也不太明白制作或制作（该线程的最佳答案+评论）所需的缺点/额外考虑因素？friendShaderstd::unique_ptrstd::make_uniquefriend

  2. 根本不使用智能指针。有没有办法让我的static create()函数返回一个原始指针（使用关键字），当超出范围并调用析构函数时，它会new在类/内部自动删除？Shader

非常感谢您的宝贵时间。

4

2 回答 2

2

这是一个上下文挑战。

你正在解决错误的问题。

GLuint id, 将是调用glCreateShader()对象的构造和glDeleteShader()

在这里修复问题。

零规则是您让资源包装器管理生命周期，而不是在业务逻辑类型中这样做。我们可以在 a 周围编写一个包装器，GLuint它知道如何清理自己并且只能移动，通过劫持std::unique_ptr存储整数而不是指针来防止双重破坏。

开始了：

// "pointers" in unique ptrs must be comparable to nullptr.
// So, let us make an integer qualify:
template<class Int>
struct nullable{
  Int val=0;
  nullable()=default;
  nullable(Int v):val(v){}
  friend bool operator==(std::nullptr_t, nullable const& self){return !static_cast<bool>(self);}
  friend bool operator!=(std::nullptr_t, nullable const& self){return static_cast<bool>(self);}
  friend bool operator==(nullable const& self, std::nullptr_t){return !static_cast<bool>(self);}
  friend bool operator!=(nullable const& self, std::nullptr_t){return static_cast<bool>(self);}
  operator Int()const{return val;}
};

// This both statelessly stores the deleter, and
// tells the unique ptr to use a nullable<Int> instead of an Int*:
template<class Int, void(*deleter)(Int)>
struct IntDeleter{
  using pointer=nullable<Int>;
  void operator()(pointer p)const{
    deleter(p);
  }
};

// Unique ptr's core functionality is cleanup on destruction
// You can change what it uses for a pointer. 
template<class Int, void(*deleter)(Int)>
using IntResource=std::unique_ptr<Int, IntDeleter<Int,deleter>>;

// Here we statelessly remember how to destroy this particular
// kind of GLuint, and make it an RAII type with move support:
using GLShaderResource=IntResource<GLuint,glDeleteShader>;

现在该类型知道它是一个着色器并将其自身清理为非空。

GLShaderResource id(glCreateShader());
SomeGLFunction(id.get());

对任何错别字表示歉意。

在您的班级中填充这些内容，复制 ctors 被阻止，移动 ctors 做正确的事情，dtors 自动清理等等。

struct GLSLShader {
  // public!
  ~GLSLShader() = default;
  GLSLShader() { // OpenGL create calls for id };
private: // does this really need to be private?
  GLShaderResource id;
};

简单多了。

std::vector<GLSLShader> v;

这很有效。我们GLShaderResource是半常规的（仅移动常规类型，不支持排序），并且vector对这些感到满意。0 规则意味着GLSLShader拥有它的 也是半规则的并支持 RAII——资源分配是初始化——这反过来意味着它在存储在std容器中时会自行清理。

一个“常规”类型意味着它“表现得像一个int”——就像原型值类型一样。当您使用常规或半常规类型时，C++ 的标准库和大部分 C++ 都喜欢它。

请注意，这基本上是零开销；sizeof(GLShaderResource)是一样GLuint的，堆上什么也没有。我们有一堆编译时类型的机器，包装了一个简单的 32 位整数；编译时类型的机器生成代码，但不会使数据比 32 位更复杂。

活生生的例子。

开销包括：

  1. 一些调用约定使得传递struct包装只int传递与传递不同int。

  2. 在销毁时，我们检查每一个，看看是否0要决定是否要调用glDeleteShader；编译器有时可以证明某些东西保证为零并跳过该检查。但它不会告诉你它是否确实成功了。（OTOH，众所周知，人类在证明他们跟踪所有资源方面很糟糕，所以一些运行时检查并不是最糟糕的事情）。

  3. 如果你正在做一个完全未优化的构建，当你调用一个 OpenGL 函数时会有一些额外的指令。但是在编译器的任何非零级别inlineing 之后，它们都会消失。

  4. 该类型在某些方面（可复制、可销毁、可构造）并不是“微不足道的”（C++ 标准中的一个术语），这使得memset在 C++ 标准下做类似非法的事情；您不能以一些低级的方式将其视为原始内存。

一个问题！

许多 OpenGL 实现都有指向glDeleteShader/glCreateShader等的指针，上面依赖于它们是实际的函数，而不是指针或宏或其他任何东西。

有两种简单的解决方法。第一个是在上面&的deleter参数中添加 a（两个点）。这有一个问题，它只在它们现在实际上是指针时才有效，而不是当它们是实际函数时。

编写在这两种情况下都有效的代码有点棘手，但我认为几乎每个 GL 实现都使用函数指针，所以你应该很好，除非你想做一个“库质量”的实现。在这种情况下，您可以编写一些帮助类型来创建 constexpr 函数指针，这些函数指针按名称调用（或不调用）函数指针。

最后，显然一些析构函数需要额外的参数。这是一个草图。

using GLuint=std::uint32_t;

GLuint glCreateShaderImpl() { return 7; }
auto glCreateShader = glCreateShaderImpl;
void glDeleteShaderImpl(GLuint x) { std::cout << x << " deleted\n"; }
auto glDeleteShader = glDeleteShaderImpl;

std::pair<GLuint, GLuint> glCreateTextureWrapper() { return {7,1024}; }

void glDeleteTextureImpl(GLuint x, GLuint size) { std::cout << x << " deleted size [" << size << "]\n"; }
auto glDeleteTexture = glDeleteTextureImpl;

template<class Int>
struct nullable{
  Int val=0;
  nullable()=default;
  nullable(Int v):val(v){}
  nullable(std::nullptr_t){}
  friend bool operator==(std::nullptr_t, nullable const& self){return !static_cast<bool>(self);}
  friend bool operator!=(std::nullptr_t, nullable const& self){return static_cast<bool>(self);}
  friend bool operator==(nullable const& self, std::nullptr_t){return !static_cast<bool>(self);}
  friend bool operator!=(nullable const& self, std::nullptr_t){return static_cast<bool>(self);}
  operator Int()const{return val;}
};

template<class Int, auto& deleter>
struct IntDeleter;

template<class Int, class...Args, void(*&deleter)(Int, Args...)>
struct IntDeleter<Int, deleter>:
  std::tuple<std::decay_t<Args>...>
{
  using base = std::tuple<std::decay_t<Args>...>;
  using base::base;
  using pointer=nullable<Int>;
  void operator()(pointer p)const{
    std::apply([&p](std::decay_t<Args> const&...args)->void{
        deleter(p, args...);
    }, static_cast<base const&>(*this));
  }
};

template<class Int, void(*&deleter)(Int)>
using IntResource=std::unique_ptr<Int, IntDeleter<Int,deleter>>;

using GLShaderResource=IntResource<GLuint,glDeleteShader>;

using GLTextureResource=std::unique_ptr<GLuint,IntDeleter<GLuint, glDeleteTexture>>;

int main() {
    auto res = GLShaderResource(glCreateShader());
    std::cout << res.get() << "\n";
    auto tex = std::make_from_tuple<GLTextureResource>(glCreateTextureWrapper());
    std::cout << tex.get() << "\n";
}
于 2021-03-04T10:28:02.383 回答
1

自己实现一个删除器，让删除器成为你班级的朋友。然后像这样编辑您的声明：

static std::unique_ptr<GLSLShader, your_deleter> create();
于 2021-03-04T08:29:11.043 回答