現代 OpenGL 中的球體網格

Question

我正在嘗試創建一個球體表面的三角形網格並使用 OpenGL 4.1 繪制它。

這是我目前使用的代碼，從該問題的第二個答案中獲得，頂點布局是 [x, y, z, r, b, g, a] 這就是為什么每個頂點有 7 個浮點數：

std::vector<float> vertices;
std::vector<unsigned int> indices;
const float dLambda = 2 * glm::pi<float>() / meridianNumber;
const float dPhi = glm::pi<float>() / parallelNumber;
unsigned int lastVertex = 0;


for (int i = 0; i < parallelNumber; ++i) {
    for (int j = 0; j < meridianNumber; ++j) {
        std::cout << "lot: " << glm::degrees(j * dLambda);
        std::cout << "\tlat: " << glm::degrees(i * dPhi);
        std::cout << std::endl;
        float lambda1 = j * dLambda;
        float phi1 = i * dPhi;
        float lambda2 = j+1 == parallelNumber   ? 2 * glm::pi<float>()
                                                : (j+1) * dLambda;
        float phi2 = i+1 == meridianNumber   ? glm::pi<float>()
                                             : (i+1) * dPhi;

        // vertex 1
        vertices.emplace_back(cosf(lambda1) * sinf(phi1) * radius);
        vertices.emplace_back(cosf(phi1) * radius);
        vertices.emplace_back(sinf(lambda1) * sinf(phi1) * radius);
        vertices.emplace_back(0.5f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);

        // vertex 2
        vertices.emplace_back(cosf(lambda1) * sinf(phi2) * radius);
        vertices.emplace_back(cosf(phi2) * radius);
        vertices.emplace_back(sinf(lambda1) * sinf(phi2) * radius);
        vertices.emplace_back(0.5f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);

        // vertex 3
        vertices.emplace_back(cosf(lambda2) * sinf(phi1) * radius);
        vertices.emplace_back(cosf(phi1) * radius);
        vertices.emplace_back(sinf(lambda2) * sinf(phi1) * radius);
        vertices.emplace_back(0.5f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);

        // vertex 4
        vertices.emplace_back(cosf(lambda2) * sinf(phi2) * radius);
        vertices.emplace_back(cosf(phi2) * radius);
        vertices.emplace_back(sinf(lambda2) * sinf(phi2) * radius);
        vertices.emplace_back(0.5f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);
        vertices.emplace_back(1.0f);

        indices.emplace_back(lastVertex);
        indices.emplace_back(lastVertex+1);
        indices.emplace_back(lastVertex+2);

        indices.emplace_back(lastVertex+1);
        indices.emplace_back(lastVertex+3);
        indices.emplace_back(lastVertex+2);

        lastVertex += 4;
    }

但我做錯了什么，因為這就是我在畫的東西：

我用來繪制的代碼是：

GLCall(glDrawElements(
    GL_TRIANGLES,
    indicesNumber,
    GL_UNSIGNED_INT,
    (const void*) 0
));

編輯 1： VAO 設置非常復雜，因為我在 opengl 上寫了一點抽象層……我有一個名為 VertexBuffer 的類，它可以創建、保持活動並銷毀 OpenGL 數組緩沖區。 另一個類 IndexBuffer 與前一個管理 Element 數組緩沖區的類非常相似。 這兩個類使用起來非常簡單，它們可以被構造、綁定、解除綁定和銷毀，僅此而已。 還有第三個類表示 OpenGL 頂點緩沖區中單個頂點的布局； 這個名為 VertexLayout 的類包含調用 glVertexAttribPointer 所需的所有數據。

馬力：

class VertexLayout {
private:
    struct Element {
        unsigned int type;
        unsigned int count;
        unsigned char normalized;
        size_t typeSize;

        Element(
            unsigned int type, unsigned int count, unsigned char normalized,
            size_t typeSize
        );
    };
    std::vector<Element> elements;
    unsigned int stride;

public:

    VertexLayout();

    template<typename T>
    VertexLayout &push(unsigned int count, unsigned char normalized = GL_FALSE){
        std::fputs(
            "this function has to be implemented for desired type",
            stderr
        );
        assert(false);
        return *this;
    }

    const std::vector<Element> &getElements() const;

    unsigned int getStride() const;

};

cp：

template<>
VertexLayout &VertexLayout::push<unsigned int>(
    unsigned int count, unsigned char normalized
) {
    elements.emplace_back(
        GL_UNSIGNED_INT, count, normalized, sizeof(unsigned int)
    );
    stride += count * sizeof(unsigned int);
    return *this;
};

template<>
VertexLayout &VertexLayout::push<unsigned char>(
    unsigned int count, unsigned char normalized
) {
    elements.emplace_back(
        GL_UNSIGNED_BYTE, count, normalized, sizeof(unsigned char)
    );
    stride += count * sizeof(unsigned char);
    return *this;
};

template<>
VertexLayout &VertexLayout::push<float>(unsigned int count, unsigned char normalized){
    elements.emplace_back(GL_FLOAT, count, normalized, sizeof(float));
    stride += count * sizeof(float);
    return *this;
}

VertexLayout::Element::Element(
    unsigned int type, unsigned int count,
    unsigned char normalized, size_t typeSize
) : type(type), count(count), normalized(normalized), typeSize(typeSize) {}

const std::vector<VertexLayout::Element> &VertexLayout::getElements()   const {
    return elements;
}

unsigned int VertexLayout::getStride() const {
    return stride;
}

VertexLayout::VertexLayout() : stride(0) {}

因此，應該為每個 VertexBuffer 對象創建一個 VertexLayout 實例，並且應該將 foreach opengl 屬性稱為push<type>(numberOfElementOfThatType) 。

第四個也是最后一個類是表示 VAO 的 VertexArray 類：最后一個類跟蹤所有連接到 VAO 的 VertexBuffer 和 IndexBuffer 對象，並在使用以下方法添加 VertexBuffer 時設置調用 glVertexAttribPointer 的布局：

void VertexArray::addBuffer(
    const VertexBuffer &buffer, const VertexLayout &layout
) {
    GLCall(glBindVertexArray(id));
    buffer.bind();
    const auto &elements = layout.getElements();
    size_t offset = 0;
    for (unsigned int i = 0; i < elements.size(); ++i) {
        const auto &element = elements[i];
        GLCall(glEnableVertexAttribArray(i));
        GLCall(glVertexAttribPointer(
            i, element.count, element.type, element.normalized,
            layout.getStride(), (const void *)offset
        ));
        offset += element.count * element.typeSize;
    }
    vertexBuffers.emplace_back(buffer);
}

GLCall 是一個宏，它在發布時什么都不做，而在調試時清除 OpenGL 錯誤並打印新錯誤。

編輯 2：這是代表一個 VBO 的 VertexBuffer 類：

馬力

class VertexBuffer {
private: // static
    static std::map<unsigned int, unsigned int> references;

private: // member
    unsigned int rendererID;

public:
    VertexBuffer();

    VertexBuffer(
        const void *data, unsigned long size,
        unsigned int usage = GL_STATIC_DRAW
    );
    VertexBuffer(const VertexBuffer &oth);
    VertexBuffer &operator=(const VertexBuffer &rhs);

    ~VertexBuffer();

    void bind() const;
    void unbind() const;
};

cp：

std::map<unsigned int, unsigned int> VertexBuffer::references;

VertexBuffer::VertexBuffer(
    const void *data,
    unsigned long size,
    unsigned int usage
) {
    GLCall(glGenBuffers(1, &rendererID));
    GLCall(glBindBuffer(GL_ARRAY_BUFFER, rendererID));
    GLCall(glBufferData(GL_ARRAY_BUFFER, size, data, usage));
    references.insert_or_assign(rendererID, 1);
}

VertexBuffer::VertexBuffer(const VertexBuffer &oth) {
    if (oth.rendererID != 0){
        auto ref = references.find(oth.rendererID);
        assert(ref != references.end());
        ref->second++;
    }
    rendererID = oth.rendererID;
}

VertexBuffer &VertexBuffer::operator=(const VertexBuffer &rhs) {
    if (rendererID != 0) {
        auto refs = references.find(rendererID);
        assert(refs != references.end());

        if (--refs->second == 0) {
            GLCall(glDeleteBuffers(1, &rendererID));
            references.erase(refs);
        }
    }
    if (rhs.rendererID != 0){
        auto ref = references.find(rhs.rendererID);
        assert(ref != references.end());
        ref->second++;
    }
    rendererID = rhs.rendererID;

    return *this;
}

VertexBuffer::VertexBuffer() : rendererID(0) {}

VertexBuffer::~VertexBuffer() {
    if (rendererID != 0) {
        auto ref = references.find(rendererID);
        assert(ref != references.end());
        if (--ref->second == 0) {
            GLCall(glDeleteBuffers(1, &rendererID));
            references.erase(ref);
        }
    }
}

void VertexBuffer::bind() const {
    GLCall(glBindBuffer(GL_ARRAY_BUFFER, rendererID));
}

void VertexBuffer::unbind() const {
    GLCall(glBindBuffer(GL_ARRAY_BUFFER, 0));
}

在球體中，我只有一個包含位置和顏色的大緩沖區。

Answer 1

我找到了解決方案。 這是一個非常愚蠢的錯誤：VertexBuffer 類的構造函數需要以字節為單位的緩沖區大小，但是當我調用它時，我只傳遞了 std::vector 的大小，即元素的數量。