Fix tests

src/anki/core/StagingGpuMemoryManager.cpp

@@ -59,7 +59,7 @@ void StagingGpuMemoryManager::initBuffer(
 	perframe.m_mappedMem = static_cast<U8*>(perframe.m_buff->map(0, perframe.m_size, BufferMapAccessBit::WRITE));
 }
 
-void* StagingGpuMemoryManager::allocatePerFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
+void* StagingGpuMemoryManager::allocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
 {
 	PerFrameBuffer& buff = m_perFrameBuffers[usage];
 	Error err = buff.m_alloc.allocate(size, token.m_offset);
@@ -75,8 +75,7 @@ void* StagingGpuMemoryManager::allocatePerFrame(PtrSize size, StagingGpuMemoryTy
 	return buff.m_mappedMem + token.m_offset;
 }
 
-void* StagingGpuMemoryManager::tryAllocatePerFrame(
-	PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
+void* StagingGpuMemoryManager::tryAllocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
 {
 	PerFrameBuffer& buff = m_perFrameBuffers[usage];
 	Error err = buff.m_alloc.allocate(size, token.m_offset);

src/anki/core/StagingGpuMemoryManager.h

@@ -75,11 +75,11 @@ public:
 
 	/// Allocate staging memory for various operations. The memory will be reclaimed at the begining of the
 	/// N-(MAX_FRAMES_IN_FLIGHT-1) frame.
-	void* allocatePerFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
+	void* allocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
 
 	/// Allocate staging memory for various operations. The memory will be reclaimed at the begining of the
 	/// N-(MAX_FRAMES_IN_FLIGHT-1) frame.
-	void* tryAllocatePerFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
+	void* tryAllocateFrame(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
 
 private:
 	class PerFrameBuffer

src/anki/gr/CommandBuffer.inl.h

@@ -1,73 +0,0 @@
-// Copyright (C) 2009-2016, Panagiotis Christopoulos Charitos and contributors.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include <anki/gr/CommandBuffer.h>
-#include <anki/gr/GrManager.h>
-
-namespace anki
-{
-
-inline void CommandBuffer::uploadTextureSurfaceData(
-	TexturePtr tex, const TextureSurfaceInfo& surf, void*& data, PtrSize& dataSize)
-{
-	PtrSize allocationSize;
-	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
-	ANKI_ASSERT(dataSize <= allocationSize);
-
-	TransientMemoryToken token;
-	data = getManager().allocateFrameTransientMemory(allocationSize, usage, token);
-
-	uploadTextureSurface(tex, surf, token);
-}
-
-inline void CommandBuffer::tryUploadTextureSurfaceData(
-	TexturePtr tex, const TextureSurfaceInfo& surf, void*& data, PtrSize& dataSize)
-{
-	PtrSize allocationSize;
-	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
-	ANKI_ASSERT(dataSize <= allocationSize);
-
-	TransientMemoryToken token;
-	data = getManager().tryAllocateFrameTransientMemory(allocationSize, usage, token);
-
-	if(data)
-	{
-		uploadTextureSurface(tex, surf, token);
-	}
-}
-
-inline void CommandBuffer::uploadTextureSurfaceCopyData(
-	TexturePtr tex, const TextureSurfaceInfo& surf, const void* data, PtrSize dataSize)
-{
-	PtrSize allocationSize;
-	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
-	getManager().getTextureSurfaceUploadInfo(tex, surf, allocationSize);
-	ANKI_ASSERT(dataSize <= allocationSize);
-
-	TransientMemoryToken token;
-	void* ptr = getManager().allocateFrameTransientMemory(allocationSize, usage, token);
-	memcpy(ptr, data, dataSize);
-
-	uploadTextureSurface(tex, surf, token);
-}
-
-inline void CommandBuffer::uploadTextureVolumeCopyData(
-	TexturePtr tex, const TextureVolumeInfo& vol, const void* data, PtrSize dataSize)
-{
-	PtrSize allocationSize;
-	const BufferUsageBit usage = BufferUsageBit::TEXTURE_UPLOAD_SOURCE;
-	getManager().getTextureVolumeUploadInfo(tex, vol, allocationSize);
-	ANKI_ASSERT(dataSize <= allocationSize);
-
-	TransientMemoryToken token;
-	void* ptr = getManager().allocateFrameTransientMemory(allocationSize, usage, token);
-	memcpy(ptr, data, dataSize);
-
-	uploadTextureVolume(tex, vol, token);
-}
-
-} // end namespace anki

src/anki/gr/gl/BufferImpl.cpp

@@ -30,45 +30,11 @@ void BufferImpl::init(PtrSize size, BufferUsageBit usage, BufferMapAccessBit acc
 
 	if((usage & BufferUsageBit::UNIFORM_ALL) != BufferUsageBit::NONE)
 	{
-		GLint64 maxBufferSize;
-		glGetInteger64v(GL_MAX_UNIFORM_BLOCK_SIZE, &maxBufferSize);
-
-		if(size > 16384)
-		{
-			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
-					  "than the spec's min",
-				size);
-		}
-		else if(size > PtrSize(maxBufferSize))
-		{
-			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
-					  "than the implementation's min (%u)",
-				size,
-				maxBufferSize);
-		}
-
 		m_target = GL_UNIFORM_BUFFER;
 	}
 
 	if((usage & BufferUsageBit::STORAGE_ALL) != BufferUsageBit::NONE)
 	{
-		GLint64 maxBufferSize;
-		glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxBufferSize);
-
-		if(size > pow(2, 24))
-		{
-			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
-					  "than the spec's min",
-				size);
-		}
-		else if(size > PtrSize(maxBufferSize))
-		{
-			ANKI_LOGW("The size (%u) of the shader storage buffer is greater "
-					  "than the implementation's min (%u)",
-				size,
-				maxBufferSize);
-		}
-
 		m_target = GL_SHADER_STORAGE_BUFFER;
 	}
 

src/anki/renderer/Drawer.cpp

@@ -297,7 +297,7 @@ void RenderableDrawer::setupUniforms(DrawContext& ctx, CompleteRenderingBuildInf
 	const MaterialVariant& variant = mtl.getVariant(build.m_in.m_key);
 
 	// Get some memory for uniforms
-	U8* uniforms = static_cast<U8*>(m_r->getStagingGpuMemoryManager().allocatePerFrame(
+	U8* uniforms = static_cast<U8*>(m_r->getStagingGpuMemoryManager().allocateFrame(
 		variant.getDefaultBlockSize(), StagingGpuMemoryType::UNIFORM, ctx.m_uboToken));
 
 	// Call the visitor

src/anki/renderer/Ir.cpp

@@ -125,7 +125,7 @@ Error Ir::loadMesh(CString fname, BufferPtr& vert, BufferPtr& idx, U32& idxCount
 
 	StagingGpuMemoryToken token;
 	Vec3* verts = static_cast<Vec3*>(
-		m_r->getStagingGpuMemoryManager().allocatePerFrame(vertBuffSize, StagingGpuMemoryType::TRANSFER, token));
+		m_r->getStagingGpuMemoryManager().allocateFrame(vertBuffSize, StagingGpuMemoryType::TRANSFER, token));
 
 	const U8* ptr = loader.getVertexData();
 	for(U i = 0; i < loader.getHeader().m_totalVerticesCount; ++i)
@@ -137,7 +137,7 @@ Error Ir::loadMesh(CString fname, BufferPtr& vert, BufferPtr& idx, U32& idxCount
 
 	cmdb->copyBufferToBuffer(token.m_buffer, token.m_offset, vert, 0, token.m_range);
 
-	void* cpuIds = m_r->getStagingGpuMemoryManager().allocatePerFrame(
+	void* cpuIds = m_r->getStagingGpuMemoryManager().allocateFrame(
 		loader.getIndexDataSize(), StagingGpuMemoryType::TRANSFER, token);
 
 	memcpy(cpuIds, loader.getIndexData(), loader.getIndexDataSize());

src/anki/renderer/Lf.cpp

@@ -145,7 +145,7 @@ void Lf::runOcclusionTests(RenderingContext& ctx, CommandBufferPtr cmdb)
 
 		// Alloc dyn mem
 		StagingGpuMemoryToken vertToken;
-		positions = static_cast<Vec3*>(m_r->getStagingGpuMemoryManager().allocatePerFrame(
+		positions = static_cast<Vec3*>(m_r->getStagingGpuMemoryManager().allocateFrame(
 			sizeof(Vec3) * count, StagingGpuMemoryType::VERTEX, vertToken));
 		initialPositions = positions;
 

src/anki/renderer/LightBin.cpp

@@ -403,7 +403,7 @@ Error LightBin::bin(FrustumComponent& frc,
 
 	if(visiblePointLightsCount)
 	{
-		ShaderPointLight* data = static_cast<ShaderPointLight*>(m_stagingMem->allocatePerFrame(
+		ShaderPointLight* data = static_cast<ShaderPointLight*>(m_stagingMem->allocateFrame(
 			sizeof(ShaderPointLight) * visiblePointLightsCount, StagingGpuMemoryType::UNIFORM, pointLightsToken));
 
 		ctx.m_pointLights = WeakArray<ShaderPointLight>(data, visiblePointLightsCount);
@@ -418,7 +418,7 @@ Error LightBin::bin(FrustumComponent& frc,
 
 	if(visibleSpotLightsCount)
 	{
-		ShaderSpotLight* data = static_cast<ShaderSpotLight*>(m_stagingMem->allocatePerFrame(
+		ShaderSpotLight* data = static_cast<ShaderSpotLight*>(m_stagingMem->allocateFrame(
 			sizeof(ShaderSpotLight) * visibleSpotLightsCount, StagingGpuMemoryType::UNIFORM, spotLightsToken));
 
 		ctx.m_spotLights = WeakArray<ShaderSpotLight>(data, visibleSpotLightsCount);
@@ -435,7 +435,7 @@ Error LightBin::bin(FrustumComponent& frc,
 	{
 		if(visibleProbeCount)
 		{
-			ShaderProbe* data = static_cast<ShaderProbe*>(m_stagingMem->allocatePerFrame(
+			ShaderProbe* data = static_cast<ShaderProbe*>(m_stagingMem->allocateFrame(
 				sizeof(ShaderProbe) * visibleProbeCount, StagingGpuMemoryType::UNIFORM, *probesToken));
 
 			ctx.m_probes = WeakArray<ShaderProbe>(data, visibleProbeCount);
@@ -451,7 +451,7 @@ Error LightBin::bin(FrustumComponent& frc,
 
 	if(visibleDecalCount)
 	{
-		ShaderDecal* data = static_cast<ShaderDecal*>(m_stagingMem->allocatePerFrame(
+		ShaderDecal* data = static_cast<ShaderDecal*>(m_stagingMem->allocateFrame(
 			sizeof(ShaderDecal) * visibleDecalCount, StagingGpuMemoryType::UNIFORM, decalsToken));
 
 		ctx.m_decals = WeakArray<ShaderDecal>(data, visibleDecalCount);
@@ -466,14 +466,14 @@ Error LightBin::bin(FrustumComponent& frc,
 	ctx.m_bin = this;
 
 	// Get mem for clusters
-	ShaderCluster* data = static_cast<ShaderCluster*>(m_stagingMem->allocatePerFrame(
+	ShaderCluster* data = static_cast<ShaderCluster*>(m_stagingMem->allocateFrame(
 		sizeof(ShaderCluster) * m_clusterCount, StagingGpuMemoryType::STORAGE, clustersToken));
 
 	ctx.m_clusters = WeakArray<ShaderCluster>(data, m_clusterCount);
 
 	// Allocate light IDs
-	U32* data2 = static_cast<U32*>(m_stagingMem->allocatePerFrame(
-		maxLightIndices * sizeof(U32), StagingGpuMemoryType::STORAGE, lightIndicesToken));
+	U32* data2 = static_cast<U32*>(
+		m_stagingMem->allocateFrame(maxLightIndices * sizeof(U32), StagingGpuMemoryType::STORAGE, lightIndicesToken));
 
 	ctx.m_lightIds = WeakArray<U32>(data2, maxLightIndices);
 

src/anki/renderer/RenderingPass.cpp

@@ -35,10 +35,9 @@ ResourceManager& RenderingPass::getResourceManager()
 	return m_r->getResourceManager();
 }
 
-void* RenderingPass::allocatePerFrameStagingMemory(
-	PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
+void* RenderingPass::allocateFrameStagingMemory(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token)
 {
-	return m_r->getStagingGpuMemoryManager().allocatePerFrame(size, usage, token);
+	return m_r->getStagingGpuMemoryManager().allocateFrame(size, usage, token);
 }
 
 } // end namespace anki

src/anki/renderer/RenderingPass.h

@@ -43,7 +43,7 @@ anki_internal:
 	template<typename TPtr>
 	TPtr allocateUniforms(PtrSize size, StagingGpuMemoryToken& token)
 	{
-		return static_cast<TPtr>(allocatePerFrameStagingMemory(size, StagingGpuMemoryType::UNIFORM, token));
+		return static_cast<TPtr>(allocateFrameStagingMemory(size, StagingGpuMemoryType::UNIFORM, token));
 	}
 
 	static void bindUniforms(CommandBufferPtr& cmdb, U set, U binding, const StagingGpuMemoryToken& token)
@@ -66,7 +66,7 @@ anki_internal:
 	template<typename TPtr>
 	TPtr allocateStorage(PtrSize size, StagingGpuMemoryToken& token)
 	{
-		return static_cast<TPtr>(allocatePerFrameStagingMemory(size, StagingGpuMemoryType::STORAGE, token));
+		return static_cast<TPtr>(allocateFrameStagingMemory(size, StagingGpuMemoryType::STORAGE, token));
 	}
 
 	static void bindStorage(CommandBufferPtr& cmdb, U set, U binding, const StagingGpuMemoryToken& token)
@@ -85,7 +85,7 @@ protected:
 
 	ResourceManager& getResourceManager();
 
-	void* allocatePerFrameStagingMemory(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
+	void* allocateFrameStagingMemory(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
 };
 /// @}
 

src/anki/renderer/Smaa.cpp

@@ -167,7 +167,7 @@ Error SmaaWeights::init(const ConfigSet& initializer)
 		m_areaTex = gr.newInstance<Texture>(texinit);
 
 		StagingGpuMemoryToken token;
-		void* stagingMem = m_r->getStagingGpuMemoryManager().allocatePerFrame(
+		void* stagingMem = m_r->getStagingGpuMemoryManager().allocateFrame(
 			sizeof(areaTexBytes), StagingGpuMemoryType::TRANSFER, token);
 		memcpy(stagingMem, &areaTexBytes[0], sizeof(areaTexBytes));
 
@@ -189,7 +189,7 @@ Error SmaaWeights::init(const ConfigSet& initializer)
 		m_searchTex = gr.newInstance<Texture>(texinit);
 
 		StagingGpuMemoryToken token;
-		void* stagingMem = m_r->getStagingGpuMemoryManager().allocatePerFrame(
+		void* stagingMem = m_r->getStagingGpuMemoryManager().allocateFrame(
 			sizeof(searchTexBytes), StagingGpuMemoryType::TRANSFER, token);
 		memcpy(stagingMem, &searchTexBytes[0], sizeof(searchTexBytes));
 

src/anki/renderer/Ssao.cpp

@@ -117,7 +117,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 	StagingGpuMemoryToken token;
 	const U noiseSize = NOISE_TEX_SIZE * NOISE_TEX_SIZE * sizeof(Array<I8, 4>);
 	Array<I8, 4>* noise = static_cast<Array<I8, 4>*>(
-		m_r->getStagingGpuMemoryManager().allocatePerFrame(noiseSize, StagingGpuMemoryType::TRANSFER, token));
+		m_r->getStagingGpuMemoryManager().allocateFrame(noiseSize, StagingGpuMemoryType::TRANSFER, token));
 
 	genNoise(&noise[0], &noise[0] + noiseSize);
 

src/anki/renderer/Tm.cpp

@@ -49,8 +49,7 @@ Error Tm::initInternal(const ConfigSet& initializer)
 	CommandBufferPtr cmdb = getGrManager().newInstance<CommandBuffer>(cmdbinit);
 
 	StagingGpuMemoryToken token;
-	void* data =
-		m_r->getStagingGpuMemoryManager().allocatePerFrame(sizeof(Vec4), StagingGpuMemoryType::TRANSFER, token);
+	void* data = m_r->getStagingGpuMemoryManager().allocateFrame(sizeof(Vec4), StagingGpuMemoryType::TRANSFER, token);
 	*static_cast<Vec4*>(data) = Vec4(0.5);
 	cmdb->copyBufferToBuffer(token.m_buffer, token.m_offset, m_luminanceBuff, 0, token.m_range);
 	cmdb->flush();

src/anki/resource/Mesh.cpp

@@ -42,8 +42,7 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 	if(m_vertBuff)
 	{
 		StagingGpuMemoryToken token;
-		void* data =
-			stagingMem.tryAllocatePerFrame(m_loader.getVertexDataSize(), StagingGpuMemoryType::TRANSFER, token);
+		void* data = stagingMem.tryAllocateFrame(m_loader.getVertexDataSize(), StagingGpuMemoryType::TRANSFER, token);
 
 		if(data)
 		{
@@ -71,7 +70,7 @@ Error MeshLoadTask::operator()(AsyncLoaderTaskContext& ctx)
 	// Create index buffer
 	{
 		StagingGpuMemoryToken token;
-		void* data = stagingMem.tryAllocatePerFrame(m_loader.getIndexDataSize(), StagingGpuMemoryType::TRANSFER, token);
+		void* data = stagingMem.tryAllocateFrame(m_loader.getIndexDataSize(), StagingGpuMemoryType::TRANSFER, token);
 
 		if(data)
 		{

src/anki/resource/TextureResource.cpp

@@ -75,7 +75,7 @@ Error TexUploadTask::operator()(AsyncLoaderTaskContext& ctx)
 				ANKI_ASSERT(allocationSize >= surfOrVolSize);
 
 				StagingGpuMemoryToken token;
-				void* data = m_stagingMem->tryAllocatePerFrame(allocationSize, StagingGpuMemoryType::TRANSFER, token);
+				void* data = m_stagingMem->tryAllocateFrame(allocationSize, StagingGpuMemoryType::TRANSFER, token);
 
 				if(data)
 				{

src/anki/scene/ParticleEmitter.cpp

@@ -375,7 +375,7 @@ Error ParticleEmitter::frameUpdate(F32 prevUpdateTime, F32 crntTime)
 	Vec4 aabbmax(MIN_F32, MIN_F32, MIN_F32, 0.0);
 	m_aliveParticlesCount = 0;
 
-	F32* verts = static_cast<F32*>(getResourceManager().getStagingGpuMemoryManager().allocatePerFrame(
+	F32* verts = static_cast<F32*>(getResourceManager().getStagingGpuMemoryManager().allocateFrame(
 		m_vertBuffSize, StagingGpuMemoryType::VERTEX, m_vertBuffToken));
 
 	const F32* verts_base = verts;

tests/gr/Gr.cpp

@@ -8,6 +8,7 @@
 #include <anki/core/NativeWindow.h>
 #include <anki/core/Config.h>
 #include <anki/util/HighRezTimer.h>
+#include <anki/core/StagingGpuMemoryManager.h>
 
 namespace anki
 {
@@ -255,16 +256,61 @@ void main()
 	imageStore(u_img, ivec2(gl_WorkGroupID.x, gl_WorkGroupID.y), u_color);
 })";
 
+static NativeWindow* win = nullptr;
+static GrManager* gr = nullptr;
+static StagingGpuMemoryManager* stagingMem = nullptr;
+
 #define COMMON_BEGIN()                                                                                                 \
-	NativeWindow* win = nullptr;                                                                                       \
-	GrManager* gr = nullptr;                                                                                           \
+	stagingMem = new StagingGpuMemoryManager();                                                                        \
 	createGrManager(win, gr);                                                                                          \
+	ANKI_TEST_EXPECT_NO_ERR(stagingMem->init(gr, Config()));                                                           \
 	{
 
 #define COMMON_END()                                                                                                   \
 	}                                                                                                                  \
+	delete stagingMem;                                                                                                 \
 	delete gr;                                                                                                         \
-	delete win;
+	delete win;                                                                                                        \
+	win = nullptr;                                                                                                     \
+	gr = nullptr;                                                                                                      \
+	stagingMem = nullptr;
+
+static void* setUniforms(PtrSize size, CommandBufferPtr& cmdb, U set, U binding)
+{
+	StagingGpuMemoryToken token;
+	void* ptr = stagingMem->allocateFrame(size, StagingGpuMemoryType::UNIFORM, token);
+	cmdb->bindUniformBuffer(set, binding, token.m_buffer, token.m_offset, token.m_range);
+	return ptr;
+}
+
+static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U set, U binding)
+{
+	StagingGpuMemoryToken token;
+	void* ptr = stagingMem->allocateFrame(size, StagingGpuMemoryType::STORAGE, token);
+	cmdb->bindStorageBuffer(set, binding, token.m_buffer, token.m_offset, token.m_range);
+	return ptr;
+}
+
+#define SET_UNIFORMS(type_, size_, cmdb_, set_, binding_) static_cast<type_>(setUniforms(size_, cmdb_, set_, binding_))
+#define SET_STORAGE(type_, size_, cmdb_, set_, binding_) static_cast<type_>(setStorage(size_, cmdb_, set_, binding_))
+
+#define UPLOAD_TEX_SURFACE(cmdb_, tex_, surf_, ptr_, size_)                                                            \
+	do                                                                                                                 \
+	{                                                                                                                  \
+		StagingGpuMemoryToken token;                                                                                   \
+		void* f = stagingMem->allocateFrame(size_, StagingGpuMemoryType::TRANSFER, token);                             \
+		memcpy(f, ptr_, size_);                                                                                        \
+		cmdb_->copyBufferToTextureSurface(token.m_buffer, token.m_offset, token.m_range, tex_, surf_);                 \
+	} while(0)
+
+#define UPLOAD_TEX_VOL(cmdb_, tex_, vol_, ptr_, size_)                                                                 \
+	do                                                                                                                 \
+	{                                                                                                                  \
+		StagingGpuMemoryToken token;                                                                                   \
+		void* f = stagingMem->allocateFrame(size_, StagingGpuMemoryType::TRANSFER, token);                             \
+		memcpy(f, ptr_, size_);                                                                                        \
+		cmdb_->copyBufferToTextureVolume(token.m_buffer, token.m_offset, token.m_range, tex_, vol_);                   \
+	} while(0)
 
 const PixelFormat DS_FORMAT = PixelFormat(ComponentFormat::D24S8, TransformFormat::UNORM);
 
@@ -449,16 +495,6 @@ ANKI_TEST(Gr, DrawWithUniforms)
 		timer.start();
 		gr->beginFrame();
 
-		// Uploaded buffer
-		TransientMemoryToken token;
-		Vec4* rotMat =
-			static_cast<Vec4*>(gr->allocateFrameTransientMemory(sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, token));
-		F32 angle = toRad(360.0f / ITERATION_COUNT * iterations);
-		(*rotMat)[0] = cos(angle);
-		(*rotMat)[1] = -sin(angle);
-		(*rotMat)[2] = sin(angle);
-		(*rotMat)[3] = cos(angle);
-
 		CommandBufferInitInfo cinit;
 		CommandBufferPtr cmdb = gr->newInstance<CommandBuffer>(cinit);
 
@@ -466,8 +502,15 @@ ANKI_TEST(Gr, DrawWithUniforms)
 		cmdb->bindShaderProgram(prog);
 		cmdb->beginRenderPass(fb);
 
-		cmdb->bindUniformBuffer(0, 0, b, 0);
-		cmdb->bindUniformBuffer(0, 1, token);
+		cmdb->bindUniformBuffer(0, 0, b, 0, MAX_PTR_SIZE);
+
+		// Uploaded buffer
+		Vec4* rotMat = SET_UNIFORMS(Vec4*, sizeof(Vec4), cmdb, 0, 1);
+		F32 angle = toRad(360.0f / ITERATION_COUNT * iterations);
+		(*rotMat)[0] = cos(angle);
+		(*rotMat)[1] = -sin(angle);
+		(*rotMat)[2] = sin(angle);
+		(*rotMat)[3] = cos(angle);
 
 		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
 		cmdb->endRenderPass();
@@ -705,11 +748,11 @@ ANKI_TEST(Gr, DrawWithTexture)
 
 	cmdb->setTextureSurfaceBarrier(b, TextureUsageBit::NONE, TextureUsageBit::UPLOAD, TextureSurfaceInfo(0, 0, 0, 0));
 
-	cmdb->uploadTextureSurfaceCopyData(a, TextureSurfaceInfo(0, 0, 0, 0), &mip0[0], sizeof(mip0));
+	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceInfo(0, 0, 0, 0), &mip0[0], sizeof(mip0));
 
-	cmdb->uploadTextureSurfaceCopyData(a, TextureSurfaceInfo(1, 0, 0, 0), &mip1[0], sizeof(mip1));
+	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceInfo(1, 0, 0, 0), &mip1[0], sizeof(mip1));
 
-	cmdb->uploadTextureSurfaceCopyData(b, TextureSurfaceInfo(0, 0, 0, 0), &bmip0[0], sizeof(bmip0));
+	UPLOAD_TEX_SURFACE(cmdb, b, TextureSurfaceInfo(0, 0, 0, 0), &bmip0[0], sizeof(bmip0));
 
 	// Gen mips
 	cmdb->setTextureSurfaceBarrier(
@@ -795,15 +838,12 @@ static void drawOffscreenDrawcalls(GrManager& gr,
 
 	Mat4 projMat = Mat4::calculatePerspectiveProjectionMatrix(toRad(60.0), toRad(60.0), 0.1f, 100.0f);
 
-	TransientMemoryToken token0, token1;
-
 	Mat4 modelMat(Vec4(-0.5, -0.5, 0.0, 1.0), Mat3(Euler(ang, ang / 2.0f, ang / 3.0f)), 1.0f);
 
-	Mat4* mvp = static_cast<Mat4*>(gr.allocateFrameTransientMemory(sizeof(*mvp), BufferUsageBit::UNIFORM_ALL, token0));
+	Mat4* mvp = SET_UNIFORMS(Mat4*, sizeof(*mvp), cmdb, 0, 0);
 	*mvp = projMat * viewMat * modelMat;
 
-	Vec4* color =
-		static_cast<Vec4*>(gr.allocateFrameTransientMemory(sizeof(*color) * 2, BufferUsageBit::UNIFORM_ALL, token1));
+	Vec4* color = SET_UNIFORMS(Vec4*, sizeof(*color) * 2, cmdb, 0, 1);
 	*color++ = Vec4(1.0, 0.0, 0.0, 0.0);
 	*color = Vec4(0.0, 1.0, 0.0, 0.0);
 
@@ -812,23 +852,18 @@ static void drawOffscreenDrawcalls(GrManager& gr,
 	cmdb->bindShaderProgram(prog);
 	cmdb->bindIndexBuffer(indexBuff, 0, IndexType::U16);
 	cmdb->setViewport(0, 0, viewPortSize, viewPortSize);
-	cmdb->bindUniformBuffer(0, 0, token0);
-	cmdb->bindUniformBuffer(0, 1, token1);
 	cmdb->drawElements(PrimitiveTopology::TRIANGLES, 6 * 2 * 3);
 
 	// 2nd draw
 	modelMat = Mat4(Vec4(0.5, 0.5, 0.0, 1.0), Mat3(Euler(ang * 2.0, ang, ang / 3.0f * 2.0)), 1.0f);
 
-	mvp = static_cast<Mat4*>(gr.allocateFrameTransientMemory(sizeof(*mvp), BufferUsageBit::UNIFORM_ALL, token0));
+	mvp = SET_UNIFORMS(Mat4*, sizeof(*mvp), cmdb, 0, 0);
 	*mvp = projMat * viewMat * modelMat;
 
-	color =
-		static_cast<Vec4*>(gr.allocateFrameTransientMemory(sizeof(*color) * 2, BufferUsageBit::UNIFORM_ALL, token1));
+	color = SET_UNIFORMS(Vec4*, sizeof(*color) * 2, cmdb, 0, 1);
 	*color++ = Vec4(0.0, 0.0, 1.0, 0.0);
 	*color = Vec4(0.0, 1.0, 1.0, 0.0);
 
-	cmdb->bindUniformBuffer(0, 0, token0);
-	cmdb->bindUniformBuffer(0, 1, token1);
 	cmdb->drawElements(PrimitiveTopology::TRIANGLES, 6 * 2 * 3);
 }
 
@@ -1051,16 +1086,13 @@ ANKI_TEST(Gr, ImageLoadStore)
 		CommandBufferPtr cmdb = gr->newInstance<CommandBuffer>(cinit);
 
 		// Write image
-		TransientMemoryToken token;
-		Vec4* col =
-			static_cast<Vec4*>(gr->allocateFrameTransientMemory(sizeof(*col), BufferUsageBit::STORAGE_ALL, token));
+		Vec4* col = SET_STORAGE(Vec4*, sizeof(*col), cmdb, 1, 0);
 		*col = Vec4(iterations / F32(ITERATION_COUNT));
 
 		cmdb->setTextureSurfaceBarrier(
 			tex, TextureUsageBit::NONE, TextureUsageBit::IMAGE_COMPUTE_WRITE, TextureSurfaceInfo(1, 0, 0, 0));
 		cmdb->bindShaderProgram(compProg);
 		cmdb->bindImage(0, 0, tex, 1);
-		cmdb->bindStorageBuffer(1, 0, token);
 		cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
 		cmdb->setTextureSurfaceBarrier(tex,
 			TextureUsageBit::IMAGE_COMPUTE_WRITE,
@@ -1163,9 +1195,9 @@ ANKI_TEST(Gr, 3DTextures)
 
 	cmdb->setTextureVolumeBarrier(a, TextureUsageBit::NONE, TextureUsageBit::UPLOAD, TextureVolumeInfo(1));
 
-	cmdb->uploadTextureVolumeCopyData(a, TextureVolumeInfo(0), &mip0[0], sizeof(mip0));
+	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeInfo(0), &mip0[0], sizeof(mip0));
 
-	cmdb->uploadTextureVolumeCopyData(a, TextureVolumeInfo(1), &mip1[0], sizeof(mip1));
+	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeInfo(1), &mip1[0], sizeof(mip1));
 
 	cmdb->setTextureVolumeBarrier(a, TextureUsageBit::UPLOAD, TextureUsageBit::SAMPLED_FRAGMENT, TextureVolumeInfo(0));
 
@@ -1207,14 +1239,11 @@ ANKI_TEST(Gr, 3DTextures)
 
 		cmdb->bindShaderProgram(prog);
 
-		TransientMemoryToken token;
-		Vec4* uv =
-			static_cast<Vec4*>(gr->allocateFrameTransientMemory(sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, token));
+		Vec4* uv = SET_UNIFORMS(Vec4*, sizeof(Vec4), cmdb, 0, 0);
 
 		U idx = (F32(ITERATION_COUNT - iterations - 1) / ITERATION_COUNT) * TEX_COORDS_LOD.getSize();
 		*uv = TEX_COORDS_LOD[idx];
 
-		cmdb->bindUniformBuffer(0, 0, token);
 		cmdb->bindTexture(0, 0, a);
 		cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 6);