Почему glbuffersubdata в розыгрыше косвенного буфера вызывает аварию [закрыто] ⇐ C++

[Anonymous]

Я пытаюсь использовать glmultidrawelements indirect , чтобы нарисовать некоторые примитивы. Я пишу небольшую абстракцию вокруг него для моего рендеринга, поскольку он все еще на ранних стадиях разработки.
Когда я пытаюсь позвонить Glbuffersubdata, чтобы обновить косвенный буфер, в котором приложение сбивается. Он работает нормально, когда я размещаю обновление буфера в BloseRawCommands () , но он все еще ничего не делает. Однако, когда я переключаюсь на gldrawlements, я получаю примитивный рендеринг, как и ожидалось.struct DrawElementsIndirectCommand {
uint32_t count;
uint32_t instanceCount;
uint32_t firstIndex;
int baseVertex;
uint32_t baseInstance;
};

struct {
uint32_t vao;
uint32_t vbo;
uint32_t ebo;
uint32_t ibo;

const int MAX_VERTEX = 300000;
const int MAX_INDICES = 900000;

const int MAX_DRAW_COMMANDS = 100;
DrawElementsIndirectCommand* commands;
int commandPtr = 0;

int indexCount = 0;
int vertexCount = 0;
int currentVertexCount = 0;
int currentIndexCount = 0;
}rendererData;

void Initialize()
{
glGenVertexArrays(1, &rendererData.vao);
glBindVertexArray(rendererData.vao);

glGenBuffers(1, &rendererData.vbo);
glGenBuffers(1, &rendererData.ebo);
glGenBuffers(1, &rendererData.ibo);

glBindBuffer(GL_ARRAY_BUFFER, rendererData.vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rendererData.ebo);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, rendererData.ibo);

glBufferData(GL_ARRAY_BUFFER, sizeof(Vertice) * rendererData.MAX_VERTEX, nullptr, GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * rendererData.MAX_INDICES, nullptr, GL_STATIC_DRAW);
glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand) * rendererData.MAX_DRAW_COMMANDS, nullptr, GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertice), 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertice), (void*)offsetof(Vertice,n));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertice), (void*)offsetof(Vertice,uv));
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertice), (void*)offsetof(Vertice,tan));
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertice), (void*)offsetof(Vertice,bitan));

glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);

rendererData.commands = (DrawElementsIndirectCommand*)malloc(sizeof(DrawElementsIndirectCommand) * rendererData.MAX_DRAW_COMMANDS);
rendererData.commandPtr = 0;

rendererData.indexCount = 0;
rendererData.vertexCount = 0;
rendererData.currentIndexCount = 0;
}

void Shutdown()
{
glDeleteVertexArrays(1, &rendererData.vao);
glDeleteBuffers(1, &rendererData.vbo);
glDeleteBuffers(1, &rendererData.ebo);
glDeleteBuffers(1, &rendererData.ibo);

free(rendererData.commands);

IAONNIS_LOG_INFO("Renderer has shutdown");
}

void submitDrawCommandData(DrawData data)
{
glBindVertexArray(rendererData.vao);
glBindBuffer(GL_ARRAY_BUFFER, rendererData.vbo);
glBufferSubData(GL_ARRAY_BUFFER, rendererData.vertexCount * sizeof(Vertice), sizeof(Vertice) * data.vertexCount, data.vertexPtr);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rendererData.ebo);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, rendererData.indexCount * sizeof(uint32_t), sizeof(uint32_t) * data.indexCount, data.indexPtr);

rendererData.currentVertexCount += data.vertexCount;
rendererData.currentIndexCount += data.indexCount;
}

void closeDrawCommands()
{
rendererData.commands[rendererData.commandPtr].baseInstance = 0;
rendererData.commands[rendererData.commandPtr].baseVertex = rendererData.vertexCount;
rendererData.commands[rendererData.commandPtr].count = rendererData.currentIndexCount;
rendererData.commands[rendererData.commandPtr].firstIndex = rendererData.indexCount;
rendererData.commands[rendererData.commandPtr].instanceCount = 1;

rendererData.commandPtr++;

rendererData.vertexCount += rendererData.currentVertexCount;
rendererData.indexCount += rendererData.currentIndexCount;

rendererData.currentIndexCount = 0;
rendererData.currentVertexCount = 0;
glBufferData(GL_DRAW_INDIRECT_BUFFER, rendererData.commandPtr * sizeof(DrawElementsIndirectCommand), &rendererData.commands, GL_DYNAMIC_DRAW);
}

void drawCommands()
{
glBindVertexArray(rendererData.vao);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, rendererData.ibo);

glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, rendererData.commandPtr, 0);
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}
< /code>
main.cpp
//..Initial code above...

uint32_t program = CreateShaderProgram("vertex.glsl", "fragment.glsl");
glUseProgram(program);

Renderer3D::Vertice vertices[] = {
{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}},
{{1.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}},
{{0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {0.0f, 1.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}
};

uint32_t indices[] =
{
0,1,2,
0,2,3,
};

Renderer3D::Initialize();

Renderer3D::DrawData data;
data.vertexCount = 4;
data.vertexPtr = vertices;
data.indexCount = 6;
data.indexPtr = indices;

Iaonnis::Renderer3D::submitDrawCommandData(data);

Renderer3D::closeDrawCommands();

glViewport(0, 0, 800, 800);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);

while (!glfwWindowShouldClose(window))
{
glClearColor(0.0, 0.5, 0.1, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Renderer3D::drawCommands();

glfwSwapBuffers(window);
glfwPollEvents();
}

Renderer3D::Shutdown();

glfwTerminate();
glfwDestroyWindow(window);
}



Подробнее здесь: https://stackoverflow.com/questions/797 ... se-a-crash