below code running report: CommandStream used too much space (will block)

[MrZhuGitHub]

// Main code
int main(int, char**)
{
// 初始化GLFW
if (!glfwInit()) {
std::cerr << "Failed to initialize GLFW" << std::endl;
return -1;
}

// 设置OpenGL版本为3.3
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

//glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);

// 创建窗口
GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Triangle", nullptr, nullptr);
if (!window) {
    std::cerr << "Failed to create GLFW window" << std::endl;
    glfwTerminate();
    return -1;
}
glfwMakeContextCurrent(window);

// // 初始化GLEW
// if (glewInit() != GLEW_OK) {
//     std::cerr << "Failed to initialize GLEW" << std::endl;
//     return -1;
// }

App app{};

Engine *engine = Engine::create(Engine::Backend::OPENGL);
SwapChain *swapChain = engine->createSwapChain(glfwGetWin32Window(window));
Renderer *renderer = engine->createRenderer();
Scene *scene = engine->createScene();
View *view = engine->createView();

int width, height;
glfwGetFramebufferSize(window, &width, &height);
if (width && height) {
    view->setViewport({0, 0, (uint32_t)width, (uint32_t)height});
}

auto setup = [&app](Engine* engine, View* view, Scene* scene) {
    app.skybox = Skybox::Builder().color({0.1, 0.125, 0.25, 1.0}).build(*engine);
    scene->setSkybox(app.skybox);
    view->setPostProcessingEnabled(false);
    static_assert(sizeof(Vertex) == 12, "Strange vertex size.");
    app.vb = VertexBuffer::Builder()
            .vertexCount(3)
            .bufferCount(1)
            .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT2, 0, 12)
            .attribute(VertexAttribute::COLOR, 0, VertexBuffer::AttributeType::UBYTE4, 8, 12)
            .normalized(VertexAttribute::COLOR)
            .build(*engine);
    app.vb->setBufferAt(*engine, 0,
            VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 36, nullptr));
    app.ib = IndexBuffer::Builder()
            .indexCount(3)
            .bufferType(IndexBuffer::IndexType::USHORT)
            .build(*engine);
    app.ib->setBuffer(*engine,
            IndexBuffer::BufferDescriptor(TRIANGLE_INDICES, 6, nullptr));
    app.mat = Material::Builder()
            .package(RESOURCES_BAKEDCOLOR_DATA, RESOURCES_BAKEDCOLOR_SIZE)
            .build(*engine);
    app.renderable = EntityManager::get().create();
    RenderableManager::Builder(1)
            .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
            .material(0, app.mat->getDefaultInstance())
            .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb, app.ib, 0, 3)
            .culling(false)
            .receiveShadows(false)
            .castShadows(false)
            .build(*engine, app.renderable);
    scene->addEntity(app.renderable);
    app.camera = utils::EntityManager::get().create();
    app.cam = engine->createCamera(app.camera);
    view->setCamera(app.cam);
    view->setScene(scene);
};

setup(engine, view, scene);

float time = 0.0;

while (!glfwWindowShouldClose(window)) {
    time = time + 1.0;
    if (time > 10000.0) {
        time = 0.0;
    }

    {
        constexpr float ZOOM = 1.5f;
        const uint32_t w = view->getViewport().width;
        const uint32_t h = view->getViewport().height;
        const float aspect = (float) w / h;
        app.cam->setProjection(Camera::Projection::ORTHO,
        -aspect * ZOOM, aspect * ZOOM,
        -ZOOM, ZOOM, 0, 1);
        auto& tcm = engine->getTransformManager();
        tcm.setTransform(tcm.getInstance(app.renderable),
        filament::math::mat4f::rotation(time, filament::math::float3{ 0, 0, 1 }));
    }
    
    if (renderer->beginFrame(swapChain)) {
        renderer->render(view);
        renderer->endFrame();
    }

    glfwPollEvents();

}

engine->destroy(app.skybox);
engine->destroy(app.renderable);
engine->destroy(app.mat);
engine->destroy(app.vb);
engine->destroy(app.ib);
engine->destroyCameraComponent(app.camera);
utils::EntityManager::get().destroy(app.camera);

engine->destroy(view);
engine->destroy(scene);
engine->destroy(renderer);
engine->destroy(swapChain);
Engine::destroy(&engine);

glfwDestroyWindow(window);
glfwTerminate();

return 0;

}