现代OpenGL中的球体网格

我正在尝试创建一个球体表面的三角形网格，并使用OpenGL 4.1绘制它 .

这是我正在使用的代码从question的第二个答案中获得，顶点布局是[x，y，z，r，b，g，a]，这就是为什么有7个浮点foreach顶点：

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;
    }

但我做错了，因为's what I'米画：

我用来绘制的代码是：

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

EDIT 1: VAO设置非常复杂，因为我在opengl上写了一小段抽象...我有一个名为VertexBuffer的类，可以创建，保持活动并破坏OpenGL数组缓冲区 . 另一个类IndexBuffer与管理Element数组缓冲区的前一个类非常相似 . 这两个类使用起来非常简单，它们可以构造，绑定，解除绑定和破坏，仅此而已 . 第三个类表示OpenGL顶点缓冲区中单个顶点的布局;这个名为VertexLayout的类包含调用glVertexAttribPointer所需的所有数据 .

HPP：

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;

};

CPP：

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) {}

因此，应该在foreex 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错误并打印新错误 .

EDIT 2: 这是代表一个VBO的类VertexBuffer：

HPP

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;
};

CPP：

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));
}

在球体中，我只有一个包含位置和颜色的大缓冲区 .