Redrawing Static Scenes in SDL

Yes, in most typical SDL application structures, you should still redraw everything in the main loop, even if the scene appears static.

While it seems counterintuitive and potentially wasteful at first glance, this approach is standard practice for several good reasons:

Simplicity and Consistency

The "clear, draw everything, present" model is straightforward to implement and maintain. Your rendering code doesn't need complex logic to track what might have changed or which parts of the screen need updating.

You simply render the desired state of the entire scene every frame. This makes the codebase much cleaner and less prone to visual bugs that can arise from incomplete or incorrect partial updates.

Event Handling and Window Management

Even if your game scene is static, the application window itself might need redrawing. Consider these scenarios:

• The window is minimized and then restored.
• Another window overlaps yours and then moves away.
• The window is resized.

In these cases, the operating system often requires the application to redraw its content. Having a consistent rendering loop ensures that your window correctly redraws its full content whenever needed, triggered by events or system requests, not just by changes in your game state. If you only drew once, the window might appear blank or corrupted after such events.

Leveraging Hardware/System Optimizations

Modern operating systems and graphics drivers are highly optimized for handling full window updates. While redrawing might seem like extra work for the CPU/GPU, the overhead of constantly checking if something needs redrawing and managing partial updates ("dirty rectangling") can sometimes be comparable to, or even greater than, just redrawing the whole scene, especially for simple scenes. The consistent full redraw allows the underlying system to potentially use its own optimizations more effectively.

Preparing for Future Changes

Even if your scene is static now, building your application with a standard rendering loop makes it much easier to add animation or dynamic elements later. The core structure is already in place.

When Might You Avoid Constant Redrawing?

There are specific scenarios, often in GUI toolkits or document editors rather than typical games, where applications do track changes and only redraw affected regions. This can save power on battery-operated devices or reduce CPU usage for complex static displays. However, implementing this correctly adds significant complexity.

Conclusion

For most SDL applications, especially those resembling games or real-time graphics displays, sticking to the standard loop of clearing, drawing all elements, and presenting the frame is the recommended approach, even for visually static scenes. It simplifies development, ensures correctness in various windowing scenarios, and aligns with how graphics systems are often optimized.