Refactoring again. COMPILES

include/anki/misc/Xml.h

@@ -31,7 +31,7 @@ public:
 		m_alloc(b.m_alloc)
 	{}
 
-	XmlElement(tinyxml2::XMLElement* el, const StackAllocator<U8>& alloc)
+	XmlElement(tinyxml2::XMLElement* el, GenericMemoryPoolAllocator<U8> alloc)
 	:	m_el(el),
 		m_alloc(alloc)
 	{}
@@ -90,7 +90,7 @@ public:
 
 private:
 	tinyxml2::XMLElement* m_el;
-	StackAllocator<U8> m_alloc;
+	GenericMemoryPoolAllocator<U8> m_alloc;
 
 	ANKI_USE_RESULT Error check() const;
 };
@@ -100,13 +100,13 @@ class XmlDocument
 {
 public:
 	ANKI_USE_RESULT Error loadFile(
-		const CString& filename, StackAllocator<U8>& alloc);
+		const CString& filename, GenericMemoryPoolAllocator<U8> alloc);
 
 	ANKI_USE_RESULT Error getChildElement(const CString& name, XmlElement& out);
 
 private:
 	tinyxml2::XMLDocument m_doc;
-	StackAllocator<U8> m_alloc;
+	GenericMemoryPoolAllocator<U8> m_alloc;
 };
 
 } // end namespace anki

include/anki/resource/Animation.h

@@ -43,14 +43,14 @@ private:
 class AnimationChannel
 {
 public:
-	ResourceString m_name;
+	String m_name;
 
 	I32 m_boneIndex = -1; ///< For skeletal animations
 
-	ResourceDArray<Key<Vec3>> m_positions;
-	ResourceDArray<Key<Quat>> m_rotations;
-	ResourceDArray<Key<F32>> m_scales;
-	ResourceDArray<Key<F32>> m_cameraFovs;
+	DArray<Key<Vec3>> m_positions;
+	DArray<Key<Quat>> m_rotations;
+	DArray<Key<F32>> m_scales;
+	DArray<Key<F32>> m_cameraFovs;
 
 	void destroy(ResourceAllocator<U8>& alloc)
 	{
@@ -74,7 +74,7 @@ public:
 		const CString& filename, ResourceInitializer& init);
 
 	/// Get a vector of all animation channels
-	const ResourceDArray<AnimationChannel>& getChannels() const
+	const DArray<AnimationChannel>& getChannels() const
 	{
 		return m_channels;
 	}
@@ -103,7 +103,7 @@ public:
 
 private:
 	ResourceAllocator<U8> m_alloc;
-	ResourceDArray<AnimationChannel> m_channels;
+	DArray<AnimationChannel> m_channels;
 	F32 m_duration;
 	F32 m_startTime;
 	Bool8 m_repeat;

include/anki/resource/Image.h

@@ -13,7 +13,7 @@
 namespace anki {
 
 /// Image class.
-/// Used in Texture::load. Supported types: TGA and PNG
+/// Used in Texture::load. Supported types: TGA and an AnKi specific format.
 class Image
 {
 public:
@@ -53,10 +53,10 @@ public:
 		U32 m_width;
 		U32 m_height;
 		U32 m_mipLevel;
-		ResourceDArray<U8> m_data;
+		DArray<U8> m_data;
 	};
 
-	Image(ResourceAllocator<U8>& alloc)
+	Image(GenericMemoryPoolAllocator<U8> alloc)
 	:	m_alloc(alloc)
 	{}
 
@@ -97,7 +97,7 @@ public:
 
 	const Surface& getSurface(U mipLevel, U layer) const;
 
-	ResourceAllocator<U8> getAllocator() const
+	GenericMemoryPoolAllocator<U8> getAllocator() const
 	{
 		return m_alloc;
 	}
@@ -110,9 +110,9 @@ public:
 		const CString& filename, U32 maxTextureSize = MAX_U32);
 
 private:
-	ResourceAllocator<U8> m_alloc;
+	GenericMemoryPoolAllocator<U8> m_alloc;
 	/// [mip][depthFace]
-	ResourceDArray<Surface> m_surfaces;
+	DArray<Surface> m_surfaces;
 	U8 m_mipLevels = 0;
 	U8 m_depth = 0;
 	DataCompression m_compression = DataCompression::NONE;

include/anki/resource/Mesh.h

@@ -107,7 +107,7 @@ protected:
 	};
 
 	ResourceAllocator<U8> m_alloc;
-	ResourceDArray<SubMesh> m_subMeshes;
+	DArray<SubMesh> m_subMeshes;
 	U32 m_indicesCount;
 	U32 m_vertsCount;
 	Obb m_obb;

include/anki/resource/MeshLoader.h

@@ -95,7 +95,7 @@ public:
 	~MeshLoader();
 
 	ANKI_USE_RESULT Error load(
-		BaseMemoryPool* pool,
+		GenericMemoryPoolAllocator<U8> alloc,
 		const CString& filename);
 
 	const Header& getHeader() const

include/anki/resource/Model.h

@@ -81,9 +81,9 @@ public:
 protected:
 	ResourceAllocator<U8> m_alloc;
 	/// Array [lod][pass]
-	ResourceDArray<CommandBufferHandle> m_vertJobs;
+	DArray<CommandBufferHandle> m_vertJobs;
 	Material* m_mtl = nullptr;
-	ResourceDArray<Mesh*> m_meshes; ///< One for each LOD
+	DArray<Mesh*> m_meshes; ///< One for each LOD
 
 	/// Create vertex descriptors using a material and a mesh
 	ANKI_USE_RESULT Error create(GrManager* gr);
@@ -126,7 +126,7 @@ public:
 		ResourceManager* resources);
 
 private:
-	ResourceDArray<MeshResourcePointerType> m_meshResources; ///< Geometries
+	DArray<MeshResourcePointerType> m_meshResources; ///< Geometries
 	MaterialResourcePointer m_mtlResource; ///< Material
 };
 
@@ -172,7 +172,7 @@ public:
 
 	~Model();
 
-	const ResourceDArray<ModelPatchBase*>& getModelPatches() const
+	const DArray<ModelPatchBase*>& getModelPatches() const
 	{
 		return m_modelPatches;
 	}
@@ -192,10 +192,10 @@ public:
 
 private:
 	ResourceManager* m_resources = nullptr;
-	ResourceDArray<ModelPatchBase*> m_modelPatches;
+	DArray<ModelPatchBase*> m_modelPatches;
 	Obb m_visibilityShape;
 	SkeletonResourcePointer m_skeleton;
-	ResourceDArray<AnimationResourcePointer> m_animations;
+	DArray<AnimationResourcePointer> m_animations;
 	PhysicsCollisionShape* m_physicsShape = nullptr;
 };
 

include/anki/resource/Script.h

@@ -31,7 +31,7 @@ public:
 	}
 
 private:
-	ResourceString m_source;
+	String m_source;
 	ResourceAllocator<char> m_alloc;
 };
 /// @}

include/anki/resource/Skeleton.h

@@ -21,7 +21,7 @@ public:
 
 	~Bone() = default;
 
-	const ResourceString& getName() const
+	const String& getName() const
 	{
 		return m_name;
 	}
@@ -40,7 +40,7 @@ public:
 	/// @}
 
 private:
-	ResourceString m_name; ///< The name of the bone
+	String m_name; ///< The name of the bone
 	static const U32 MAX_CHILDS_PER_BONE = 4; ///< Please dont change this
 
 	// see the class notes
@@ -75,7 +75,7 @@ public:
 
 	/// @name Accessors
 	/// @{
-	const ResourceDArray<Bone>& getBones() const
+	const DArray<Bone>& getBones() const
 	{
 		return m_bones;
 	}
@@ -83,7 +83,7 @@ public:
 
 private:
 	ResourceAllocator<U8> m_alloc;
-	ResourceDArray<Bone> m_bones;
+	DArray<Bone> m_bones;
 };
 
 } // end namespace anki

include/anki/scene/Common.h

@@ -26,16 +26,6 @@ using SceneAllocator = ChainAllocator<T>;
 template<typename T>
 using SceneFrameAllocator = StackAllocator<T>;
 
-/// Scene string
-using SceneString = StringBase<SceneAllocator<char>>;
-
-/// Scene array
-template<typename T>
-using SceneDArray = DArray<T>;
-
-template<typename T>
-using SceneFrameDArrayAuto = DArrayAuto<T, SceneFrameAllocator<T>>;
-
 /// Scene dictionary
 template<typename T>
 using SceneDictionary = 

include/anki/scene/ModelNode.h

@@ -41,7 +41,7 @@ public:
 private:
 	Obb m_obb; ///< In world space
 	const ModelPatchBase* m_modelPatch; ///< The resource
-	SceneDArray<ObbSpatialComponent*> m_spatials;
+	DArray<ObbSpatialComponent*> m_spatials;
 
 	ANKI_USE_RESULT Error updateInstanceSpatials(
 		const MoveComponent* instanceMoves[], 
@@ -76,8 +76,8 @@ public:
 
 private:
 	ModelResourcePointer m_model; ///< The resource
-	SceneDArray<ModelPatchNode*> m_modelPatches;
-	SceneDArray<Transform> m_transforms; ///< Cache the transforms of instances
+	DArray<ModelPatchNode*> m_modelPatches;
+	DArray<Transform> m_transforms; ///< Cache the transforms of instances
 	Timestamp m_transformsTimestamp;
 	PhysicsBody* m_body = nullptr;
 	BodyComponent* m_bodyComp = nullptr;

include/anki/scene/ParticleEmitter.h

@@ -178,10 +178,10 @@ private:
 	};
 
 	ParticleEmitterResourcePointer m_particleEmitterResource;
-	SceneDArray<ParticleBase*> m_particles;
+	DArray<ParticleBase*> m_particles;
 	F32 m_timeLeftForNextEmission = 0.0;
 	Obb m_obb;
-	SceneDArray<Transform> m_transforms; ///< InstanceTransforms
+	DArray<Transform> m_transforms; ///< InstanceTransforms
 	Timestamp m_transformsTimestamp = 0;
 
 	// Opt: We dont have to make extra calculations if the ParticleEmitter's

include/anki/scene/RenderComponent.h

@@ -222,7 +222,7 @@ public:
 class RenderComponent: public SceneComponent
 {
 public:
-	typedef SceneDArray<RenderComponentVariable*> Variables;
+	using Variables = DArray<RenderComponentVariable*>;
 
 	static Bool classof(const SceneComponent& c)
 	{

include/anki/scene/SceneNode.h

@@ -178,9 +178,9 @@ protected:
 
 private:
 	SceneGraph* m_scene = nullptr;
-	SceneDArray<SceneComponent*> m_components;
+	DArray<SceneComponent*> m_components;
 	U8 m_componentsCount = 0;
-	SceneString m_name; ///< A unique name
+	String m_name; ///< A unique name
 	Bool8 m_forDeletion = false;
 };
 /// @}

include/anki/util/Allocator.h

@@ -77,6 +77,15 @@ public:
 		*this = b;
 	}
 
+	/// Copy constructor, uses another type of allocator
+	template<typename Y, typename YPool>
+	GenericPoolAllocator(const GenericPoolAllocator<Y, YPool>& b)
+	{
+		auto balloc = b;
+		m_pool = &balloc.getMemoryPool();
+		m_pool->getRefcount().fetchAdd(1);
+	}
+
 	/// Constuctor that creates a pool
 	template<typename... TArgs>
 	explicit GenericPoolAllocator(

include/anki/util/File.h

@@ -96,8 +96,8 @@ public:
 
 	/// Read all the contents of a text file
 	/// If the file is not rewined it will probably fail
-	template<typename TAlloc>
-	ANKI_USE_RESULT Error readAllText(TAlloc alloc, String& out);
+	ANKI_USE_RESULT Error readAllText(
+		GenericMemoryPoolAllocator<U8> alloc, String& out);
 
 	/// Read 32bit unsigned integer. Set the endianness if the file's 
 	/// endianness is different from the machine's
@@ -167,30 +167,6 @@ private:
 		m_size = 0;
 	}
 };
-
-//==============================================================================
-template<typename TAlloc>
-inline Error File::readAllText(TAlloc alloc, String& out)
-{
-	Error err = ErrorCode::NONE;
-	PtrSize size = getSize();
-
-	if(size != 0)
-	{
-		err = out.create(alloc, '?', size);
-
-		if(!err)
-		{
-			err = read(&out[0], size);
-		}
-	}
-	else
-	{
-		err = ErrorCode::FUNCTION_FAILED;
-	}
-	
-	return err;
-}
 /// @}
 
 } // end namespace anki

include/anki/util/Filesystem.h

@@ -16,11 +16,9 @@ namespace anki {
 /// Return true if a file exists
 Bool fileExists(const CString& filename);
 
-/// Get file extension
-/// @param[in] filename The file to open
-/// @return nullptr on failure and if the dot is the last character
+/// Get file extension.
 ANKI_USE_RESULT Error getFileExtension(
-	const CString& filename, HeapAllocator<U8>& alloc, String& out);
+	const CString& filename, GenericMemoryPoolAllocator<U8> alloc, String& out);
 
 /// Return true if directory exists?
 Bool directoryExists(const CString& dir);
@@ -35,7 +33,8 @@ ANKI_USE_RESULT Error createDirectory(const CString& dir);
 /// Write the home directory to @a buff. The @a buffSize is the size of the 
 /// @a buff. If the @buffSize is not enough the function will throw 
 /// an exception.
-ANKI_USE_RESULT Error getHomeDirectory(HeapAllocator<U8>& alloc, String& out);
+ANKI_USE_RESULT Error getHomeDirectory(
+	GenericMemoryPoolAllocator<U8> alloc, String& out);
 
 /// @}
 

include/anki/util/String.inl.h

@@ -7,7 +7,7 @@ namespace anki {
 
 //==============================================================================
 template<typename TAllocator>
-Error String::create(TAllocator alloc, const CStringType& cstr)
+inline Error String::create(TAllocator alloc, const CStringType& cstr)
 {
 	Error err = ErrorCode::NONE;
 	
@@ -28,7 +28,8 @@ Error String::create(TAllocator alloc, const CStringType& cstr)
 
 //==============================================================================
 template<typename TAllocator>
-Error String::create(TAllocator alloc, ConstIterator first, ConstIterator last)
+inline Error String::create(
+	TAllocator alloc, ConstIterator first, ConstIterator last)
 {
 	ANKI_ASSERT(first != 0 && last != 0);
 	auto length = last - first;
@@ -45,7 +46,7 @@ Error String::create(TAllocator alloc, ConstIterator first, ConstIterator last)
 
 //==============================================================================
 template<typename TAllocator>
-Error String::create(TAllocator alloc, Char c, PtrSize length)
+inline Error String::create(TAllocator alloc, Char c, PtrSize length)
 {
 	ANKI_ASSERT(c != '\0');
 	Error err = m_data.create(alloc, length + 1);
@@ -61,7 +62,8 @@ Error String::create(TAllocator alloc, Char c, PtrSize length)
 
 //==============================================================================
 template<typename TAllocator>
-Error String::appendInternal(TAllocator alloc, const Char* str, PtrSize strSize)
+inline Error String::appendInternal(
+	TAllocator alloc, const Char* str, PtrSize strSize)
 {
 	ANKI_ASSERT(str != nullptr);
 	ANKI_ASSERT(strSize > 1);
@@ -95,7 +97,7 @@ Error String::appendInternal(TAllocator alloc, const Char* str, PtrSize strSize)
 
 //==============================================================================
 template<typename TAllocator>
-Error String::sprintf(TAllocator alloc, CString fmt, ...)
+inline Error String::sprintf(TAllocator alloc, CString fmt, ...)
 {
 	Error err = ErrorCode::NONE;
 	Array<Char, 512> buffer;
@@ -136,7 +138,7 @@ Error String::sprintf(TAllocator alloc, CString fmt, ...)
 
 //==============================================================================
 template<typename TAllocator, typename TNumber>
-Error String::toString(TAllocator alloc, TNumber number)
+inline Error String::toString(TAllocator alloc, TNumber number)
 {
 	Error err = ErrorCode::NONE;
 

include/anki/util/StringList.inl.h

@@ -10,7 +10,7 @@ namespace anki {
 
 //==============================================================================
 template<typename TAllocator>
-void StringList::destroy(TAllocator alloc)
+inline void StringList::destroy(TAllocator alloc)
 {
 	auto it = Base::getBegin();
 	auto endit = Base::getEnd();
@@ -24,7 +24,7 @@ void StringList::destroy(TAllocator alloc)
 
 //==============================================================================
 template<typename TAllocator>
-Error StringList::join(
+inline Error StringList::join(
 	TAllocator alloc,
 	const CString& separator,
 	String& out) const
@@ -71,26 +71,9 @@ Error StringList::join(
 	return err;
 }
 
-//==============================================================================
-I StringList::getIndexOf(const CString& value) const
-{
-	U pos = 0;
-
-	for(auto it = Base::getBegin(); it != Base::getEnd(); ++it)
-	{
-		if(*it == value)
-		{
-			break;
-		}
-		++ pos;
-	}
-
-	return (pos == Base::getSize()) ? -1 : pos;
-}
-
 //==============================================================================
 template<typename TAllocator>
-Error StringList::splitString(
+inline Error StringList::splitString(
 	TAllocator alloc,
 	const CString& s, 
 	const Char separator)
@@ -153,29 +136,9 @@ Error StringList::splitString(
 	return err;
 }
 
-//==============================================================================
-void StringList::sortAll(const Sort method)
-{
-	if(method == Sort::ASCENDING)
-	{
-		Base::sort([](const String& a, const String& b)
-		{
-			return a < b;
-		});
-	}
-	else
-	{
-		ANKI_ASSERT(method == Sort::DESCENDING);
-		Base::sort([](const String& a, const String& b)
-		{
-			return a < b;
-		});
-	}
-}
-
 //==============================================================================
 template<typename TAllocator, typename... TArgs>
-Error StringList::pushBackSprintf(
+inline Error StringList::pushBackSprintf(
 	TAllocator alloc, const TArgs&... args)
 {
 	String str;

src/core/App.cpp

@@ -295,8 +295,7 @@ Error App::initDirs()
 {
 #if ANKI_OS != ANKI_OS_ANDROID
 	// Settings path
-	String home;
-	String::ScopeDestroyer homed(&home, m_heapAlloc);
+	StringAuto home(m_heapAlloc);
 	ANKI_CHECK(getHomeDirectory(m_heapAlloc, home));
 
 	ANKI_CHECK(m_settingsDir.sprintf(m_heapAlloc, "%s/.anki", &home[0]));

src/misc/Xml.cpp

@@ -101,7 +101,7 @@ Error XmlElement::getFloats(DArrayAuto<F64>& out) const
 		}
 	}
 
-	StringListBase<StackAllocator<char>> list;
+	StringList list;
 	if(!err)
 	{
 		err = list.splitString(m_alloc, txt, ' ');
@@ -303,7 +303,8 @@ Error XmlElement::getSiblingElementsCount(U32& out) const
 //==============================================================================
 
 //==============================================================================
-Error XmlDocument::loadFile(const CString& filename, StackAllocator<U8>& alloc)
+Error XmlDocument::loadFile(const CString& filename, 
+	GenericMemoryPoolAllocator<U8> alloc)
 {
 	Error err = ErrorCode::NONE;
 
@@ -315,9 +316,9 @@ Error XmlDocument::loadFile(const CString& filename, StackAllocator<U8>& alloc)
 	}
 
 	m_alloc = alloc;
-	StringBase<StackAllocator<char>> text;
+	String text;
 	
-	err = file.readAllText(StackAllocator<char>(m_alloc), text);
+	err = file.readAllText(m_alloc, text);
 	if(err)
 	{
 		return err;

src/renderer/Hdr.cpp

@@ -95,44 +95,37 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	const char* SHADER_FILENAME = 
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
-	err = pps.sprintf(getAllocator(),
+	StringAuto pps(getAllocator());
+	ANKI_CHECK(pps.sprintf(
 		"#define HPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
 		m_blurringDist, m_height, 
-		static_cast<U>(initializer.get("pps.hdr.samples")));
-	if(err) return err;
+		static_cast<U>(initializer.get("pps.hdr.samples"))));
 
-	err = m_hblurFrag.loadToCache(&getResourceManager(),
-		SHADER_FILENAME, pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_hblurFrag.loadToCache(&getResourceManager(),
+		SHADER_FILENAME, pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_hblurFrag->getGrShader(), m_hblurPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_hblurFrag->getGrShader(), m_hblurPpline));
 
 	pps.destroy(getAllocator());
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define VPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
 		m_blurringDist, m_width, 
-		static_cast<U>(initializer.get("pps.hdr.samples")));
-	if(err) return err;
+		static_cast<U>(initializer.get("pps.hdr.samples"))));
 
-	err = m_vblurFrag.loadToCache(&getResourceManager(),
-		SHADER_FILENAME, pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_vblurFrag.loadToCache(&getResourceManager(),
+		SHADER_FILENAME, pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_vblurFrag->getGrShader(), m_vblurPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_vblurFrag->getGrShader(), m_vblurPpline));
 
 	// Set timestamps
 	m_parameterUpdateTimestamp = getGlobalTimestamp();
@@ -144,7 +137,6 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 //==============================================================================
 Error Hdr::init(const ConfigSet& initializer)
 {
-
 	Error err = initInternal(initializer);
 
 	if(err)

src/renderer/Is.cpp

@@ -174,11 +174,9 @@ Error Is::initInternal(const ConfigSet& config)
 	//
 	// Load the programs
 	//
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
-	err = pps.sprintf(
-		getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"\n#define TILES_X_COUNT %u\n"
 		"#define TILES_Y_COUNT %u\n"
 		"#define TILES_COUNT %u\n" 
@@ -202,57 +200,32 @@ Error Is::initInternal(const ConfigSet& config)
 		m_maxLightIds,
 		m_groundLightEnabled,
 		TILES_BLOCK_BINDING,
-		m_sm.getPoissonEnabled());
-	if(err) return err;
+		m_sm.getPoissonEnabled()));
 
 	// point light
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGrManager()); // Job for initialization
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(cmdBuff.create(&getGrManager())); // Job for initialization
 
-	err = m_lightVert.loadToCache(&getResourceManager(),
-		"shaders/IsLp.vert.glsl", pps.toCString(), "r_");
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_lightVert.loadToCache(&getResourceManager(),
+		"shaders/IsLp.vert.glsl", pps.toCString(), "r_"));
 
-	err = m_lightFrag.loadToCache(&getResourceManager(),
-		"shaders/IsLp.frag.glsl", pps.toCString(), "r_");
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_lightFrag.loadToCache(&getResourceManager(),
+		"shaders/IsLp.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_lightPpline.create(cmdBuff, 
-		{m_lightVert->getGrShader(), m_lightFrag->getGrShader()});
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_lightPpline.create(cmdBuff, 
+		{m_lightVert->getGrShader(), m_lightFrag->getGrShader()}));
 
 	//
 	// Create framebuffer
 	//
 
-	err = m_r->createRenderTarget(
-		m_r->getWidth(), m_r->getHeight(), GL_RGB8, 1, m_rt);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_r->createRenderTarget(
+		m_r->getWidth(), m_r->getHeight(), GL_RGB8, 1, m_rt));
 
 	FramebufferHandle::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	err = m_fb.create(cmdBuff, fbInit);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_fb.create(cmdBuff, fbInit));
 
 	//
 	// Init the quad
@@ -260,52 +233,33 @@ Error Is::initInternal(const ConfigSet& config)
 	static const F32 quadVertCoords[][2] = 
 		{{1.0, 1.0}, {0.0, 1.0}, {1.0, 0.0}, {0.0, 0.0}};
 
-	err = m_quadPositionsVertBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
-		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_quadPositionsVertBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0));
 
 	//
 	// Create UBOs
 	//
-	err = m_commonBuffer.create(cmdBuff, GL_UNIFORM_BUFFER, nullptr,
-		sizeof(shader::CommonUniforms), GL_DYNAMIC_STORAGE_BIT);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_commonBuffer.create(cmdBuff, GL_UNIFORM_BUFFER, nullptr,
+		sizeof(shader::CommonUniforms), GL_DYNAMIC_STORAGE_BIT));
 
 	for(U i = 0; i < MAX_FRAMES; ++i)
 	{
 		// Lights
-		err = m_lightsBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER, 
+		ANKI_CHECK(m_lightsBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER, 
 			nullptr, calcLightsBufferSize(), 
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 
 		// Tiles
-		err = m_tilesBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER,
+		ANKI_CHECK(m_tilesBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER,
 			nullptr, m_r->getTilesCountXY() * sizeof(shader::Tile),
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 
 		// Index
-		err = m_lightIdsBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER,
+		ANKI_CHECK(m_lightIdsBuffers[i].create(cmdBuff, 
+			GL_SHADER_STORAGE_BUFFER,
 			nullptr, (m_maxPointLights * m_maxSpotLights * m_maxSpotTexLights)
 			* sizeof(U32),
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 	}
 
 	// Flush
@@ -388,11 +342,7 @@ Error Is::lightPass(CommandBufferHandle& cmdBuff)
 	//
 	// Do shadows pass
 	//
-	err = m_sm.run(&shadowCasters[0], visibleSpotTexLightsCount, cmdBuff);
-	if(ANKI_UNLIKELY(err)) 
-	{
-		return err;
-	}
+	ANKI_CHECK(m_sm.run(&shadowCasters[0], visibleSpotTexLightsCount, cmdBuff));
 
 	//
 	// Write the lights and tiles UBOs
@@ -459,22 +409,14 @@ Error Is::lightPass(CommandBufferHandle& cmdBuff)
 	setState(cmdBuff);
 
 	// Sync
-	err = threadPool.waitForAllThreadsToFinish();
-	if(ANKI_UNLIKELY(err)) 
-	{
-		return err;
-	}
+	ANKI_CHECK(threadPool.waitForAllThreadsToFinish());
 
 	//
 	// Setup uniforms
 	//
 
 	// shader prog
-	err = updateCommonBlock(cmdBuff);
-	if(ANKI_UNLIKELY(err)) 
-	{
-		return err;
-	}
+	ANKI_CHECK(updateCommonBlock(cmdBuff));
 
 	m_commonBuffer.bindShaderBuffer(cmdBuff, COMMON_UNIFORMS_BLOCK_BINDING);
 

src/renderer/Lf.cpp

@@ -52,8 +52,6 @@ Error Lf::init(const ConfigSet& config)
 Error Lf::initPseudo(const ConfigSet& config, 
 	CommandBufferHandle& cmdBuff)
 {
-	Error err = ErrorCode::NONE;
-
 	m_maxSpritesPerFlare = config.get("pps.lf.maxSpritesPerFlare");
 	m_maxFlares = config.get("pps.lf.maxFlares");
 
@@ -64,68 +62,44 @@ Error Lf::initPseudo(const ConfigSet& config,
 	}
 
 	// Load program 1
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
-	err = pps.sprintf(getAllocator(), 
+	ANKI_CHECK(pps.sprintf(
 		"#define TEX_DIMENSIONS vec2(%u.0, %u.0)\n", 
 		m_r->getPps().getHdr()._getWidth(),
-		m_r->getPps().getHdr()._getHeight());
-	if(err) return err;
+		m_r->getPps().getHdr()._getHeight()));
 
-	err = m_pseudoFrag.loadToCache(&getResourceManager(), 
-		"shaders/PpsLfPseudoPass.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_pseudoFrag.loadToCache(&getResourceManager(), 
+		"shaders/PpsLfPseudoPass.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_pseudoFrag->getGrShader(), m_pseudoPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_pseudoFrag->getGrShader(), m_pseudoPpline));
 
 	// Textures
-	err = m_lensDirtTex.load(
-		"engine_data/lens_dirt.ankitex", &getResourceManager());
-	if(err) return err;
+	ANKI_CHECK(m_lensDirtTex.load(
+		"engine_data/lens_dirt.ankitex", &getResourceManager()));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Lf::initSprite(const ConfigSet& config, 
 	CommandBufferHandle& cmdBuff)
 {
-	Error err = ErrorCode::NONE;
-
 	// Load program + ppline
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
-	err = pps.sprintf(getAllocator(), "#define MAX_SPRITES %u\n",
-		m_maxSpritesPerFlare);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(pps.sprintf("#define MAX_SPRITES %u\n",
+		m_maxSpritesPerFlare));
 
-	err = m_realVert.loadToCache(&getResourceManager(), 
-		"shaders/PpsLfSpritePass.vert.glsl", pps.toCString(), "r_");
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_realVert.loadToCache(&getResourceManager(), 
+		"shaders/PpsLfSpritePass.vert.glsl", pps.toCString(), "r_"));
 
-	err = m_realFrag.loadToCache(&getResourceManager(), 
-		"shaders/PpsLfSpritePass.frag.glsl", pps.toCString(), "r_");
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_realFrag.loadToCache(&getResourceManager(), 
+		"shaders/PpsLfSpritePass.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_realPpline.create(cmdBuff,
-		{m_realVert->getGrShader(), m_realFrag->getGrShader()});
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_realPpline.create(cmdBuff,
+		{m_realVert->getGrShader(), m_realFrag->getGrShader()}));
 
 	// Create buffer
 	PtrSize uboAlignment = 
@@ -136,16 +110,12 @@ Error Lf::initSprite(const ConfigSet& config,
 
 	for(U i = 0; i < m_flareDataBuff.getSize(); ++i)
 	{
-		err = m_flareDataBuff[i].create(
+		ANKI_CHECK(m_flareDataBuff[i].create(
 			cmdBuff, GL_UNIFORM_BUFFER, nullptr, blockSize, 
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/renderer/Pps.cpp

@@ -56,10 +56,9 @@ Error Pps::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_fb.create(cmdBuff, fbInit));
 
 	// SProg
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define SSAO_ENABLED %u\n"
 		"#define HDR_ENABLED %u\n"
 		"#define SHARPEN_ENABLED %u\n"

src/renderer/RenderingPass.cpp

@@ -47,12 +47,10 @@ Error BlurringRenderingPass::initBlurring(
 	CommandBufferHandle cmdb;
 	ANKI_CHECK(cmdb.create(&gl));
 
-	Array<String, 2> pps;
-	String::ScopeDestroyer ppsd0(&pps[0], getAllocator());
-	String::ScopeDestroyer ppsd1(&pps[1], getAllocator());
+	Array<StringAuto, 2> pps = {{getAllocator(), getAllocator()}};
 
 	ANKI_CHECK(
-		pps[1].sprintf(getAllocator(),
+		pps[1].sprintf(
 		"#define HPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
@@ -61,7 +59,7 @@ Error BlurringRenderingPass::initBlurring(
 		blurringDistance, height, samples));
 
 	ANKI_CHECK(
-		pps[0].sprintf(getAllocator(),
+		pps[0].sprintf(
 		"#define VPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"

src/renderer/Ssao.cpp

@@ -161,93 +161,77 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	// Kernel
 	//
-	String kernelStr;
-	String::ScopeDestroyer kernelStrd(&kernelStr, getAllocator());
+	StringAuto kernelStr(getAllocator());
 	Array<Vec3, KERNEL_SIZE> kernel;
 
 	genKernel(kernel.begin(), kernel.end());
-	err = kernelStr.create(getAllocator(), "vec3[](");
+	err = kernelStr.create("vec3[](");
 	if(err) return err;
 	for(U i = 0; i < kernel.size(); i++)
 	{
-		String tmp;
-		String::ScopeDestroyer tmpd(&tmp, getAllocator());
+		StringAuto tmp(getAllocator());
 
-		err = tmp.sprintf(getAllocator(),
-			"vec3(%f, %f, %f) %s",
+		ANKI_CHECK(tmp.sprintf("vec3(%f, %f, %f) %s",
 			kernel[i].x(), kernel[i].y(), kernel[i].z(),
-			(i != kernel.size() - 1) ? ", " : ")");
-		if(err) return err;
+			(i != kernel.size() - 1) ? ", " : ")"));
 
-		err = kernelStr.append(getAllocator(), tmp);
-		if(err) return err;
+		ANKI_CHECK(kernelStr.append(tmp));
 	}
 
 	//
 	// Shaders
 	//
-	err = m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER, 
-		nullptr, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
-	if(err) return err;
+	ANKI_CHECK(m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER, 
+		nullptr, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT));
 
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
 	// main pass prog
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define NOISE_MAP_SIZE %u\n"
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n"
 		"#define KERNEL_SIZE %u\n"
 		"#define KERNEL_ARRAY %s\n",
-		NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]);
-	if(err) return err;
+		NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]));
 
-	err = m_ssaoFrag.loadToCache(&getResourceManager(),
-		"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_ssaoFrag.loadToCache(&getResourceManager(),
+		"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_ssaoFrag->getGrShader(), m_ssaoPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_ssaoFrag->getGrShader(), m_ssaoPpline));
 
 	// blurring progs
 	const char* SHADER_FILENAME = 
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
 	pps.destroy(getAllocator());
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define HPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES 7\n", 
-		m_height);
-	if(err) return err;
+		m_height));
 
-	err = m_hblurFrag.loadToCache(&getResourceManager(),
-		SHADER_FILENAME, pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_hblurFrag.loadToCache(&getResourceManager(),
+		SHADER_FILENAME, pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_hblurFrag->getGrShader(), m_hblurPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_hblurFrag->getGrShader(), m_hblurPpline));
 
 	pps.destroy(getAllocator());
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define VPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES 7\n", 
-		m_width);
-	if(err) return err;
+		m_width));
 
-	err = m_vblurFrag.loadToCache(&getResourceManager(),
-		SHADER_FILENAME, pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_vblurFrag.loadToCache(&getResourceManager(),
+		SHADER_FILENAME, pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_vblurFrag->getGrShader(), m_vblurPpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_vblurFrag->getGrShader(), m_vblurPpline));
 
 	cmdb.flush();
 

src/renderer/Sslr.cpp

@@ -32,76 +32,42 @@ Error Sslr::init(const ConfigSet& config)
 	alignRoundUp(16, m_height);
 
 	// Programs
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n",
-		m_width, m_height);
-	if(err)
-	{
-		return err;
-	}
+		m_width, m_height));
 
-	err = m_reflectionFrag.loadToCache(&getResourceManager(),
-		"shaders/PpsSslr.frag.glsl", pps.toCString(), "r_");
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_reflectionFrag.loadToCache(&getResourceManager(),
+		"shaders/PpsSslr.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(
-		m_reflectionFrag->getGrShader(), m_reflectionPpline);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_reflectionFrag->getGrShader(), m_reflectionPpline));
 
 	// Sampler
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGrManager());
-	if(err)
-	{
-		return err;
-	}
-	err = m_depthMapSampler.create(cmdBuff);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
+	ANKI_CHECK(m_depthMapSampler.create(cmdBuff));
 	m_depthMapSampler.setFilter(cmdBuff, SamplerHandle::Filter::NEAREST);
 
 	// Blit
-	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
-	if(err)
-	{
-		return err;
-	}
-	err = m_r->createDrawQuadPipeline(m_blitFrag->getGrShader(), m_blitPpline);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(
+		m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager()));
+	ANKI_CHECK(
+		m_r->createDrawQuadPipeline(m_blitFrag->getGrShader(), m_blitPpline));
 
 	// Init FBOs and RTs and blurring
 	if(m_blurringIterationsCount > 0)
 	{
-		err = initBlurring(*m_r, m_width, m_height, 9, 0.0);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(initBlurring(*m_r, m_width, m_height, 9, 0.0));
 	}
 	else
 	{
 		Direction& dir = m_dirs[(U)DirectionEnum::VERTICAL];
 
-		err = m_r->createRenderTarget(m_width, m_height, GL_RGB8, 1, dir.m_rt);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(
+			m_r->createRenderTarget(m_width, m_height, GL_RGB8, 1, dir.m_rt));
 
 		// Set to bilinear because the blurring techniques take advantage of 
 		// that
@@ -111,11 +77,7 @@ Error Sslr::init(const ConfigSet& config)
 		FramebufferHandle::Initializer fbInit;
 		fbInit.m_colorAttachmentsCount = 1;
 		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
-		err = dir.m_fb.create(cmdBuff, fbInit);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(dir.m_fb.create(cmdBuff, fbInit));
 	}
 
 	cmdBuff.finish();

src/renderer/Tiler.cpp

@@ -83,11 +83,10 @@ Error Tiler::initInternal()
 	m_enableGpuTests = false;
 
 	// Load the program
-	String pps;
-	String::ScopeDestroyer ppsd(&pps, getAllocator());
+	StringAuto pps(getAllocator());
 
 	ANKI_CHECK(
-		pps.sprintf(getAllocator(),
+		pps.sprintf(
 		"#define TILES_X_COUNT %u\n"
 		"#define TILES_Y_COUNT %u\n"
 		"#define RENDERER_WIDTH %u\n"

src/resource/Image.cpp

@@ -23,8 +23,8 @@ static U8 tgaHeaderCompressed[12] = {0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
 //==============================================================================
 static ANKI_USE_RESULT Error loadUncompressedTga(
-	File& fs, U32& width, U32& height, U32& bpp, ResourceDArray<U8>& data,
-	ResourceAllocator<U8>& alloc)
+	File& fs, U32& width, U32& height, U32& bpp, DArray<U8>& data,
+	GenericMemoryPoolAllocator<U8>& alloc)
 {
 	U8 header6[6];
 
@@ -73,8 +73,8 @@ static ANKI_USE_RESULT Error loadUncompressedTga(
 
 //==============================================================================
 static ANKI_USE_RESULT Error loadCompressedTga(
-	File& fs, U32& width, U32& height, U32& bpp, ResourceDArray<U8>& data,
-	ResourceAllocator<U8>& alloc)
+	File& fs, U32& width, U32& height, U32& bpp, DArray<U8>& data,
+	GenericMemoryPoolAllocator<U8>& alloc)
 {
 	U8 header6[6];
 	Error err = fs.read(reinterpret_cast<char*>(&header6[0]), sizeof(header6));
@@ -186,8 +186,8 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 
 //==============================================================================
 static ANKI_USE_RESULT Error loadTga(const CString& filename, 
-	U32& width, U32& height, U32& bpp, ResourceDArray<U8>& data,
-	ResourceAllocator<U8>& alloc)
+	U32& width, U32& height, U32& bpp, DArray<U8>& data,
+	GenericMemoryPoolAllocator<U8>& alloc)
 {
 	File fs;
 	char myTgaHeader[12];
@@ -338,8 +338,8 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 	const CString& filename, 
 	U32 maxTextureSize,
 	Image::DataCompression& preferredCompression,
-	ResourceDArray<Image::Surface>& surfaces,
-	ResourceAllocator<U8>& alloc,
+	DArray<Image::Surface>& surfaces,
+	GenericMemoryPoolAllocator<U8>& alloc,
 	U8& depth, 
 	U8& mipLevels, 
 	Image::TextureType& textureType,
@@ -348,23 +348,15 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 	Error err = ErrorCode::NONE;
 	
 	File file;
-	err = file.open(filename, 
+	ANKI_CHECK(file.open(filename, 
 		File::OpenFlag::READ | File::OpenFlag::BINARY 
-		| File::OpenFlag::LITTLE_ENDIAN);
-	if(err)
-	{
-		return err;
-	}
+		| File::OpenFlag::LITTLE_ENDIAN));
 
 	//
 	// Read and check the header
 	//
 	AnkiTextureHeader header;
-	err = file.read(&header, sizeof(AnkiTextureHeader));
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(file.read(&header, sizeof(AnkiTextureHeader)));
 
 	if(std::memcmp(&header.m_magic[0], "ANKITEX1", 8) != 0)
 	{
@@ -500,21 +492,14 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 		}
 	}
 
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(err);
 
 	//
 	// It's time to read
 	//
 
 	// Allocate the surfaces 
-	err = surfaces.create(alloc, mipLevels * depth);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(surfaces.create(alloc, mipLevels * depth));
 
 	// Read all surfaces
 	U mipWidth = header.m_width;
@@ -575,8 +560,7 @@ Error Image::load(const CString& filename, U32 maxTextureSize)
 	Error err = ErrorCode::NONE;
 
 	// get the extension
-	String ext;
-	String::ScopeDestroyer extd(&ext, m_alloc);
+	StringAuto ext(m_alloc);
 	err = getFileExtension(filename, m_alloc, ext);
 	if(err)
 	{

src/resource/Material.cpp

@@ -92,7 +92,7 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 	Error err = ErrorCode::NONE;
 	MaterialVariableTemplate<T>* out = nullptr;
 
-	TempResourceDArrayAuto<F32> floats(talloc);
+	DArrayAuto<F32> floats(talloc);
 
 	// Get the float values
 	if(in.m_value.getSize() > 0)
@@ -538,7 +538,7 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 						continue;
 					}
 
-					TempResourceString src(rinit.m_tempAlloc);
+					StringAuto src(rinit.m_tempAlloc);
 					ANKI_CHECK(src.sprintf(
 						"%s\n"
 						"#define LOD %u\n"
@@ -548,7 +548,7 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 						&rinit.m_resources._getShadersPrependedSource()[0],
 						level, pid, tess, &loader.getProgramSource(shader)[0]));
 
-					TempResourceString filename(rinit.m_tempAlloc);
+					StringAuto filename(rinit.m_tempAlloc);
 
 					ANKI_CHECK(createProgramSourceToCache(src, filename));
 
@@ -575,7 +575,7 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 
 //==============================================================================
 Error Material::createProgramSourceToCache(
-	const TempResourceString& source, TempResourceString& out)
+	const StringAuto& source, StringAuto& out)
 {
 	Error err = ErrorCode::NONE;
 
@@ -583,7 +583,7 @@ Error Material::createProgramSourceToCache(
 
 	// Create the hash
 	U64 h = computeHash(&source[0], source.getLength());
-	TempResourceString prefix(alloc);
+	StringAuto prefix(alloc);
 
 	ANKI_CHECK(prefix.toString(h));
 

src/resource/MeshLoader.cpp

@@ -20,10 +20,10 @@ MeshLoader::~MeshLoader()
 
 //==============================================================================
 Error MeshLoader::load(
-	BaseMemoryPool* pool,
+	GenericMemoryPoolAllocator<U8> alloc,
 	const CString& filename)
 {
-	m_alloc = GenericPoolAllocator<U8, BaseMemoryPool>(pool);
+	m_alloc = alloc;
 	
 	Error err = loadInternal(filename);
 	if(err)

src/resource/Model.cpp

@@ -323,27 +323,15 @@ Error Model::load(const CString& filename, ResourceInitializer& init)
 		else if(type == "staticMesh")
 		{
 			CString filename;
-			if(err = valEl.getText(filename))
-			{
-				return err;
-			}
+			ANKI_CHECK(valEl.getText(filename));
 	
-			TempResourceString fixedFilename;
-			if(err = init.m_resources.fixResourceFilename(
-				filename, fixedFilename))
-			{
-				return err;
-			}
+			StringAuto fixedFilename(init.m_tempAlloc);
+			ANKI_CHECK(init.m_resources.fixResourceFilename(
+				filename, fixedFilename));
 
 			MeshLoader loader;
-			if(err = loader.load(
-				&init.m_tempAlloc.getMemoryPool(), fixedFilename.toCString()))
-			{
-				fixedFilename.destroy(init.m_tempAlloc);
-				return err;
-			}
-
-			fixedFilename.destroy(init.m_tempAlloc);
+			ANKI_CHECK(
+				loader.load(init.m_tempAlloc, fixedFilename.toCString()));
 
 			m_physicsShape = physics.newCollisionShape<PhysicsTriangleSoup>(
 				csInit, 

src/resource/ResourceManager.cpp

@@ -108,7 +108,7 @@ Error ResourceManager::fixResourceFilename(
 	Error err = ErrorCode::NONE;
 
 	// If the filename is in cache then dont append the data path
-	if(filename.find(m_cacheDir.toCString()) != TempResourceString::NPOS)
+	if(filename.find(m_cacheDir.toCString()) != String::NPOS)
 	{
 		err = out.create(filename);
 	}

src/scene/ModelNode.cpp

@@ -390,8 +390,7 @@ Error ModelNode::frameUpdate(F32, F32)
 	Error err = ErrorCode::NONE;
 
 	// Gather the move components of the instances
-	SceneFrameDArrayAuto<const MoveComponent*> instanceMoves(
-		getSceneFrameAllocator());
+	DArrayAuto<const MoveComponent*> instanceMoves(getSceneFrameAllocator());
 	U instanceMovesCount = 0;
 	Timestamp instancesTimestamp = 0;
 

src/scene/StaticGeometryNode.cpp

@@ -157,9 +157,9 @@ Error StaticGeometryNode::create(const CString& name, const CString& filename)
 		U i = 0;
 		for(const ModelPatchBase* patch : m_model->getModelPatches())
 		{
-			SceneString newname;
+			StringAuto newname(getSceneAllocator());
 			
-			err = newname.sprintf(getSceneAllocator(), "%s_%u", &name[0], i);
+			err = newname.sprintf("%s_%u", &name[0], i);
 			if(err)
 			{
 				break;
@@ -168,8 +168,6 @@ Error StaticGeometryNode::create(const CString& name, const CString& filename)
 			StaticGeometryPatchNode* node;
 			err = getSceneGraph().newSceneNode<StaticGeometryPatchNode>(
 				newname.toCString(), node, patch);
-			
-			newname.destroy(getSceneAllocator());
 
 			if(err)
 			{

src/util/File.cpp

@@ -660,4 +660,28 @@ File::OpenFlag File::getMachineEndianness()
 	}
 }
 
+//==============================================================================
+Error File::readAllText(
+	GenericMemoryPoolAllocator<U8> alloc, String& out)
+{
+	Error err = ErrorCode::NONE;
+	PtrSize size = getSize();
+
+	if(size != 0)
+	{
+		err = out.create(alloc, '?', size);
+
+		if(!err)
+		{
+			err = read(&out[0], size);
+		}
+	}
+	else
+	{
+		err = ErrorCode::FUNCTION_FAILED;
+	}
+	
+	return err;
+}
+
 } // end namespace anki

src/util/Filesystem.cpp

@@ -9,7 +9,7 @@ namespace anki {
 
 //==============================================================================
 Error getFileExtension(
-	const CString& filename, HeapAllocator<U8>& alloc, String& out)
+	const CString& filename, GenericMemoryPoolAllocator<U8> alloc, String& out)
 {
 	Error err = ErrorCode::NONE;
 	const char* pc = std::strrchr(&filename[0], '.');

src/util/FilesystemPosix.cpp

@@ -114,7 +114,7 @@ Error createDirectory(const CString& dir)
 }
 
 //==============================================================================
-Error getHomeDirectory(HeapAllocator<U8>& alloc, String& out)
+Error getHomeDirectory(GenericMemoryPoolAllocator<U8> alloc, String& out)
 {
 	const char* home = getenv("HOME");
 	if(home == nullptr)