finish dynamic resolution

malytomas · malytomas · commit 69781d056d3a · 2024-11-10T16:27:51.000+01:00
diff --git a/sources/include/cage-engine/provisionalGraphics.h b/sources/include/cage-engine/provisionalGraphics.h
@@ -15,35 +15,32 @@ namespace cage
 	{
 	public:
 		Holder<UniformBuffer> resolve(); // requires opengl context
-		bool ready() const;
 	};
 
 	class CAGE_ENGINE_API ProvisionalFrameBuffer : private Immovable
 	{
 	public:
 		Holder<FrameBuffer> resolve(); // requires opengl context
-		bool ready() const;
 	};
 
 	class CAGE_ENGINE_API ProvisionalTexture : private Immovable
 	{
 	public:
 		Holder<Texture> resolve(); // requires opengl context
-		bool ready() const;
 	};
 
 	class CAGE_ENGINE_API ProvisionalGraphics : private Immovable
 	{
 	public:
 		// section: thread-safe, does not require opengl context
 
-		Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name);
+		Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name, std::function<void(UniformBuffer *)> &&init = {});
 
 		Holder<ProvisionalFrameBuffer> frameBufferDraw(const String &name);
 		Holder<ProvisionalFrameBuffer> frameBufferRead(const String &name);
 
-		Holder<ProvisionalTexture> texture(const String &name, std::function<void(Texture *)> &&init);
-		Holder<ProvisionalTexture> texture(const String &name, uint32 target, std::function<void(Texture *)> &&init);
+		Holder<ProvisionalTexture> texture(const String &name, std::function<void(Texture *)> &&init = {});
+		Holder<ProvisionalTexture> texture(const String &name, uint32 target, std::function<void(Texture *)> &&init = {});
 
 		// section: thread-safe, requires opengl context
 
diff --git a/sources/include/cage-simple/engine.h b/sources/include/cage-simple/engine.h
@@ -86,7 +86,7 @@ namespace cage
 	VoicesMixer *engineMasterMixer();
 	VoicesMixer *engineEffectsMixer();
 	VoicesMixer *engineGuiMixer();
-	ProvisionalGraphics *engineProvisonalGraphics();
+	ProvisionalGraphics *engineProvisionalGraphics();
 	uint64 engineControlTime();
 
 	struct EngineDynamicResolution
diff --git a/sources/libengine/graphics/provisionalGraphics.cpp b/sources/libengine/graphics/provisionalGraphics.cpp
@@ -18,8 +18,10 @@ namespace cage
 		{
 		public:
 			const String name;
+			std::function<void(UniformBuffer *)> init;
 			Holder<UniformBuffer> result;
 			ProvisionalGraphicsImpl *impl = nullptr;
+			uint32 type = m; // 1 = init copied
 			bool used = true;
 
 			ProvisionalUniformBufferImpl(const String &name) : name(name) {}
@@ -64,25 +66,21 @@ namespace cage
 					{
 						Holder<T> v = systemMemory().createHolder<T>(name);
 						data.insert(v.share());
-						return std::move(v);
+						return v;
 					}
 					return it->share();
 				}
 
 				void reset()
 				{
 					ScopeLock lock(mutex);
-					auto it = data.begin();
-					while (it != data.end())
-					{
-						if ((*it)->used)
+					std::erase_if(data,
+						[](auto &it)
 						{
-							(*it)->used = false;
-							it++;
-						}
-						else
-							it = data.erase(it);
-					}
+							const bool res = it->used;
+							it->used = false;
+							return !res;
+						});
 				}
 
 				void purge()
@@ -119,9 +117,14 @@ namespace cage
 			Container<ProvisionalFrameBufferHandleImpl> frameBuffers;
 			Container<ProvisionalTextureHandleImpl> textures;
 
-			Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name)
+			Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name, std::function<void(UniformBuffer *)> &&init)
 			{
 				auto ub = uniformBuffers.acquire(name);
+				if (ub->type == m)
+				{
+					ub->type = 1;
+					ub->init = std::move(init);
+				}
 				return std::move(ub).cast<ProvisionalUniformBuffer>();
 			}
 
@@ -169,16 +172,12 @@ namespace cage
 		{
 			impl->result = newUniformBuffer();
 			impl->result->setDebugName(impl->name);
+			if (impl->init)
+				impl->init(+impl->result);
 		}
 		return impl->result.share();
 	}
 
-	bool ProvisionalUniformBuffer::ready() const
-	{
-		const ProvisionalUniformBufferImpl *impl = (const ProvisionalUniformBufferImpl *)this;
-		return !!impl->result;
-	}
-
 	Holder<FrameBuffer> ProvisionalFrameBuffer::resolve()
 	{
 		ProvisionalFrameBufferHandleImpl *impl = (ProvisionalFrameBufferHandleImpl *)this;
@@ -199,12 +198,6 @@ namespace cage
 		return impl->result.share();
 	}
 
-	bool ProvisionalFrameBuffer::ready() const
-	{
-		const ProvisionalFrameBufferHandleImpl *impl = (const ProvisionalFrameBufferHandleImpl *)this;
-		return !!impl->result;
-	}
-
 	Holder<Texture> ProvisionalTexture::resolve()
 	{
 		ProvisionalTextureHandleImpl *impl = (ProvisionalTextureHandleImpl *)this;
@@ -213,21 +206,16 @@ namespace cage
 		{
 			impl->result = newTexture(impl->target);
 			impl->result->setDebugName(impl->name);
-			impl->init(+impl->result);
+			if (impl->init)
+				impl->init(+impl->result);
 		}
 		return impl->result.share();
 	}
 
-	bool ProvisionalTexture::ready() const
-	{
-		const ProvisionalTextureHandleImpl *impl = (const ProvisionalTextureHandleImpl *)this;
-		return !!impl->result;
-	}
-
-	Holder<ProvisionalUniformBuffer> ProvisionalGraphics::uniformBuffer(const String &name)
+	Holder<ProvisionalUniformBuffer> ProvisionalGraphics::uniformBuffer(const String &name, std::function<void(UniformBuffer *)> &&init)
 	{
 		ProvisionalGraphicsImpl *impl = (ProvisionalGraphicsImpl *)this;
-		return impl->uniformBuffer(name);
+		return impl->uniformBuffer(name, std::move(init));
 	}
 
 	Holder<ProvisionalFrameBuffer> ProvisionalGraphics::frameBufferDraw(const String &name)
diff --git a/sources/libengine/graphics/renderPipeline.cpp b/sources/libengine/graphics/renderPipeline.cpp
@@ -957,7 +957,7 @@ namespace cage
 				TextureHandle colorTexture = provisionalGraphics->texture(Stringizer() + "colorTarget_" + data.name + "_" + data.resolution,
 					[resolution = data.resolution](Texture *t)
 					{
-						t->initialize(resolution, 1, GL_RGBA16F);
+						t->initialize(resolution, 1, GL_RGBA16F); // RGB16F (without alpha) is not required to work in frame buffer
 						t->filters(GL_LINEAR, GL_LINEAR, 0);
 						t->wraps(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
 					});
@@ -1047,17 +1047,13 @@ namespace cage
 					const auto graphicsDebugScope = renderQueue->namedScope("effects");
 
 					TextureHandle texSource = colorTexture;
-					TextureHandle texTarget = [&]()
-					{
-						TextureHandle t = provisionalGraphics->texture(Stringizer() + "intermediateTarget_" + data.resolution,
-							[resolution = data.resolution](Texture *t)
-							{
-								t->initialize(resolution, 1, GL_RGBA16F);
-								t->filters(GL_LINEAR, GL_LINEAR, 0);
-								t->wraps(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
-							});
-						return t;
-					}();
+					TextureHandle texTarget = provisionalGraphics->texture(Stringizer() + "intermediateTarget_" + data.resolution,
+						[resolution = data.resolution](Texture *t)
+						{
+							t->initialize(resolution, 1, GL_RGBA16F); // RGB16F (without alpha) is not required to work in frame buffer
+							t->filters(GL_LINEAR, GL_LINEAR, 0);
+							t->wraps(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+						});
 
 					// depth of field
 					if (any(data.effects.effects & ScreenSpaceEffectsFlags::DepthOfField))
@@ -1073,6 +1069,10 @@ namespace cage
 						std::swap(texSource, texTarget);
 					}
 
+					renderQueue->resetFrameBuffer();
+					renderQueue->resetAllState();
+					renderQueue->resetAllTextures();
+
 					// eye adaptation
 					if (any(data.effects.effects & ScreenSpaceEffectsFlags::EyeAdaptation))
 					{
@@ -1138,11 +1138,13 @@ namespace cage
 					// blit to destination
 					if (texSource != colorTexture)
 					{
+						const auto graphicsDebugScope = renderQueue->namedScope("effects blit");
 						renderQueue->viewport(Vec2i(), data.resolution);
 						renderQueue->bind(texSource, 0);
 						renderQueue->bind(shaderBlitPixels);
 						renderQueue->bind(renderTarget);
 						renderQueue->colorTexture(renderTarget, 0, colorTexture);
+						renderQueue->depthTexture(renderTarget, {});
 						renderQueue->activeAttachments(renderTarget, 1);
 						renderQueue->checkFrameBuffer(renderTarget);
 						renderQueue->draw(modelSquare);
@@ -1155,6 +1157,7 @@ namespace cage
 					const auto graphicsDebugScope = renderQueue->namedScope("final blit");
 					renderQueue->resetAllState();
 					renderQueue->viewport(Vec2i(), data.resolution);
+					renderQueue->bind(data.target, 0); // ensure the texture is properly initialized
 					renderQueue->bind(colorTexture, 0);
 					renderQueue->bind(shaderBlitPixels);
 					renderQueue->bind(renderTarget);
diff --git a/sources/libengine/graphics/screenSpaceEffects.cpp b/sources/libengine/graphics/screenSpaceEffects.cpp
@@ -8,6 +8,7 @@
 #include <cage-engine/screenSpaceEffects.h>
 #include <cage-engine/shaderProgram.h>
 #include <cage-engine/texture.h>
+#include <cage-engine/uniformBuffer.h>
 
 namespace cage
 {
@@ -82,13 +83,7 @@ namespace cage
 		FrameBufferHandle fb = config.provisionals->frameBufferDraw("graphicsEffects");
 		q->bind(fb);
 
-		UniformBufferHandle ssaoPoints = config.provisionals->uniformBuffer("ssaoPoints");
-		{ // potentially dangerous hack
-			ProvisionalUniformBuffer *pub = (ProvisionalUniformBuffer *)ssaoPoints.pointer();
-			CAGE_ASSERT(pub);
-			if (!pub->ready())
-				q->writeWhole(ssaoPoints, privat::pointsForSsaoShader(), GL_STATIC_DRAW);
-		}
+		UniformBufferHandle ssaoPoints = config.provisionals->uniformBuffer("ssaoPoints", [](UniformBuffer *ub) { ub->writeWhole(privat::pointsForSsaoShader(), GL_STATIC_DRAW); });
 		q->bind(ssaoPoints, 3);
 
 		struct Shader
@@ -229,7 +224,7 @@ namespace cage
 		q->bindImage(config.inColor, 0, true, false);
 		TextureHandle texHist = provTex(config.provisionals, Stringizer() + "luminanceHistogram", Vec2i(256, 1), 1, GL_R32UI);
 		q->bindImage(texHist, 1, true, true);
-		TextureHandle texAccum = provTex(config.provisionals, Stringizer() + "luminanceAccumulation" + config.cameraId, Vec2i(1), 1, GL_R32F);
+		TextureHandle texAccum = provTex(config.provisionals, Stringizer() + "luminanceAccumulation_" + config.cameraId, Vec2i(1), 1, GL_R32F);
 		q->bindImage(texAccum, 2, true, true);
 
 		// collection
@@ -312,7 +307,7 @@ namespace cage
 		q->colorTexture(fb, 0, config.outColor);
 		q->checkFrameBuffer(fb);
 		q->bind(config.inColor, 0);
-		TextureHandle texAccum = provTex(config.provisionals, Stringizer() + "luminanceAccumulation" + config.cameraId, Vec2i(1), 1, GL_R32F);
+		TextureHandle texAccum = provTex(config.provisionals, Stringizer() + "luminanceAccumulation_" + config.cameraId, Vec2i(1), 1, GL_R32F);
 		q->bind(texAccum, 1);
 		Holder<ShaderProgram> shader = config.assets->get<AssetSchemeIndexShaderProgram, MultiShaderProgram>(HashString("cage/shader/effects/luminanceApply.glsl"))->get(0);
 		q->bind(shader);
diff --git a/sources/libsimple/gameloop.cpp b/sources/libsimple/gameloop.cpp
@@ -833,7 +833,7 @@ namespace cage
 		return +engineData->guiBus;
 	}
 
-	ProvisionalGraphics *engineProvisonalGraphics()
+	ProvisionalGraphics *engineProvisionalGraphics()
 	{
 		return +engineData->provisionalGraphics;
 	}
diff --git a/sources/libsimple/graphics.cpp b/sources/libsimple/graphics.cpp
@@ -135,7 +135,7 @@ namespace cage
 		TextureHandle initializeTarget(const String &prefix, Vec2i resolution)
 		{
 			const String name = Stringizer() + prefix + "_" + resolution;
-			TextureHandle tex = engineProvisonalGraphics()->texture(name,
+			TextureHandle tex = engineProvisionalGraphics()->texture(name,
 				[resolution](Texture *tex)
 				{
 					tex->initialize(resolution, 1, GL_RGB8);
@@ -174,15 +174,15 @@ namespace cage
 
 			void initialize() // opengl thread
 			{
-				renderQueue = newRenderQueue("engine", engineProvisonalGraphics());
+				renderQueue = newRenderQueue("engine", engineProvisionalGraphics());
 				onDemand = newAssetsOnDemand(engineAssets());
 			}
 
 			void finalize() // opengl thread
 			{
 				onDemand->clear(); // make sure to release all assets, but keep the structure to allow remaining calls to enginePurgeAssetsOnDemandCache
 				renderQueue.clear();
-				engineProvisonalGraphics()->purge();
+				engineProvisionalGraphics()->purge();
 			}
 
 			void emit(uint64 emitTime) // control thread
@@ -266,7 +266,7 @@ namespace cage
 						else
 						{
 							CAGE_ASSERT(!windowTarget);
-							windowTarget = initializeTarget(data.name, data.resolution);
+							windowTarget = initializeTarget(Stringizer() + "windowTarget_" + data.name, data.resolution);
 							data.target = windowTarget;
 						}
 						data.finalProduct = !cam.target;
@@ -307,13 +307,13 @@ namespace cage
 						if (dynamicResolution != 1)
 							data.effects.effects &= ~ScreenSpaceEffectsFlags::AntiAliasing;
 						data.effects.gamma = Real(confRenderGamma);
-						data.name = Stringizer() + "vr_camera_" + index;
+						data.name = Stringizer() + "vrCamera_" + index;
 						data.resolution = applyDynamicResolution(it.resolution);
 						data.transform = transformByVrOrigin(cfg.scene, it.transform, cfg.interpolationFactor);
 						data.projection = it.projection;
 						data.lodSelection.screenSize = perspectiveScreenSize(it.verticalFov, data.resolution[1]);
 						data.lodSelection.center = it.primary ? vrFrame->pose().position : it.transform.position;
-						data.target = initializeTarget(data.name, data.resolution);
+						data.target = initializeTarget(Stringizer() + "vrTarget_" + data.name, data.resolution);
 						data.finalProduct = true;
 						vrTargets.push_back(data.target);
 						cameras.push_back(std::move(data));
@@ -370,7 +370,7 @@ namespace cage
 							Holder<Model> modelSquare = engineAssets()->get<AssetSchemeIndexModel, Model>(HashString("cage/model/square.obj"));
 							CAGE_ASSERT(modelSquare);
 							modelSquare->bind();
-							Holder<FrameBuffer> renderTarget = engineProvisonalGraphics()->frameBufferDraw("vr_blit")->resolve();
+							Holder<FrameBuffer> renderTarget = engineProvisionalGraphics()->frameBufferDraw("vr_blit")->resolve();
 							renderTarget->bind();
 							frame->acquireTextures();
 							CAGE_ASSERT(frame->cameras.size() == targets.size());
@@ -419,7 +419,7 @@ namespace cage
 					const Vec2i windowResolution = engineWindow()->resolution();
 					RenderPipelineConfig cfg;
 					cfg.assets = engineAssets();
-					cfg.provisionalGraphics = engineProvisonalGraphics();
+					cfg.provisionalGraphics = engineProvisionalGraphics();
 					cfg.scene = +eb.scene;
 					cfg.onDemand = +onDemand;
 					const uint64 period = controlThread().updatePeriod();
@@ -457,7 +457,7 @@ namespace cage
 			void dispatch() // opengl thread
 			{
 				renderQueue->dispatch();
-				engineProvisonalGraphics()->reset();
+				engineProvisionalGraphics()->reset();
 
 				{ // check gl errors (even in release, but do not halt the game)
 					try
diff --git a/sources/libsimple/guiInWorld.cpp b/sources/libsimple/guiInWorld.cpp
@@ -32,7 +32,7 @@ namespace cage
 				{
 					GuiManagerCreateConfig cfg;
 					cfg.assetManager = engineAssets();
-					cfg.provisionalGraphics = +engineProvisonalGraphics();
+					cfg.provisionalGraphics = +engineProvisionalGraphics();
 					cfg.tooltipsEnabled = config.tooltipsEnabled;
 					guiMan = newGuiManager(cfg);
 					guiMan->outputResolution(config.resolution);
@@ -152,7 +152,7 @@ namespace cage
 				}
 
 				// retrieve this every frame so that it is not removed
-				auto fb = engineProvisonalGraphics()->frameBufferDraw(Stringizer() + "gui-in-world-framebuffer-" + (uintPtr)this);
+				auto fb = engineProvisionalGraphics()->frameBufferDraw(Stringizer() + "gui-in-world-framebuffer-" + (uintPtr)this);
 
 				Holder<RenderQueue> qq;
 				{
@@ -162,7 +162,7 @@ namespace cage
 				if (!qq)
 					return;
 
-				Holder<RenderQueue> q = newRenderQueue("gui in world", engineProvisonalGraphics());
+				Holder<RenderQueue> q = newRenderQueue("gui in world", engineProvisionalGraphics());
 				{
 					auto name = q->namedScope("gui in world");
 					q->bind(fb);

Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,10 @@ namespace cage`
`18`	`18`	`{`
`19`	`19`	`public:`
`20`	`20`	`const String name;`
	`21`	`+ std::function<void(UniformBuffer *)> init;`
`21`	`22`	`Holder<UniformBuffer> result;`
`22`	`23`	`ProvisionalGraphicsImpl *impl = nullptr;`
	`24`	`+ uint32 type = m; // 1 = init copied`
`23`	`25`	`bool used = true;`
`24`	`26`
`25`	`27`	`ProvisionalUniformBufferImpl(const String &name) : name(name) {}`
`@@ -64,25 +66,21 @@ namespace cage`
`64`	`66`	`{`
`65`	`67`	`Holder<T> v = systemMemory().createHolder<T>(name);`
`66`	`68`	`data.insert(v.share());`
`67`		`- return std::move(v);`
	`69`	`+ return v;`
`68`	`70`	`}`
`69`	`71`	`return it->share();`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`void reset()`
`73`	`75`	`{`
`74`	`76`	`ScopeLock lock(mutex);`
`75`		`- auto it = data.begin();`
`76`		`- while (it != data.end())`
`77`		`- {`
`78`		`- if ((*it)->used)`
	`77`	`+ std::erase_if(data,`
	`78`	`+ [](auto &it)`
`79`	`79`	`{`
`80`		`- (*it)->used = false;`
`81`		`- it++;`
`82`		`- }`
`83`		`- else`
`84`		`- it = data.erase(it);`
`85`		`- }`
	`80`	`+ const bool res = it->used;`
	`81`	`+ it->used = false;`
	`82`	`+ return !res;`
	`83`	`+ });`
`86`	`84`	`}`
`87`	`85`
`88`	`86`	`void purge()`
`@@ -119,9 +117,14 @@ namespace cage`
`119`	`117`	`Container<ProvisionalFrameBufferHandleImpl> frameBuffers;`
`120`	`118`	`Container<ProvisionalTextureHandleImpl> textures;`
`121`	`119`
`122`		`- Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name)`
	`120`	`+ Holder<ProvisionalUniformBuffer> uniformBuffer(const String &name, std::function<void(UniformBuffer *)> &&init)`
`123`	`121`	`{`
`124`	`122`	`auto ub = uniformBuffers.acquire(name);`
	`123`	`+ if (ub->type == m)`
	`124`	`+ {`
	`125`	`+ ub->type = 1;`
	`126`	`+ ub->init = std::move(init);`
	`127`	`+ }`
`125`	`128`	`return std::move(ub).cast<ProvisionalUniformBuffer>();`
`126`	`129`	`}`
`127`	`130`
`@@ -169,16 +172,12 @@ namespace cage`
`169`	`172`	`{`
`170`	`173`	`impl->result = newUniformBuffer();`
`171`	`174`	`impl->result->setDebugName(impl->name);`
	`175`	`+ if (impl->init)`
	`176`	`+ impl->init(+impl->result);`
`172`	`177`	`}`
`173`	`178`	`return impl->result.share();`
`174`	`179`	`}`
`175`	`180`
`176`		`- bool ProvisionalUniformBuffer::ready() const`
`177`		`- {`
`178`		`- const ProvisionalUniformBufferImpl impl = (const ProvisionalUniformBufferImpl )this;`
`179`		`- return !!impl->result;`
`180`		`- }`
`181`		`-`
`182`	`181`	`Holder<FrameBuffer> ProvisionalFrameBuffer::resolve()`
`183`	`182`	`{`
`184`	`183`	`ProvisionalFrameBufferHandleImpl impl = (ProvisionalFrameBufferHandleImpl )this;`
`@@ -199,12 +198,6 @@ namespace cage`
`199`	`198`	`return impl->result.share();`
`200`	`199`	`}`
`201`	`200`
`202`		`- bool ProvisionalFrameBuffer::ready() const`
`203`		`- {`
`204`		`- const ProvisionalFrameBufferHandleImpl impl = (const ProvisionalFrameBufferHandleImpl )this;`
`205`		`- return !!impl->result;`
`206`		`- }`
`207`		`-`
`208`	`201`	`Holder<Texture> ProvisionalTexture::resolve()`
`209`	`202`	`{`
`210`	`203`	`ProvisionalTextureHandleImpl impl = (ProvisionalTextureHandleImpl )this;`
`@@ -213,21 +206,16 @@ namespace cage`
`213`	`206`	`{`
`214`	`207`	`impl->result = newTexture(impl->target);`
`215`	`208`	`impl->result->setDebugName(impl->name);`
`216`		`- impl->init(+impl->result);`
	`209`	`+ if (impl->init)`
	`210`	`+ impl->init(+impl->result);`
`217`	`211`	`}`
`218`	`212`	`return impl->result.share();`
`219`	`213`	`}`
`220`	`214`
`221`		`- bool ProvisionalTexture::ready() const`
`222`		`- {`
`223`		`- const ProvisionalTextureHandleImpl impl = (const ProvisionalTextureHandleImpl )this;`
`224`		`- return !!impl->result;`
`225`		`- }`
`226`		`-`
`227`		`- Holder<ProvisionalUniformBuffer> ProvisionalGraphics::uniformBuffer(const String &name)`
	`215`	`+ Holder<ProvisionalUniformBuffer> ProvisionalGraphics::uniformBuffer(const String &name, std::function<void(UniformBuffer *)> &&init)`
`228`	`216`	`{`
`229`	`217`	`ProvisionalGraphicsImpl impl = (ProvisionalGraphicsImpl )this;`
`230`		`- return impl->uniformBuffer(name);`
	`218`	`+ return impl->uniformBuffer(name, std::move(init));`
`231`	`219`	`}`
`232`	`220`
`233`	`221`	`Holder<ProvisionalFrameBuffer> ProvisionalGraphics::frameBufferDraw(const String &name)`
Original file line number	Diff line number	Diff line change
`@@ -833,7 +833,7 @@ namespace cage`
`833`	`833`	`return +engineData->guiBus;`
`834`	`834`	`}`
`835`	`835`
`836`		`- ProvisionalGraphics *engineProvisonalGraphics()`
	`836`	`+ ProvisionalGraphics *engineProvisionalGraphics()`
`837`	`837`	`{`
`838`	`838`	`return +engineData->provisionalGraphics;`
`839`	`839`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace cage`
`32`	`32`	`{`
`33`	`33`	`GuiManagerCreateConfig cfg;`
`34`	`34`	`cfg.assetManager = engineAssets();`
`35`		`- cfg.provisionalGraphics = +engineProvisonalGraphics();`
	`35`	`+ cfg.provisionalGraphics = +engineProvisionalGraphics();`
`36`	`36`	`cfg.tooltipsEnabled = config.tooltipsEnabled;`
`37`	`37`	`guiMan = newGuiManager(cfg);`
`38`	`38`	`guiMan->outputResolution(config.resolution);`
`@@ -152,7 +152,7 @@ namespace cage`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`// retrieve this every frame so that it is not removed`
`155`		`- auto fb = engineProvisonalGraphics()->frameBufferDraw(Stringizer() + "gui-in-world-framebuffer-" + (uintPtr)this);`
	`155`	`+ auto fb = engineProvisionalGraphics()->frameBufferDraw(Stringizer() + "gui-in-world-framebuffer-" + (uintPtr)this);`
`156`	`156`
`157`	`157`	`Holder<RenderQueue> qq;`
`158`	`158`	`{`
`@@ -162,7 +162,7 @@ namespace cage`
`162`	`162`	`if (!qq)`
`163`	`163`	`return;`
`164`	`164`
`165`		`- Holder<RenderQueue> q = newRenderQueue("gui in world", engineProvisonalGraphics());`
	`165`	`+ Holder<RenderQueue> q = newRenderQueue("gui in world", engineProvisionalGraphics());`
`166`	`166`	`{`
`167`	`167`	`auto name = q->namedScope("gui in world");`
`168`	`168`	`q->bind(fb);`