From 23d27183f6339bd1fe597a2b480c5753d784744f Mon Sep 17 00:00:00 2001 From: JungerBoyo Date: Wed, 6 Dec 2023 23:54:41 +0100 Subject: [PATCH] fixed issue with ring buffer sizes being too small in some cases, added world grid doc --- src/engine/chunk_pool.cpp | 18 ++-- src/engine/chunk_pool.h | 9 +- src/engine/engine.cpp | 4 +- src/engine/engine_context.h | 6 +- src/engine/meshing_engine.h | 4 +- src/engine/noise_terrain_generator.cpp | 2 +- src/engine/ringbuffer.h | 4 + src/engine/world_grid.cpp | 116 +++++++++++-------------- src/engine/world_grid.h | 51 ++++++++--- src/main.cpp | 3 +- ve001_log.1 | 97 ++++++++++----------- 11 files changed, 164 insertions(+), 150 deletions(-) diff --git a/src/engine/chunk_pool.cpp b/src/engine/chunk_pool.cpp index 247374f..78ccbb5 100644 --- a/src/engine/chunk_pool.cpp +++ b/src/engine/chunk_pool.cpp @@ -34,9 +34,7 @@ static void setVertexLayout(u32 vao, u32 vbo) { glVertexArrayVertexBuffer(vao, vertex_attrib_binding, vbo, 0, sizeof(Vertex)); } -void ChunkPool::init(i32 max_chunks) noexcept { - _chunks_count = max_chunks; - +void ChunkPool::init() noexcept { u32 tmp[3] = { 0U, 0U, 0U }; glCreateBuffers(3, tmp); @@ -51,21 +49,21 @@ void ChunkPool::init(i32 max_chunks) noexcept { glNamedBufferStorage( _dibo_id, - 6 * max_chunks * sizeof(DrawElementsIndirectCmd), + 6 * _chunks_count * sizeof(DrawElementsIndirectCmd), nullptr, GL_MAP_WRITE_BIT|GL_MAP_PERSISTENT_BIT|GL_MAP_COHERENT_BIT ); _dibo_mapped_ptr = glMapNamedBufferRange( _dibo_id, - 0, 6 * max_chunks * sizeof(DrawElementsIndirectCmd), + 0, 6 * _chunks_count * sizeof(DrawElementsIndirectCmd), GL_MAP_WRITE_BIT|GL_MAP_PERSISTENT_BIT|GL_MAP_COHERENT_BIT ); try { - _chunks.reserve(max_chunks); - _chunk_id_to_index.resize(max_chunks, INVALID_CHUNK_INDEX); - _voxel_data.resize(static_cast(max_chunks) * _engine_context.chunk_size_1D); + _chunks.reserve(_chunks_count); + _chunk_id_to_index.resize(_chunks_count, INVALID_CHUNK_INDEX); + _voxel_data.resize(static_cast(_chunks_count) * _engine_context.chunk_size_1D); _free_chunks = RingBuffer(_chunks_count, {}); _draw_cmds.reserve(_chunks_count * 6); for (std::size_t i{ 0U }; i < _chunks_count; ++i) { @@ -209,7 +207,9 @@ void ChunkPool::recreatePool(MeshingEngine::Result overflow_result) { const auto max_written_indices_z_axis = std::max(overflow_result.written_indices[Z_POS], overflow_result.written_indices[Z_NEG]); const auto max_written_indices = std::max(std::max(max_written_indices_x_axis, max_written_indices_y_axis), max_written_indices_z_axis); - auto new_max_vertices_in_submesh = static_cast(((1.5F * static_cast(max_written_indices)) / 6.F) * 4.F); + auto new_max_vertices_in_submesh = static_cast( + ((_engine_context.chunk_pool_growth_coefficient * static_cast(max_written_indices)) / 6.F) * 4.F + ); new_max_vertices_in_submesh = new_max_vertices_in_submesh + (4 - new_max_vertices_in_submesh % 4); _engine_context.chunk_max_current_submesh_size = new_max_vertices_in_submesh * sizeof(Vertex); diff --git a/src/engine/chunk_pool.h b/src/engine/chunk_pool.h index 98c31ab..430e094 100644 --- a/src/engine/chunk_pool.h +++ b/src/engine/chunk_pool.h @@ -127,7 +127,7 @@ struct ChunkPool { //////////////////////////////////// /// @brief count of all chunks in a pool - vmath::i32 _chunks_count; + vmath::u32 _chunks_count; /// @brief helper array translating chunk_id to its /// index in <_chunks> std::vector _chunk_id_to_index; @@ -158,12 +158,13 @@ struct ChunkPool { /// @brief meshing engine of the chunk pool. It schedules meshing /// tasks on the GPU - MeshingEngine _meshing_engine{ _engine_context }; + MeshingEngine _meshing_engine{ _engine_context, _chunks_count }; - ChunkPool(EngineContext& engine_context) : _engine_context(engine_context) {} + ChunkPool(EngineContext& engine_context, vmath::u32 max_chunks) : + _chunks_count(max_chunks), _engine_context(engine_context) {} /// @brief initializes chunk pool /// @param max_chunks number of chunks in a pool - void init(vmath::i32 max_chunks) noexcept; + void init() noexcept; /// @brief allocates chunk from _free_chunks /// @param voxel_write_data function writing voxel data to voxel data region (CPU) /// @param position position of the chunk diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp index 6907d29..c51f645 100644 --- a/src/engine/engine.cpp +++ b/src/engine/engine.cpp @@ -8,9 +8,6 @@ using namespace ve001; // #define SIMPLE_GENERATOR // #define MAX_DIV_FACTOR 1 - -static constexpr u64 MAX_DIV_FACTOR{ 32UL }; - // #define NO_RESIZE Engine::Engine(Vec3f32 world_size, Vec3f32 initial_position, Vec3i32 chunk_size) : _engine_context(EngineContext{ @@ -30,6 +27,7 @@ Engine::Engine(Vec3f32 world_size, Vec3f32 initial_position, Vec3i32 chunk_size) .chunk_max_current_mesh_size = sizeof(Vertex) * static_cast(24), .chunk_max_current_submesh_size = sizeof(Vertex) * static_cast(24/6), #endif + .chunk_pool_growth_coefficient = 1.5F, .meshing_axis_progress_step = 64 }), _world_grid(_engine_context, world_size, initial_position, diff --git a/src/engine/engine_context.h b/src/engine/engine_context.h index 6a41b2b..35351ac 100644 --- a/src/engine/engine_context.h +++ b/src/engine/engine_context.h @@ -25,12 +25,14 @@ struct EngineContext { vmath::u64 chunk_max_possible_mesh_size; /// @brief maximum possible mesh size of a single chunk's side after greedy meshing vmath::u64 chunk_max_possible_submesh_size; - /// @brief maximum current mesh size of a single chunk's side's indices after greedy meshing - // vmath::u64 chunk_max_current_submesh_indices_size; /// @brief maximum current mesh size of a single chunk after greedy meshing vmath::u64 chunk_max_current_mesh_size; /// @brief maximum current mesh size of a single chunk's side after greedy meshing vmath::u64 chunk_max_current_submesh_size; + /// @brief chunk pool memory growth coefficient + vmath::f32 chunk_pool_growth_coefficient; + /// @brief max possiblenumber of visible chunks + // vmath::u32 max_visible_chunks; /// @brief it maps to local_size_x attribute in greedy meshing compute shader vmath::i32 meshing_axis_progress_step; }; diff --git a/src/engine/meshing_engine.h b/src/engine/meshing_engine.h index 43b5b81..f5fa31a 100644 --- a/src/engine/meshing_engine.h +++ b/src/engine/meshing_engine.h @@ -90,9 +90,9 @@ struct MeshingEngine { const EngineContext& _engine_context; - MeshingEngine(const EngineContext& engine_context) + MeshingEngine(const EngineContext& engine_context, vmath::u32 max_chunks) : _engine_context(engine_context), - _commands(512, Command{}) {} + _commands(max_chunks, Command{}) {} void init(vmath::u32 vbo_id); diff --git a/src/engine/noise_terrain_generator.cpp b/src/engine/noise_terrain_generator.cpp index f99127b..1e0a696 100644 --- a/src/engine/noise_terrain_generator.cpp +++ b/src/engine/noise_terrain_generator.cpp @@ -34,7 +34,7 @@ void NoiseTerrainGenerator::threadInit() { // fn_add->SetRHS(fn_position_output); _smart_node = FastNoise::NewFromEncodedNodeTree( - "IQAZABAAexQOQA0AAwAAAAAAAEAIAAAAAAA/AAAAAAABAwCPwnU9AQQAmpkZPzMz87+uR+G+9ig8QOxRWEBxPYo/AAAAAAAAAAD//wEAAClcjz4=" + "IQAZABAAexQoQA0AAwAAAAAAAEAIAAAAAAA/AAAAAAABAwCPwnU9AQQAAAAAAArXo78AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wEAAClcjz4=" );//fn_add; } std::optional> NoiseTerrainGenerator::gen(vmath::Vec3i32 chunk_position) { diff --git a/src/engine/ringbuffer.h b/src/engine/ringbuffer.h index f961899..a91713d 100644 --- a/src/engine/ringbuffer.h +++ b/src/engine/ringbuffer.h @@ -19,6 +19,10 @@ struct RingBuffer { RingBuffer(std::size_t size, T fill_value) : _buffer(size, fill_value) {} + void resize(std::size_t new_size) { + _buffer.resize(new_size); + } + bool write(T value) noexcept { if (_writer_index == _reader_index && !_empty) { return false; diff --git a/src/engine/world_grid.cpp b/src/engine/world_grid.cpp index 2eb8652..323d41c 100644 --- a/src/engine/world_grid.cpp +++ b/src/engine/world_grid.cpp @@ -12,12 +12,6 @@ static bool isInElipsoid(Vec3f32 ellipsoid_center, Vec3f32 semi_axes, Vec3f32 po (diff[0]*diff[0])/(semi_axes[0]*semi_axes[0]) + (diff[1]*diff[1])/(semi_axes[1]*semi_axes[1]) + (diff[2]*diff[2])/(semi_axes[2]*semi_axes[2])) <= 1.F; - // return semi_axes[0]*semi_axes[0] > - // (point[0] - ellipsoid_center[0]) * (point[0] - ellipsoid_center[0]) + - // (point[1] - ellipsoid_center[1]) * (point[1] - ellipsoid_center[1]) + - // (point[2] - ellipsoid_center[2]) * (point[2] - ellipsoid_center[2]); - - // return true; } static bool isInBoundingBox(Vec3i32 p0, Vec3i32 p1, Vec3i32 point) { @@ -30,14 +24,22 @@ static bool isInBoundingBox(Vec3i32 p0, Vec3i32 p1, Vec3i32 point) { point[2] <= p1[2]); } +static u32 computeMaxVisibleChunks(Vec3i32 chunk_size, Vec3f32 ellipsoid_semi_axes) { + const auto chunk_size_f32 = Vec3f32::cast(chunk_size); + const auto max_chunks_along_x = static_cast(std::floor((2.F * ellipsoid_semi_axes[0])/chunk_size_f32[0])); + const auto max_chunks_along_y = static_cast(std::floor((2.F * ellipsoid_semi_axes[1])/chunk_size_f32[1])); + const auto max_chunks_along_z = static_cast(std::floor((2.F * ellipsoid_semi_axes[2])/chunk_size_f32[2])); + return max_chunks_along_x * max_chunks_along_y * max_chunks_along_z; +} - -WorldGrid::WorldGrid(EngineContext& engine_context, vmath::Vec3f32 world_size, vmath::Vec3f32 initial_position, std::unique_ptr chunk_generator) : _engine_context(engine_context), - _current_position(initial_position), _semi_axes(world_size), _chunk_pool(engine_context), +WorldGrid::WorldGrid(EngineContext& engine_context, vmath::Vec3f32 world_size, vmath::Vec3f32 initial_position, std::unique_ptr chunk_generator) : + _engine_context(engine_context), + _max_visible_chunks(computeMaxVisibleChunks(_engine_context.chunk_size, world_size)), + _current_position(initial_position), _semi_axes(world_size), _chunk_pool(engine_context, _max_visible_chunks), _grid_size(Vec3i32::add(Vec3i32::mulScalar(Vec3i32::cast(Vec3f32::div(world_size, Vec3f32::cast(engine_context.chunk_size))), 2), 1)), - _chunk_data_streamer(std::move(chunk_generator), 512), - _to_allocate_chunks(512) + _chunk_data_streamer(std::move(chunk_generator), _max_visible_chunks), + _to_allocate_chunks(_max_visible_chunks) { } @@ -47,26 +49,6 @@ constexpr std::array NEIGHBOURS_OFFSETS{{ {0, 0, 1}, { 0, 0,-1}, }}; -// #define DEBUG_WORLD_GRID - -struct Timer { - f64& duration; - - Timer(f64& duration) : - duration(duration), begin_timer(std::chrono::high_resolution_clock::now()) {} - - ~Timer() { - const auto end_timer{std::chrono::high_resolution_clock::now()}; - - const auto begin_ms{std::chrono::time_point_cast(begin_timer).time_since_epoch().count()}; - const auto end_ms{std::chrono::time_point_cast(end_timer).time_since_epoch().count()}; - - duration = static_cast(end_ms - begin_ms)/1000.; - } - - const std::chrono::time_point begin_timer; -}; - void WorldGrid::init() { const auto chunk_size_f32 = Vec3f32::cast(_engine_context.chunk_size); const auto max_chunks_along_x = static_cast(std::floor((2.F * _semi_axes[0])/chunk_size_f32[0])); @@ -77,7 +59,7 @@ void WorldGrid::init() { _tmp_indices.resize(_grid_size[0] * _grid_size[1] * _grid_size[2], VisibleChunk::INVALID_NEIGHBOUR_INDEX); _visible_chunks.reserve(max_chunks); - _chunk_pool.init(max_chunks); + _chunk_pool.init(); _free_visible_chunk_ids.resize(max_chunks); u32 i{ 0U }; for (auto& visible_chunk_id : _free_visible_chunk_ids) { @@ -143,44 +125,44 @@ static u32 oppositeNeighbour(u32 neighbour) { return neighbour - (neighbour & 0x1U) + (~neighbour & 0x1U); } -bool WorldGrid::validate() { - const auto position_in_chunk_space = Vec3i32::cast(vmath::vroundf(Vec3f32::div(_current_position, Vec3f32::cast(_engine_context.chunk_size)))); - const auto half_grid_size = Vec3i32::divScalar(_grid_size, 2);//1; - const auto world_p0_in_chunk_space = Vec3i32::sub(position_in_chunk_space, half_grid_size); - const auto world_p1_in_chunk_space = Vec3i32::add(position_in_chunk_space, half_grid_size/*Vec3i32::sub(half_grid_size, {1})*/); - - for (const auto& visible_chunk : _visible_chunks) { - if (isInBoundingBox(world_p0_in_chunk_space, world_p1_in_chunk_space, visible_chunk.position_in_chunks)) { - u32 nonempty_neighbours{ 0U }; - for (u32 neighbour{ 0U }; neighbour < 6U; ++neighbour) { - if (visible_chunk.neighbours_indices[neighbour] != VisibleChunk::INVALID_NEIGHBOUR_INDEX) { - const auto offset = NEIGHBOURS_OFFSETS[neighbour]; - const auto& visible_chunk_neighbour = _visible_chunks[visible_chunk.neighbours_indices[neighbour]]; - - const auto comp_offset = Vec3i32::sub(visible_chunk_neighbour.position_in_chunks, visible_chunk.position_in_chunks); - ++nonempty_neighbours; - if (comp_offset[0] != offset[0] || - comp_offset[1] != offset[1] || - comp_offset[2] != offset[2]) { +// bool WorldGrid::validate() { +// const auto position_in_chunk_space = Vec3i32::cast(vmath::vroundf(Vec3f32::div(_current_position, Vec3f32::cast(_engine_context.chunk_size)))); +// const auto half_grid_size = Vec3i32::divScalar(_grid_size, 2);//1; +// const auto world_p0_in_chunk_space = Vec3i32::sub(position_in_chunk_space, half_grid_size); +// const auto world_p1_in_chunk_space = Vec3i32::add(position_in_chunk_space, half_grid_size/*Vec3i32::sub(half_grid_size, {1})*/); + +// for (const auto& visible_chunk : _visible_chunks) { +// if (isInBoundingBox(world_p0_in_chunk_space, world_p1_in_chunk_space, visible_chunk.position_in_chunks)) { +// u32 nonempty_neighbours{ 0U }; +// for (u32 neighbour{ 0U }; neighbour < 6U; ++neighbour) { +// if (visible_chunk.neighbours_indices[neighbour] != VisibleChunk::INVALID_NEIGHBOUR_INDEX) { +// const auto offset = NEIGHBOURS_OFFSETS[neighbour]; +// const auto& visible_chunk_neighbour = _visible_chunks[visible_chunk.neighbours_indices[neighbour]]; + +// const auto comp_offset = Vec3i32::sub(visible_chunk_neighbour.position_in_chunks, visible_chunk.position_in_chunks); +// ++nonempty_neighbours; +// if (comp_offset[0] != offset[0] || +// comp_offset[1] != offset[1] || +// comp_offset[2] != offset[2]) { - return false; - } - } - } - if (visible_chunk.neighbours_count != nonempty_neighbours) { - return false; - } - } else { - return false; - } - } - - return true; -} +// return false; +// } +// } +// } +// if (visible_chunk.neighbours_count != nonempty_neighbours) { +// return false; +// } +// } else { +// return false; +// } +// } + +// return true; +// } void WorldGrid::update(Vec3f32 new_position) { - static constexpr f32 epsilon{ .01F }; + static constexpr f32 epsilon{ .1F }; const auto move_vec = Vec3f32::sub(new_position, _current_position); if (std::abs(move_vec[0]) <= epsilon && std::abs(move_vec[1]) <= epsilon && @@ -191,7 +173,7 @@ void WorldGrid::update(Vec3f32 new_position) { _current_position = new_position; const auto position_in_chunk_space = Vec3i32::cast(vmath::vroundf(Vec3f32::div(_current_position, Vec3f32::cast(_engine_context.chunk_size)))); - const auto half_grid_size = Vec3i32::divScalar(_grid_size, 2);//1; + const auto half_grid_size = Vec3i32::divScalar(_grid_size, 2); const auto world_p0_in_chunk_space = Vec3i32::sub(position_in_chunk_space, half_grid_size); const auto world_p1_in_chunk_space = Vec3i32::add(position_in_chunk_space, half_grid_size); diff --git a/src/engine/world_grid.h b/src/engine/world_grid.h index 5878814..ce33f9f 100644 --- a/src/engine/world_grid.h +++ b/src/engine/world_grid.h @@ -7,28 +7,34 @@ #include "chunk_id.h" #include "chunk_pool.h" #include "engine_context.h" -// #include "thread_pool.h" - #include "ringbuffer.h" - -// #include #include "chunk_data_streamer.h" namespace ve001 { +/// @brief world grid is responsible for managing which chunk are visible. It calls +/// chunk data streamer for new chunks of 3d voxel data and allocates them on chunk pool. It also +/// deallocates chunks becoming invisible from chunk pool. struct WorldGrid { + /// @brief id of visible chunk using VisibleChunkId = vmath::u32; static constexpr VisibleChunkId INVALID_VISIBLE_CHUNK_ID{ std::numeric_limits::max() }; static constexpr vmath::u32 INVALID_VISIBLE_CHUNK_INDEX{ std::numeric_limits::max() }; + /// @brief visible chunk metadata structure struct VisibleChunk { static constexpr vmath::u32 INVALID_NEIGHBOUR_INDEX{ std::numeric_limits::max() }; + /// @brief id of a chunk in the context of world grid VisibleChunkId visible_chunk_id; + /// @brief id of a chunk in the context of chunk pool ChunkId chunk_id; + /// @brief position of visible chunks in chunk size units vmath::Vec3i32 position_in_chunks; + /// @brief number of visible chunks's neighbours vmath::u32 neighbours_count{ 0U }; + /// @brief contains indices of neighbours in <_visible_chunks> array std::array neighbours_indices{{ INVALID_NEIGHBOUR_INDEX, INVALID_NEIGHBOUR_INDEX, @@ -38,35 +44,58 @@ struct WorldGrid { INVALID_NEIGHBOUR_INDEX }}; }; + /// @brief handle to chunk which is to be generated and than allocated struct ToAllocateChunk { std::future>> data; VisibleChunkId visible_chunk_id; std::optional> ready_data{ std::nullopt }; }; + /// @brief engine context const EngineContext& _engine_context; - + /// @brief maximum possible number of visible chunks + vmath::u32 _max_visible_chunks; + /// @brief current position vmath::Vec3f32 _current_position; + /// @brief semi axes of the ellipsoid defining visible area vmath::Vec3f32 _semi_axes; + /// @brief grid size, namely how big is the cuboid which + /// contains ellipsoid in chunk size units vmath::Vec3i32 _grid_size; - + /// @brief chunk data streamer ChunkDataStreamer _chunk_data_streamer; + /// @brief queue of chunks to generate and then allocate RingBuffer _to_allocate_chunks; - + /// @brief available visible chunks' ids std::vector _free_visible_chunk_ids; + /// @brief translates visible chunk id to index in visible chunks array std::vector _visible_chunk_id_to_index; + /// @brief array of visible chunks. It is object pooled std::vector _visible_chunks; - + /// @brief temporary indices which is a 3d grid of _grid_size. It holds neighbours indices written + /// in the current update call. It exists as a fast reference to check if the neighbour was + /// already written by some other neighbour. It is cleared at the end of update call. std::vector _tmp_indices; ChunkPool _chunk_pool; - + + /// @brief world grid constructor, it doesn't perform any opengl related initialization + /// @param engine_context engine context + /// @param world_size world size aka semi axes of an ellipsoid + /// @param initial_position initial world grid continuous in space position (eg. camera initial position) + /// @param chunk_generator chunk generator which will be used by <_chunk_data_streamer> WorldGrid(EngineContext& engine_context, vmath::Vec3f32 world_size, vmath::Vec3f32 initial_position, std::unique_ptr chunk_generator); + /// @brief performs later stage initialization eg. perform related initialization void init(); + /// @brief updated the world grid based on the new position (eg. new camera position). + /// Currently it is unsafe to supply position which more than 1 in chunk size units + /// in any of the axes void update(vmath::Vec3f32 new_position); + /// @brief polls for the chunks which aren't yet generated by chunk data streamer and + /// those which are generated but aren't yet allocated on the chunk pool. It is non-blocking + /// @return true - there are yet chunks to be confirmed generated or allocated on the chunk pool bool pollToAllocateChunks(); - - bool validate(); + /// @brief deinitializes all opengl related state (chunk pool) void deinit(); }; diff --git a/src/main.cpp b/src/main.cpp index 98243ed..462ffa1 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -370,7 +370,8 @@ int main() glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); - Engine engine({300.F, 210.F, 300.F}, {0.F, 0.F, 0.F}, EXTENT); + Engine engine({500.F, 200.F, 500.F}, {0.F, 0.F, 0.F}, EXTENT); + // Engine engine({300.F, 210.F, 300.F}, {0.F, 0.F, 0.F}, EXTENT); // Engine engine({100.F, 80.F, 100.F}, {0.F, 0.F, 0.F}, EXTENT); //Engine engine({64.F, 64.F, 64.F}, {0.F, 0.F, 0.F}, EXTENT); engine.init(); diff --git a/ve001_log.1 b/ve001_log.1 index de5ecc1..7991f64 100644 --- a/ve001_log.1 +++ b/ve001_log.1 @@ -1,50 +1,47 @@ -[2023-12-06 16:48:51.442] [logger] [info] Number of triangles was :: 0 -[2023-12-06 16:48:51.442] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 16:48:51.442] [logger] [info] CPU memory usage was :: 83361792B, 81408kB, 79MB -[2023-12-06 16:50:16.565] [logger] [info] Number of triangles was :: 0 -[2023-12-06 16:50:16.565] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 16:50:16.565] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:04:32.153] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:04:32.153] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:04:32.153] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:04:44.189] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:04:44.189] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:04:44.189] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:05:10.983] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:05:10.983] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:05:10.983] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:21:52.033] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:21:52.033] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:21:52.033] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:34:08.404] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:34:08.404] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:34:08.404] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 17:48:45.470] [logger] [info] Number of triangles was :: 0 -[2023-12-06 17:48:45.470] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 17:48:45.470] [logger] [info] CPU memory usage was :: 82313216B, 80384kB, 78MB -[2023-12-06 18:09:17.124] [logger] [info] Number of triangles was :: 34 -[2023-12-06 18:09:17.124] [logger] [info] GPU memory usage was :: 4992B, 4kB, 0MB -[2023-12-06 18:09:17.124] [logger] [info] CPU memory usage was :: 84410368B, 82432kB, 80MB -[2023-12-06 18:12:40.015] [logger] [critical] [GL](1):GL_OUT_OF_MEMORY in glNamedBufferStorage -[2023-12-06 18:12:41.209] [logger] [info] Number of triangles was :: 113160 -[2023-12-06 18:12:41.209] [logger] [info] GPU memory usage was :: 16295136B, 15913kB, 15MB -[2023-12-06 18:12:41.210] [logger] [info] CPU memory usage was :: 20447232B, 19968kB, 19MB -[2023-12-06 18:13:32.276] [logger] [info] Number of triangles was :: 52055 -[2023-12-06 18:13:32.277] [logger] [info] GPU memory usage was :: 7495968B, 7320kB, 7MB -[2023-12-06 18:13:32.277] [logger] [info] CPU memory usage was :: 16252928B, 15872kB, 15MB -[2023-12-06 18:14:02.593] [logger] [info] Number of triangles was :: 0 -[2023-12-06 18:14:02.593] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 18:14:02.593] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB -[2023-12-06 18:20:07.914] [logger] [info] Number of triangles was :: 0 -[2023-12-06 18:20:07.914] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 18:20:07.914] [logger] [info] CPU memory usage was :: 12582912B, 12288kB, 12MB -[2023-12-06 18:22:54.130] [logger] [info] Number of triangles was :: 0 -[2023-12-06 18:22:54.130] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 18:22:54.130] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB -[2023-12-06 18:25:33.978] [logger] [info] Number of triangles was :: 0 -[2023-12-06 18:25:33.978] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 18:25:33.978] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB -[2023-12-06 18:25:44.862] [logger] [info] Number of triangles was :: 0 -[2023-12-06 18:25:44.862] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB -[2023-12-06 18:25:44.862] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB -[2023-12-06 18:26:46.345] [logger] [info] Number of triangles was :: 0 +[2023-12-06 18:26:46.345] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB +[2023-12-06 18:26:46.345] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB +[2023-12-06 18:30:00.177] [logger] [info] Number of triangles was :: 0 +[2023-12-06 18:30:00.177] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB +[2023-12-06 18:30:00.177] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB +[2023-12-06 18:30:25.827] [logger] [info] Number of triangles was :: 0 +[2023-12-06 18:30:25.827] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB +[2023-12-06 18:30:25.827] [logger] [info] CPU memory usage was :: 2621440B, 2560kB, 2MB +[2023-12-06 18:49:32.666] [logger] [info] Number of triangles was :: 39745 +[2023-12-06 18:49:32.666] [logger] [info] GPU memory usage was :: 5723328B, 5589kB, 5MB +[2023-12-06 18:49:32.666] [logger] [info] CPU memory usage was :: 13107200B, 12800kB, 12MB +[2023-12-06 19:00:30.166] [logger] [info] Number of triangles was :: 49140 +[2023-12-06 19:00:30.166] [logger] [info] GPU memory usage was :: 7076160B, 6910kB, 6MB +[2023-12-06 19:00:30.166] [logger] [info] CPU memory usage was :: 7340032B, 7168kB, 7MB +[2023-12-06 19:01:54.399] [logger] [info] Number of triangles was :: 470282 +[2023-12-06 19:01:54.399] [logger] [info] GPU memory usage was :: 67720704B, 66133kB, 64MB +[2023-12-06 19:01:54.399] [logger] [info] CPU memory usage was :: 294125568B, 287232kB, 280MB +[2023-12-06 21:44:33.779] [logger] [info] Number of triangles was :: 738009 +[2023-12-06 21:44:33.779] [logger] [info] GPU memory usage was :: 106273344B, 103782kB, 101MB +[2023-12-06 21:44:33.779] [logger] [info] CPU memory usage was :: 331350016B, 323584kB, 316MB +[2023-12-06 21:45:54.040] [logger] [info] Number of triangles was :: 1100536 +[2023-12-06 21:45:54.040] [logger] [info] GPU memory usage was :: 158477184B, 154762kB, 151MB +[2023-12-06 21:45:54.040] [logger] [info] CPU memory usage was :: 171966464B, 167936kB, 164MB +[2023-12-06 21:47:02.596] [logger] [info] Number of triangles was :: 874264 +[2023-12-06 21:47:02.597] [logger] [info] GPU memory usage was :: 125894112B, 122943kB, 120MB +[2023-12-06 21:47:02.597] [logger] [info] CPU memory usage was :: 317194240B, 309760kB, 302MB +[2023-12-06 21:55:55.165] [logger] [info] Number of triangles was :: 1183341 +[2023-12-06 21:55:55.165] [logger] [info] GPU memory usage was :: 170401152B, 166407kB, 162MB +[2023-12-06 21:55:55.165] [logger] [info] CPU memory usage was :: 426246144B, 416256kB, 406MB +[2023-12-06 21:59:20.464] [logger] [info] Number of triangles was :: 1122180 +[2023-12-06 21:59:20.464] [logger] [info] GPU memory usage was :: 161593920B, 157806kB, 154MB +[2023-12-06 21:59:20.464] [logger] [info] CPU memory usage was :: 249561088B, 243712kB, 238MB +[2023-12-06 21:59:40.875] [logger] [info] Number of triangles was :: 0 +[2023-12-06 21:59:40.875] [logger] [info] GPU memory usage was :: 0B, 0kB, 0MB +[2023-12-06 21:59:40.875] [logger] [info] CPU memory usage was :: 349175808B, 340992kB, 333MB +[2023-12-06 22:19:46.537] [logger] [critical] [GL](1):GL_OUT_OF_MEMORY in glNamedBufferStorage +[2023-12-06 22:19:49.440] [logger] [info] Number of triangles was :: 170197 +[2023-12-06 22:19:49.440] [logger] [info] GPU memory usage was :: 24508416B, 23934kB, 23MB +[2023-12-06 22:19:49.440] [logger] [info] CPU memory usage was :: 450363392B, 439808kB, 429MB +[2023-12-06 22:20:24.158] [logger] [critical] [GL](1):GL_OUT_OF_MEMORY in glNamedBufferStorage +[2023-12-06 22:20:28.124] [logger] [info] Number of triangles was :: 317774 +[2023-12-06 22:20:28.124] [logger] [info] GPU memory usage was :: 45759456B, 44686kB, 43MB +[2023-12-06 22:20:28.124] [logger] [info] CPU memory usage was :: 328728576B, 321024kB, 313MB +[2023-12-06 22:20:50.063] [logger] [critical] [GL](1):GL_OUT_OF_MEMORY in glNamedBufferStorage +[2023-12-06 22:20:52.752] [logger] [info] Number of triangles was :: 204987 +[2023-12-06 22:20:52.752] [logger] [info] GPU memory usage was :: 29518176B, 28826kB, 28MB +[2023-12-06 22:20:52.752] [logger] [info] CPU memory usage was :: 280494080B, 273920kB, 267MB