Walk the shadow passes and the culled model groups on worker threads in the Vulkan renderer

rendering/common/walksync.h

@@ -0,0 +1,113 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+// the walks of the scene made by several threads at once (the stage M2 of claude/vulkan14-renderer-plan.md). only the vulkan renderer
+// opens the window in which they are (gfx.vulkan.parallelpasses); outside of it everything here does nothing, and the opengl renderer
+// never opens it. while it's open:
+// - every thread walking the scene holds the walk lock shared (a pass of a walker from the start to the end, the main thread from the
+//   opening to the closing). what the walks make the first time they need it, and what's shared by them (the geometry of the
+//   sections, the animated tracks, the records of the instances in the cells and in the gpu culling, the sleepers laid, the
+//   resources a lazily loaded model brings: geometry banks, materials, textures) is made with the lock held exclusive (change): the
+//   thread lets go of its shared hold meanwhile and takes it again after. the walks let go of it at the points where they hold
+//   nothing which such a change could move (yield()), so a change waits only a little for them
+// - the shared state of a model (the submodels the instances and the vehicles set up just before they're drawn: animations,
+//   lights, the variants of the seasons) is held by the thread drawing it: a scenery model by a lock of its own (a stripe of
+//   them), the vehicles all at once, as their models may be those of the scenery as well. nothing is changed while it's held
+// - the static fields of TSubModel and the matrix stack of OpenGLMatrices are per thread
+
+#pragma once
+
+#include <cstddef>
+
+class TModel3d;
+
+namespace gfx
+{
+namespace walk_sync
+{
+
+// the window is open
+bool parallel();
+// the main thread opens the window (it holds the walk lock shared from now on), lets go of its hold before it waits for the walkers
+// (leave()) and closes the window once they're done
+void open();
+void leave();
+void close();
+
+// the shared hold of a thread walking a pass (a walker); none outside of the window
+class walk_scope
+{
+  public:
+	walk_scope();
+	~walk_scope();
+	walk_scope(walk_scope const &) = delete;
+	walk_scope &operator=(walk_scope const &) = delete;
+
+  private:
+	bool m_held{false};
+};
+
+// a change of what the walks share: made with the walk lock held exclusive, while the window is open. Wanted: false when nothing
+// is to be changed after all (the change isn't waited for)
+class change
+{
+  public:
+	explicit change(bool Wanted = true);
+	~change();
+	change(change const &) = delete;
+	change &operator=(change const &) = delete;
+
+  private:
+	bool m_exclusive{false};
+	bool m_shared{false}; // the thread held the lock shared before
+};
+
+// lets a change waiting for the walk lock go first; the caller holds nothing it could move
+void yield();
+
+// a thread working for a walk which holds the walk lock and waits for it (the walks of the groups of a culling split among helpers,
+// the stage M3): it's covered by the hold of that walk, takes no hold of its own and makes no changes
+class borrowed_scope
+{
+  public:
+	borrowed_scope();
+	~borrowed_scope();
+	borrowed_scope(borrowed_scope const &) = delete;
+	borrowed_scope &operator=(borrowed_scope const &) = delete;
+};
+
+// the shared state of a scenery model held by the thread, while the window is open
+class model_hold
+{
+  public:
+	explicit model_hold(TModel3d const *Model);
+	~model_hold();
+	model_hold(model_hold const &) = delete;
+	model_hold &operator=(model_hold const &) = delete;
+
+  private:
+	std::size_t m_stripe{0};
+	bool m_held{false};
+};
+
+// the shared state of the vehicles held by the thread (all of them, with the scenery models)
+class vehicle_hold
+{
+  public:
+	vehicle_hold();
+	~vehicle_hold();
+	vehicle_hold(vehicle_hold const &) = delete;
+	vehicle_hold &operator=(vehicle_hold const &) = delete;
+
+  private:
+	bool m_held{false};
+};
+
+} // namespace walk_sync
+} // namespace gfx