ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / render / session.h
index 404b7b7..60d8f7a 100644 (file)
@@ -42,91 +42,83 @@ class Scene;
 /* Session Parameters */
 
 class SessionParams {
-public:
-       DeviceInfo device;
-       bool background;
-       bool progressive_refine;
-
-       bool progressive;
-       bool experimental;
-       int samples;
-       int2 tile_size;
-       TileOrder tile_order;
-       int start_resolution;
-       int pixel_size;
-       int threads;
-
-       bool use_profiling;
-
-       bool display_buffer_linear;
-
-       bool run_denoising;
-       bool write_denoising_passes;
-       bool full_denoising;
-       DenoiseParams denoising;
-
-       double cancel_timeout;
-       double reset_timeout;
-       double text_timeout;
-       double progressive_update_timeout;
-
-       ShadingSystem shadingsystem;
-
-       function<bool(const uchar *pixels,
-                     int width,
-                     int height,
-                     int channels)> write_render_cb;
-
-       SessionParams()
-       {
-               background = false;
-               progressive_refine = false;
-
-               progressive = false;
-               experimental = false;
-               samples = 1024;
-               tile_size = make_int2(64, 64);
-               start_resolution = INT_MAX;
-               pixel_size = 1;
-               threads = 0;
-
-               use_profiling = false;
-
-               run_denoising = false;
-               write_denoising_passes = false;
-               full_denoising = false;
-
-               display_buffer_linear = false;
-
-               cancel_timeout = 0.1;
-               reset_timeout = 0.1;
-               text_timeout = 1.0;
-               progressive_update_timeout = 1.0;
-
-               shadingsystem = SHADINGSYSTEM_SVM;
-               tile_order = TILE_CENTER;
-       }
-
-       bool modified(const SessionParams& params)
-       { return !(device == params.device
-               && background == params.background
-               && progressive_refine == params.progressive_refine
-               /* && samples == params.samples */
-               && progressive == params.progressive
-               && experimental == params.experimental
-               && tile_size == params.tile_size
-               && start_resolution == params.start_resolution
-               && pixel_size == params.pixel_size
-               && threads == params.threads
-               && use_profiling == params.use_profiling
-               && display_buffer_linear == params.display_buffer_linear
-               && cancel_timeout == params.cancel_timeout
-               && reset_timeout == params.reset_timeout
-               && text_timeout == params.text_timeout
-               && progressive_update_timeout == params.progressive_update_timeout
-               && tile_order == params.tile_order
-               && shadingsystem == params.shadingsystem); }
-
+ public:
+  DeviceInfo device;
+  bool background;
+  bool progressive_refine;
+
+  bool progressive;
+  bool experimental;
+  int samples;
+  int2 tile_size;
+  TileOrder tile_order;
+  int start_resolution;
+  int pixel_size;
+  int threads;
+
+  bool use_profiling;
+
+  bool display_buffer_linear;
+
+  bool run_denoising;
+  bool write_denoising_passes;
+  bool full_denoising;
+  DenoiseParams denoising;
+
+  double cancel_timeout;
+  double reset_timeout;
+  double text_timeout;
+  double progressive_update_timeout;
+
+  ShadingSystem shadingsystem;
+
+  function<bool(const uchar *pixels, int width, int height, int channels)> write_render_cb;
+
+  SessionParams()
+  {
+    background = false;
+    progressive_refine = false;
+
+    progressive = false;
+    experimental = false;
+    samples = 1024;
+    tile_size = make_int2(64, 64);
+    start_resolution = INT_MAX;
+    pixel_size = 1;
+    threads = 0;
+
+    use_profiling = false;
+
+    run_denoising = false;
+    write_denoising_passes = false;
+    full_denoising = false;
+
+    display_buffer_linear = false;
+
+    cancel_timeout = 0.1;
+    reset_timeout = 0.1;
+    text_timeout = 1.0;
+    progressive_update_timeout = 1.0;
+
+    shadingsystem = SHADINGSYSTEM_SVM;
+    tile_order = TILE_CENTER;
+  }
+
+  bool modified(const SessionParams &params)
+  {
+    return !(device == params.device && background == params.background &&
+             progressive_refine == params.progressive_refine
+             /* && samples == params.samples */
+             && progressive == params.progressive && experimental == params.experimental &&
+             tile_size == params.tile_size && start_resolution == params.start_resolution &&
+             pixel_size == params.pixel_size && threads == params.threads &&
+             use_profiling == params.use_profiling &&
+             display_buffer_linear == params.display_buffer_linear &&
+             cancel_timeout == params.cancel_timeout && reset_timeout == params.reset_timeout &&
+             text_timeout == params.text_timeout &&
+             progressive_update_timeout == params.progressive_update_timeout &&
+             tile_order == params.tile_order && shadingsystem == params.shadingsystem);
+  }
 };
 
 /* Session
@@ -135,111 +127,111 @@ public:
  * control loop and dispatching tasks. */
 
 class Session {
-public:
-       Device *device;
-       Scene *scene;
-       RenderBuffers *buffers;
-       DisplayBuffer *display;
-       Progress progress;
-       SessionParams params;
-       TileManager tile_manager;
-       Stats stats;
-       Profiler profiler;
+ public:
+  Device *device;
+  Scene *scene;
+  RenderBuffers *buffers;
+  DisplayBuffer *display;
+  Progress progress;
+  SessionParams params;
+  TileManager tile_manager;
+  Stats stats;
+  Profiler profiler;
 
-       function<void(RenderTile&)> write_render_tile_cb;
-       function<void(RenderTile&, bool)> update_render_tile_cb;
+  function<void(RenderTile &)> write_render_tile_cb;
+  function<void(RenderTile &, bool)> update_render_tile_cb;
 
-       explicit Session(const SessionParams& params);
-       ~Session();
+  explicit Session(const SessionParams &params);
+  ~Session();
 
-       void start();
-       bool draw(BufferParams& params, DeviceDrawParams& draw_params);
-       void wait();
+  void start();
+  bool draw(BufferParams &params, DeviceDrawParams &draw_params);
+  void wait();
 
-       bool ready_to_reset();
-       void reset(BufferParams& params, int samples);
-       void set_samples(int samples);
-       void set_pause(bool pause);
+  bool ready_to_reset();
+  void reset(BufferParams &params, int samples);
+  void set_samples(int samples);
+  void set_pause(bool pause);
 
-       bool update_scene();
-       bool load_kernels(bool lock_scene=true);
+  bool update_scene();
+  bool load_kernels(bool lock_scene = true);
 
-       void device_free();
+  void device_free();
 
-       /* Returns the rendering progress or 0 if no progress can be determined
-        * (for example, when rendering with unlimited samples). */
-       float get_progress();
+  /* Returns the rendering progress or 0 if no progress can be determined
+   * (for example, when rendering with unlimited samples). */
+  float get_progress();
 
-       void collect_statistics(RenderStats *stats);
+  void collect_statistics(RenderStats *stats);
 
-protected:
-       struct DelayedReset {
-               thread_mutex mutex;
-               bool do_reset;
-               BufferParams params;
-               int samples;
-       } delayed_reset;
+ protected:
+  struct DelayedReset {
+    thread_mutex mutex;
+    bool do_reset;
+    BufferParams params;
+    int samples;
+  } delayed_reset;
 
-       void run();
+  void run();
 
-       void update_status_time(bool show_pause = false, bool show_done = false);
+  void update_status_time(bool show_pause = false, bool show_done = false);
 
-       void tonemap(int sample);
-       void render();
-       void reset_(BufferParams& params, int samples);
+  void tonemap(int sample);
+  void render();
+  void reset_(BufferParams &params, int samples);
 
-       void run_cpu();
-       bool draw_cpu(BufferParams& params, DeviceDrawParams& draw_params);
-       void reset_cpu(BufferParams& params, int samples);
+  void run_cpu();
+  bool draw_cpu(BufferParams &params, DeviceDrawParams &draw_params);
+  void reset_cpu(BufferParams &params, int samples);
 
-       void run_gpu();
-       bool draw_gpu(BufferParams& params, DeviceDrawParams& draw_params);
-       void reset_gpu(BufferParams& params, int samples);
+  void run_gpu();
+  bool draw_gpu(BufferParams &params, DeviceDrawParams &draw_params);
+  void reset_gpu(BufferParams &params, int samples);
 
-       bool acquire_tile(Device *tile_device, RenderTile& tile);
-       void update_tile_sample(RenderTile& tile);
-       void release_tile(RenderTile& tile);
+  bool acquire_tile(Device *tile_device, RenderTile &tile);
+  void update_tile_sample(RenderTile &tile);
+  void release_tile(RenderTile &tile);
 
-       void map_neighbor_tiles(RenderTile *tiles, Device *tile_device);
-       void unmap_neighbor_tiles(RenderTile *tiles, Device *tile_device);
+  void map_neighbor_tiles(RenderTile *tiles, Device *tile_device);
+  void unmap_neighbor_tiles(RenderTile *tiles, Device *tile_device);
 
-       bool device_use_gl;
+  bool device_use_gl;
 
-       thread *session_thread;
+  thread *session_thread;
 
-       volatile bool display_outdated;
+  volatile bool display_outdated;
 
-       volatile bool gpu_draw_ready;
-       volatile bool gpu_need_tonemap;
-       thread_condition_variable gpu_need_tonemap_cond;
+  volatile bool gpu_draw_ready;
+  volatile bool gpu_need_tonemap;
+  thread_condition_variable gpu_need_tonemap_cond;
 
-       bool pause;
-       thread_condition_variable pause_cond;
-       thread_mutex pause_mutex;
-       thread_mutex tile_mutex;
-       thread_mutex buffers_mutex;
-       thread_mutex display_mutex;
+  bool pause;
+  thread_condition_variable pause_cond;
+  thread_mutex pause_mutex;
+  thread_mutex tile_mutex;
+  thread_mutex buffers_mutex;
+  thread_mutex display_mutex;
 
-       bool kernels_loaded;
-       DeviceRequestedFeatures loaded_kernel_features;
+  bool kernels_loaded;
+  DeviceRequestedFeatures loaded_kernel_features;
 
-       double reset_time;
+  double reset_time;
 
-       /* progressive refine */
-       double last_update_time;
-       bool update_progressive_refine(bool cancel);
+  /* progressive refine */
+  double last_update_time;
+  bool update_progressive_refine(bool cancel);
 
-       DeviceRequestedFeatures get_requested_device_features();
+  DeviceRequestedFeatures get_requested_device_features();
 
-       /* ** Split kernel routines ** */
+  /* ** Split kernel routines ** */
 
-       /* Maximumnumber of closure during session lifetime. */
-       int max_closure_global;
+  /* Maximumnumber of closure during session lifetime. */
+  int max_closure_global;
 
-       /* Get maximum number of closures to be used in kernel. */
-       int get_max_closure_count();
+  /* Get maximum number of closures to be used in kernel. */
+  int get_max_closure_count();
 };
 
 CCL_NAMESPACE_END
 
-#endif  /* __SESSION_H__ */
+#endif /* __SESSION_H__ */