Change timing-related debug messages from SPDLOG_INFO to SPDLOG_DEBUG, set the default log level to INFO

Signed-off-by: ZhouFANG <indevn@outlook.com>

Author: indevn

src/include/log_system.h

@@ -17,6 +17,9 @@
 #ifndef SIMPLERENDER_SRC_INCLUDE_LOG_SYSTEM_H_
 #define SIMPLERENDER_SRC_INCLUDE_LOG_SYSTEM_H_
 
+#ifndef SPDLOG_ACTIVE_LEVEL
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#endif
 #include <spdlog/spdlog.h>
 
 namespace simple_renderer {

src/light.cpp

@@ -27,7 +27,7 @@ const Vector3f Light::kDefaultDir = Vector3f(0, 0, -1);
 const Color Light::kDefaultColor = Color::kWhite;
 
 Light::Light(const std::string &name) : name_(name) {
-  SPDLOG_INFO("Light: {}", name_);
+  SPDLOG_DEBUG("Light: {}", name_);
 }
 
 }  // namespace simple_renderer

src/rasterizer.cpp

@@ -8,7 +8,7 @@ namespace simple_renderer {
 
 Rasterizer::Rasterizer(size_t width, size_t height)
     : width_(width), height_(height) {
-  SPDLOG_INFO("Rasterizer init with {}, {}", width, height);
+  SPDLOG_DEBUG("Rasterizer init with {}, {}", width, height);
 }
 
 std::vector<Fragment> Rasterizer::Rasterize(const Vertex& v0, const Vertex& v1,

src/renderer.cpp

@@ -30,7 +30,7 @@ SimpleRenderer::SimpleRenderer(size_t width, size_t height)
 
 bool SimpleRenderer::DrawModel(const Model &model, const Shader &shader, uint32_t *buffer) {
   EnsureRenderer(); // 确保渲染器实例存在
-  SPDLOG_INFO("draw model: {}", model.GetModelPath());
+  SPDLOG_DEBUG("draw model: {}", model.GetModelPath());
   return renderer_->Render(model, shader, buffer);
 }
 

src/renderers/deferred_renderer.cpp

@@ -159,16 +159,16 @@ bool DeferredRenderer::Render(const Model& model, const Shader& shader_in, uint3
   auto total_end_time = std::chrono::high_resolution_clock::now();
   double total_ms = std::chrono::duration_cast<std::chrono::microseconds>(total_end_time - total_start_time).count() / 1000.0;
 
-  SPDLOG_INFO("=== DEFERRED RENDERING PERFORMANCE ===");
+  SPDLOG_DEBUG("=== DEFERRED RENDERING PERFORMANCE ===");
   double sum_ms = vertex_ms + (total_ms - vertex_ms);
-  SPDLOG_INFO("Vertex Shader:        {:8.3f} ms ({:5.1f}%)", vertex_ms, vertex_ms/sum_ms*100);
-  SPDLOG_INFO("Buffer Alloc:         {:8.3f} ms", buffer_alloc_ms);
-  SPDLOG_INFO("Rasterization:        {:8.3f} ms", raster_ms);
-  SPDLOG_INFO("Fragment Collection:  {:8.3f} ms", collect_ms);
-  SPDLOG_INFO("Fragment Merge:       {:8.3f} ms", merge_ms);
-  SPDLOG_INFO("Deferred Shading:     {:8.3f} ms", shade_ms);
-  SPDLOG_INFO("Total:                {:8.3f} ms", vertex_ms + (buffer_alloc_ms + raster_ms + collect_ms + merge_ms + shade_ms));
-  SPDLOG_INFO("=========================================");
+  SPDLOG_DEBUG("Vertex Shader:        {:8.3f} ms ({:5.1f}%)", vertex_ms, vertex_ms/sum_ms*100);
+  SPDLOG_DEBUG("Buffer Alloc:         {:8.3f} ms", buffer_alloc_ms);
+  SPDLOG_DEBUG("Rasterization:        {:8.3f} ms", raster_ms);
+  SPDLOG_DEBUG("Fragment Collection:  {:8.3f} ms", collect_ms);
+  SPDLOG_DEBUG("Fragment Merge:       {:8.3f} ms", merge_ms);
+  SPDLOG_DEBUG("Deferred Shading:     {:8.3f} ms", shade_ms);
+  SPDLOG_DEBUG("Total:                {:8.3f} ms", vertex_ms + (buffer_alloc_ms + raster_ms + collect_ms + merge_ms + shade_ms));
+  SPDLOG_DEBUG("=========================================");
 
   return true;
 }

src/renderers/per_triangle_renderer.cpp

@@ -155,16 +155,16 @@ bool PerTriangleRenderer::Render(const Model &model, const Shader &shader_in,
                       .count() /
                   1000.0;
 
-  SPDLOG_INFO("=== PER-TRIANGLE RENDERING PERFORMANCE ===");
+  SPDLOG_DEBUG("=== PER-TRIANGLE RENDERING PERFORMANCE ===");
   double sum_ms = vertex_ms + (total_ms - vertex_ms);
-  SPDLOG_INFO("Vertex Shader:    {:8.3f} ms ({:5.1f}%)", vertex_ms,
+  SPDLOG_DEBUG("Vertex Shader:    {:8.3f} ms ({:5.1f}%)", vertex_ms,
               vertex_ms / sum_ms * 100);
-  SPDLOG_INFO("Buffer Alloc:     {:8.3f} ms", buffer_alloc_ms);
-  SPDLOG_INFO("Rasterization:    {:8.3f} ms", raster_ms);
-  SPDLOG_INFO("Merge:            {:8.3f} ms", merge_ms);
-  SPDLOG_INFO("Total:            {:8.3f} ms",
+  SPDLOG_DEBUG("Buffer Alloc:     {:8.3f} ms", buffer_alloc_ms);
+  SPDLOG_DEBUG("Rasterization:    {:8.3f} ms", raster_ms);
+  SPDLOG_DEBUG("Merge:            {:8.3f} ms", merge_ms);
+  SPDLOG_DEBUG("Total:            {:8.3f} ms",
               vertex_ms + (buffer_alloc_ms + raster_ms + merge_ms));
-  SPDLOG_INFO("==========================================");
+  SPDLOG_DEBUG("==========================================");
 
   return true;
 }

src/renderers/tile_based_renderer.cpp

@@ -132,19 +132,19 @@ bool TileBasedRenderer::Render(const Model &model, const Shader &shader_in,
                         .count() /
                     1000.0;
 
-  SPDLOG_INFO("=== TILE-BASED RENDERING PERFORMANCE ===");
+  SPDLOG_DEBUG("=== TILE-BASED RENDERING PERFORMANCE ===");
   double sum_ms = vertex_ms + (total_ms - vertex_ms);
-  SPDLOG_INFO("Vertex Shader:    {:8.3f} ms ({:5.1f}%)", vertex_ms,
+  SPDLOG_DEBUG("Vertex Shader:    {:8.3f} ms ({:5.1f}%)", vertex_ms,
               vertex_ms / sum_ms * 100);
-  SPDLOG_INFO("Setup:            {:8.3f} ms", setup_ms);
-  SPDLOG_INFO("Binning:          {:8.3f} ms", binning_ms);
-  SPDLOG_INFO("Buffer Alloc:     {:8.3f} ms", buffer_alloc_ms);
-  SPDLOG_INFO("Rasterization:    {:8.3f} ms", raster_ms);
-  SPDLOG_INFO("Copy:             {:8.3f} ms", present_ms);
-  SPDLOG_INFO("Total:            {:8.3f} ms",
+  SPDLOG_DEBUG("Setup:            {:8.3f} ms", setup_ms);
+  SPDLOG_DEBUG("Binning:          {:8.3f} ms", binning_ms);
+  SPDLOG_DEBUG("Buffer Alloc:     {:8.3f} ms", buffer_alloc_ms);
+  SPDLOG_DEBUG("Rasterization:    {:8.3f} ms", raster_ms);
+  SPDLOG_DEBUG("Copy:             {:8.3f} ms", present_ms);
+  SPDLOG_DEBUG("Total:            {:8.3f} ms",
               vertex_ms + (setup_ms + binning_ms + buffer_alloc_ms + raster_ms +
-                           present_ms));
-  SPDLOG_INFO("==========================================");
+                          present_ms));
+  SPDLOG_DEBUG("==========================================");
 
   return true;
 }
@@ -155,9 +155,9 @@ void TileBasedRenderer::TriangleTileBinning(
     std::vector<std::vector<TileTriangleRef>> &tile_triangles) {
   const size_t total_triangles = model.GetFaces().size();
 
-  SPDLOG_INFO("Starting triangle-tile binning (SoA) for {} triangles",
+  SPDLOG_DEBUG("Starting triangle-tile binning (SoA) for {} triangles",
               total_triangles);
-  SPDLOG_INFO("Screen dimensions: {}x{}, Tile size: {}, Tiles: {}x{}", width_,
+  SPDLOG_DEBUG("Screen dimensions: {}x{}, Tile size: {}, Tiles: {}x{}", width_,
               height_, grid.tile_size, grid.tiles_x, grid.tiles_y);
 
   std::vector<size_t> tile_counts(grid.tiles_x * grid.tiles_y, 0);
@@ -186,9 +186,9 @@ void TileBasedRenderer::TriangleTileBinning(
     total_triangle_refs += tile.size();
     if (!tile.empty()) non_empty_tiles++;
   }
-  SPDLOG_INFO("  (SoA) Total triangle references: {}", total_triangle_refs);
-  SPDLOG_INFO("  (SoA) Non-empty tiles: {}", non_empty_tiles);
-  SPDLOG_INFO("  (SoA) Average triangles per tile: {:.2f}",
+  SPDLOG_DEBUG("  (SoA) Total triangle references: {}", total_triangle_refs);
+  SPDLOG_DEBUG("  (SoA) Non-empty tiles: {}", non_empty_tiles);
+  SPDLOG_DEBUG("  (SoA) Average triangles per tile: {:.2f}",
               total_triangle_refs > 0
                   ? float(total_triangle_refs) / tile_triangles.size()
                   : 0.0f);