diff --git a/doomsday/engine/api/dd_share.h b/doomsday/engine/api/dd_share.h index def17d9bab..00053c39fa 100644 --- a/doomsday/engine/api/dd_share.h +++ b/doomsday/engine/api/dd_share.h @@ -1275,121 +1275,121 @@ typedef struct { /**@}*/ /** - * @defgroup namespace Namespaces + * @defgroup scheme Schemes * @ingroup resource */ /** - * Material Namespaces + * Material Schemes */ /** - * @defgroup materialNamespaceNames Material Namespace Names - * @ingroup namespace - * @{ + * @defgroup materialSchemeNames Material Scheme Names + * @ingroup scheme */ -#define MN_SYSTEM_NAME "System" -#define MN_FLATS_NAME "Flats" -#define MN_TEXTURES_NAME "Textures" -#define MN_SPRITES_NAME "Sprites" -/**@}*/ +///@{ +#define MS_SYSTEM_NAME "System" +#define MS_FLATS_NAME "Flats" +#define MS_TEXTURES_NAME "Textures" +#define MS_SPRITES_NAME "Sprites" +///@} -typedef enum materialnamespaceid_e { - MN_ANY = -1, - MATERIALNAMESPACE_FIRST = 1000, - MN_SYSTEM = MATERIALNAMESPACE_FIRST, - MN_FLATS, - MN_TEXTURES, - MN_SPRITES, - MATERIALNAMESPACE_LAST = MN_SPRITES, - MN_INVALID /// Special value used to signify an invalid namespace identifier. -} materialnamespaceid_t; +typedef enum materialschemeid_e { + MS_ANY = -1, + MATERIALSCHEME_FIRST = 1000, + MS_SYSTEM = MATERIALSCHEME_FIRST, + MS_FLATS, + MS_TEXTURES, + MS_SPRITES, + MATERIALSCHEME_LAST = MS_SPRITES, + MS_INVALID /// Special value used to signify an invalid scheme identifier. +} materialschemeid_t; -#define MATERIALNAMESPACE_COUNT (MATERIALNAMESPACE_LAST - MATERIALNAMESPACE_FIRST + 1) +#define MATERIALSCHEME_COUNT (MATERIALSCHEME_LAST - MATERIALSCHEME_FIRST + 1) -/// @c true= val can be interpreted as a valid material namespace identifier. -#define VALID_MATERIALNAMESPACEID(val) ((val) >= MATERIALNAMESPACE_FIRST && (val) <= MATERIALNAMESPACE_LAST) +/// @c true= val can be interpreted as a valid material scheme identifier. +#define VALID_MATERIALSCHEMEID(val) ((val) >= MATERIALSCHEME_FIRST && (val) <= MATERIALSCHEME_LAST) /** - * Texture Namespaces + * Texture Schemes */ /** - * @defgroup textureNamespaceNames Texture Namespace Names - * @ingroup namespace + * @defgroup textureSchemeNames Texture Scheme Names + * @ingroup scheme */ ///@{ -#define TN_SYSTEM_NAME "System" -#define TN_FLATS_NAME "Flats" -#define TN_TEXTURES_NAME "Textures" -#define TN_SPRITES_NAME "Sprites" -#define TN_PATCHES_NAME "Patches" -#define TN_DETAILS_NAME "Details" -#define TN_REFLECTIONS_NAME "Reflections" -#define TN_MASKS_NAME "Masks" -#define TN_MODELSKINS_NAME "ModelSkins" -#define TN_MODELREFLECTIONSKINS_NAME "ModelReflectionSkins" -#define TN_LIGHTMAPS_NAME "Lightmaps" -#define TN_FLAREMAPS_NAME "Flaremaps" +#define TS_SYSTEM_NAME "System" +#define TS_FLATS_NAME "Flats" +#define TS_TEXTURES_NAME "Textures" +#define TS_SPRITES_NAME "Sprites" +#define TS_PATCHES_NAME "Patches" +#define TS_DETAILS_NAME "Details" +#define TS_REFLECTIONS_NAME "Reflections" +#define TS_MASKS_NAME "Masks" +#define TS_MODELSKINS_NAME "ModelSkins" +#define TS_MODELREFLECTIONSKINS_NAME "ModelReflectionSkins" +#define TS_LIGHTMAPS_NAME "Lightmaps" +#define TS_FLAREMAPS_NAME "Flaremaps" ///@} -/// Texture namespace identifiers. @ingroup namespace -typedef enum texturenamespaceid_e { - TN_ANY = -1, - TEXTURENAMESPACE_FIRST = 2000, - TN_SYSTEM = TEXTURENAMESPACE_FIRST, - TN_FLATS, - TN_TEXTURES, - TN_SPRITES, - TN_PATCHES, - TN_DETAILS, - TN_REFLECTIONS, - TN_MASKS, - TN_MODELSKINS, - TN_MODELREFLECTIONSKINS, - TN_LIGHTMAPS, - TN_FLAREMAPS, - TEXTURENAMESPACE_LAST = TN_FLAREMAPS, - TN_INVALID /// Special value used to signify an invalid namespace identifier. -} texturenamespaceid_t; - -#define TEXTURENAMESPACE_COUNT (TEXTURENAMESPACE_LAST - TEXTURENAMESPACE_FIRST + 1) - -/// @c true= val can be interpreted as a valid texture namespace identifier. -#define VALID_TEXTURENAMESPACEID(val) ((val) >= TEXTURENAMESPACE_FIRST && (val) <= TEXTURENAMESPACE_LAST) +/// Texture scheme identifiers. @ingroup scheme +typedef enum textureschemeid_e { + TS_ANY = -1, + TEXTURESCHEME_FIRST = 2000, + TS_SYSTEM = TEXTURESCHEME_FIRST, + TS_FLATS, + TS_TEXTURES, + TS_SPRITES, + TS_PATCHES, + TS_DETAILS, + TS_REFLECTIONS, + TS_MASKS, + TS_MODELSKINS, + TS_MODELREFLECTIONSKINS, + TS_LIGHTMAPS, + TS_FLAREMAPS, + TEXTURESCHEME_LAST = TS_FLAREMAPS, + TS_INVALID /// Special value used to signify an invalid scheme identifier. +} textureschemeid_t; + +#define TEXTURESCHEME_COUNT (TEXTURESCHEME_LAST - TEXTURESCHEME_FIRST + 1) + +/// @c true= val can be interpreted as a valid texture scheme identifier. +#define VALID_TEXTURESCHEMEID(val) ((val) >= TEXTURESCHEME_FIRST && (val) <= TEXTURESCHEME_LAST) /** - * Font Namespaces + * Font Schemes */ /** - * @defgroup fontNamespaceNames Font Namespace Names - * @ingroup namespace - * @{ + * @defgroup fontSchemeNames Font Scheme Names + * @ingroup scheme */ +///@{ #define FN_SYSTEM_NAME "System" #define FN_GAME_NAME "Game" ///@} -/// Font namespace identifier. @ingroup namespace -typedef enum fontnamespaceid_e { - FN_ANY = -1, - FONTNAMESPACE_FIRST = 3000, - FN_SYSTEM = FONTNAMESPACE_FIRST, - FN_GAME, - FONTNAMESPACE_LAST = FN_GAME, - FN_INVALID ///< Special value used to signify an invalid namespace identifier. -} fontnamespaceid_t; +/// Font scheme identifier. @ingroup scheme +typedef enum fontschemeid_e { + FS_ANY = -1, + FONTSCHEME_FIRST = 3000, + FS_SYSTEM = FONTSCHEME_FIRST, + FS_GAME, + FONTSCHEME_LAST = FS_GAME, + FS_INVALID ///< Special value used to signify an invalid scheme identifier. +} fontschemeid_t; -#define FONTNAMESPACE_COUNT (FONTNAMESPACE_LAST - FONTNAMESPACE_FIRST + 1) +#define FONTSCHEME_COUNT (FONTSCHEME_LAST - FONTSCHEME_FIRST + 1) /** - * Determines whether @a val can be interpreted as a valid font namespace - * identifier. @ingroup namespace + * Determines whether @a val can be interpreted as a valid font scheme + * identifier. @ingroup scheme * @param val Integer value. * @return @c true or @c false. */ -#define VALID_FONTNAMESPACEID(val) ((val) >= FONTNAMESPACE_FIRST && (val) <= FONTNAMESPACE_LAST) +#define VALID_FONTSCHEMEID(val) ((val) >= FONTSCHEME_FIRST && (val) <= FONTSCHEME_LAST) /// Patch Info typedef struct { diff --git a/doomsday/engine/api/doomsday.def b/doomsday/engine/api/doomsday.def index 1068864dfe..ecea6ce42a 100644 --- a/doomsday/engine/api/doomsday.def +++ b/doomsday/engine/api/doomsday.def @@ -21,8 +21,8 @@ EXPORTS DD_GetVariable @43 NONAME DD_GetPlayer @44 NONAME DD_MaterialForTextureUniqueId @234 NONAME - DD_ParseTextureNamespace @502 NONAME - DD_ParseMaterialNamespace @503 NONAME + DD_ParseTextureSchemeName @502 NONAME + DD_ParseMaterialSchemeName @503 NONAME ; Base: Types. ; Animator. diff --git a/doomsday/engine/api/doomsday.h b/doomsday/engine/api/doomsday.h index a0fea97922..2f936cac14 100644 --- a/doomsday/engine/api/doomsday.h +++ b/doomsday/engine/api/doomsday.h @@ -192,10 +192,10 @@ boolean DD_GameInfo(GameInfo* info); ddplayer_t* DD_GetPlayer(int number); ///@} -/// @addtogroup namespace +/// @addtogroup scheme ///@{ -texturenamespaceid_t DD_ParseTextureNamespace(const char* str); -materialnamespaceid_t DD_ParseMaterialNamespace(const char* str); +textureschemeid_t DD_ParseTextureSchemeName(const char* str); +materialschemeid_t DD_ParseMaterialSchemeName(const char* str); ///@} /** @@ -203,7 +203,7 @@ materialnamespaceid_t DD_ParseMaterialNamespace(const char* str); * @ingroup resource */ ///@{ -materialid_t DD_MaterialForTextureUniqueId(texturenamespaceid_t texNamespaceId, int uniqueId); +materialid_t DD_MaterialForTextureUniqueId(textureschemeid_t texSchemeId, int uniqueId); ///@} /// @addtogroup defs diff --git a/doomsday/engine/api/resourceclass.h b/doomsday/engine/api/resourceclass.h index 5a96b0abe8..4de4f36d2e 100644 --- a/doomsday/engine/api/resourceclass.h +++ b/doomsday/engine/api/resourceclass.h @@ -76,8 +76,8 @@ namespace de typedef QList FileTypes; public: - ResourceClass(String _name, String _defaultNamespace) - : name_(_name), defaultNamespace_(_defaultNamespace) + ResourceClass(String _name, String _defaultScheme) + : name_(_name), defaultScheme_(_defaultScheme) {} virtual ~ResourceClass() { @@ -93,10 +93,11 @@ namespace de return name_; } - /// Return the symbolic name of the default namespace for this class of resource. - String const& defaultNamespace() const + /// Return the symbolic name of the default filesystem subspace scheme + /// for this class of resource. + String const& defaultScheme() const { - return defaultNamespace_; + return defaultScheme_; } /// Return the number of file types for this class of resource. @@ -132,8 +133,8 @@ namespace de /// Symbolic name for this class. String name_; - /// Symbolic name of the default namespace. - String defaultNamespace_; + /// Symbolic name of the default filesystem subspace scheme. + String defaultScheme_; /// Recognized file types (in order of importance, left to right). FileTypes fileTypes_; diff --git a/doomsday/engine/engine.pro b/doomsday/engine/engine.pro index 41e6b9987e..98e13290a1 100644 --- a/doomsday/engine/engine.pro +++ b/doomsday/engine/engine.pro @@ -470,7 +470,7 @@ SOURCES += \ src/filesys/filehandle.cpp \ src/filesys/fileid.cpp \ src/filesys/fs_main.cpp \ - src/filesys/fs_namespace.cpp \ + src/filesys/fs_scheme.cpp \ src/filesys/fs_util.cpp \ src/filesys/lumpindex.cpp \ src/filesys/metafile.cpp \ diff --git a/doomsday/engine/include/dd_main.h b/doomsday/engine/include/dd_main.h index 92fcdf4309..ff850646f1 100644 --- a/doomsday/engine/include/dd_main.h +++ b/doomsday/engine/include/dd_main.h @@ -199,17 +199,17 @@ de::ResourceClass& DD_ResourceClassByName(de::String name); #endif // __cplusplus -texturenamespaceid_t DD_ParseTextureNamespace(const char* str); +textureschemeid_t DD_ParseTextureSchemeName(const char* str); -materialnamespaceid_t DD_ParseMaterialNamespace(const char* str); +materialschemeid_t DD_ParseMaterialSchemeName(const char* str); -fontnamespaceid_t DD_ParseFontNamespace(const char* str); +fontschemeid_t DD_ParseFontSchemeName(const char* str); -/// @return Symbolic name of the material namespace associated with @a namespaceId. -const ddstring_t* DD_MaterialNamespaceNameForTextureNamespace(texturenamespaceid_t texNamespaceId); +/// @return Symbolic name of the material scheme associated with @a schemeId. +const ddstring_t* DD_MaterialSchemeNameForTextureScheme(textureschemeid_t schemeId); /// @return Unique identifier of the material associated with the identified @a uniqueId texture. -materialid_t DD_MaterialForTextureUniqueId(texturenamespaceid_t texNamespaceId, int uniqueId); +materialid_t DD_MaterialForTextureUniqueId(textureschemeid_t schemeId, int uniqueId); const char* value_Str(int val); diff --git a/doomsday/engine/include/filesys/fs_main.h b/doomsday/engine/include/filesys/fs_main.h index b3dbeda00e..bed7041f29 100644 --- a/doomsday/engine/include/filesys/fs_main.h +++ b/doomsday/engine/include/filesys/fs_main.h @@ -103,10 +103,12 @@ namespace de }; /** - * @todo The symbolic name of the namespace and the path mapping template - * (see applyPathMappings()) should be defined externally. -ds + * Scheme defines a file system subspace. + * + * @todo The symbolic name of the schme and the path mapping template + * (@ref mapPath()) should be defined externally. -ds */ - class Namespace + class Scheme { public: /// Symbolic names must be at least this number of characters. @@ -114,10 +116,10 @@ namespace de enum Flag { - /// Packages may include virtual file mappings to the namespace with a - /// root directory which matches the symbolic name of the namespace. + /// Packages may include virtual file mappings to the scheme with a + /// root directory which matches the symbolic name of the scheme. /// - /// @see applyPathMappings() + /// @see mapPath() MappedInPackages = 0x01 }; Q_DECLARE_FLAGS(Flags, Flag) @@ -129,30 +131,28 @@ namespace de typedef QList FoundNodes; public: - explicit Namespace(String symbolicName, Flags flags = 0); - ~Namespace(); + explicit Scheme(String symbolicName, Flags flags = 0); + ~Scheme(); - /// @return Symbolic name of this namespace (e.g., "Models"). + /// @return Symbolic name of this scheme (e.g., "Models"). String const& name() const; /** - * Rebuild this namespace by re-scanning for resources on all search - * paths and re-populating the internal database. + * Rebuild this scheme by re-scanning for resources on all search paths + * and re-populating the scheme's index. * * @note Any manually added resources will not be present after this. - * - * @todo Namespace population should be implemented externally. -ds */ void rebuild(); /** - * Clear this namespace back to it's "empty" state (i.e., no resources). + * Clear this scheme back to it's "empty" state (i.e., no resources). * The search path groups are unaffected. */ void clear(); /** - * Reset this namespace, returning it to an empty state and clearing any + * Reset this scheme, returning it to an empty state and clearing any * @ref ExtraPaths which have been registered since its construction. */ inline void reset() { @@ -161,17 +161,16 @@ namespace de } /** - * Manually add a resource to this namespace. Duplicates are pruned - * automatically. + * Manually add a resource to this scheme. Duplicates are pruned automatically. * * @param resourceNode Node which represents the resource. * - * @return @c true iff this namespace did not already contain the resource. + * @return @c true iff this scheme did not already contain the resource. */ bool add(PathTree::Node& resourceNode); /** - * Finds all resources in this namespace. + * Finds all resources in this scheme. * * @param name If not an empty string, only consider resources whose * name begins with this. Case insensitive. @@ -182,8 +181,8 @@ namespace de int findAll(String name, FoundNodes& found); /** - * Add a new search path to this namespace. Newer paths have priority - * over previously added paths. + * Add a new search path to this scheme. Newer paths have priority over + * previously added paths. * * @param path New unresolved search path to add. A copy is made. * @param group Group to add this path to. @ref PathGroup @@ -193,12 +192,12 @@ namespace de bool addSearchPath(SearchPath const& path, PathGroup group = DefaultPaths); /** - * Clear all search paths in all groups in this namespace. + * Clear all search paths in all groups in the scheme. */ void clearAllSearchPaths(); /** - * Clear search paths in @a group from this namespace. + * Clear search paths in @a group from the scheme. * * @param group Search path group to be cleared. */ @@ -210,10 +209,10 @@ namespace de SearchPaths const& searchPaths() const; /** - * Apply mapping for this namespace to the specified path. Mapping must - * be enabled (with @ref MappedInPackages) otherwise this does nothing. + * Apply mapping for this scheme to the specified path. Mapping must be + * enabled (with @ref MappedInPackages) otherwise this does nothing. * - * For example, given the namespace name "models": + * For example, given the scheme name "models": * * 
              *     "models/mymodel.dmd" => "$(App.DataPath)/$(GamePlugin.Name)/models/mymodel.dmd"
@@ -234,8 +233,8 @@ namespace de
             Instance* d;
         };
 
-        /// Namespaces within the file system.
-        typedef QMap Namespaces;
+        /// File system subspace schemes.
+        typedef QMap Schemes;
 
         /**
          * PathListItem represents a found path for find file search results.
@@ -278,35 +277,35 @@ namespace de
         void endStartup();
 
         /**
-         * @param name      Unique symbolic name of this namespace. Must be at least
-         *                  @c Namespace::min_name_length characters long.
-         * @param flags     @ref Namespace::Flag
+         * @param name      Unique symbolic name of the new scheme. Must be at least
+         *                  @c Scheme::min_name_length characters long.
+         * @param flags     @ref Scheme::Flag
          */
-        Namespace& createNamespace(String name, Namespace::Flags flags = 0);
+        Scheme& createScheme(String name, Scheme::Flags flags = 0);
 
         /**
-         * Lookup a Namespace by symbolic name.
+         * Lookup a Scheme by symbolic name.
          *
-         * @param name  Symbolic name of the namespace.
-         * @return  Namespace associated with @a name; otherwise @c 0 (not found).
+         * @param name  Symbolic name of the scheme.
+         * @return  Scheme associated with @a name; otherwise @c 0 (not found).
          */
-        Namespace* namespaceByName(String name);
+        Scheme* schemeByName(String name);
 
         /**
-         * Reset all the namespaces, returning them to an empty state and clearing
-         * any @ref ExtraPaths which have been registered since construction.
+         * Reset all the schemes, returning their indexes to an empty state and clearing
+         * any @ref ExtraPaths which have been registered since creation.
          */
-        inline void resetAllNamespaces()
+        inline void resetAllSchemes()
         {
-            Namespaces allNamespaces = namespaces();
-            DENG2_FOR_EACH(Namespaces, i, allNamespaces){ (*i)->reset(); }
+            Schemes allSchemes = schemes();
+            DENG2_FOR_EACH(Schemes, i, allSchemes){ (*i)->reset(); }
         }
 
-        /// Returns the namespaces for efficient traversal.
-        Namespaces const& namespaces();
+        /// Returns the schemes for efficient traversal.
+        Schemes const& schemes();
 
         /**
-         * Add a new path mapping from source to destination in the vfs.
+         * Add a new path mapping from source to destination.
          * @note Paths will be transformed into absolute paths if needed.
          */
         void addPathMapping(String source, String destination);
@@ -361,12 +360,12 @@ namespace de
          * Indexes @a file (which must have been opened with this file system) into
          * this file system and adds it to the list of loaded files.
          *
-         * @param file      The file to index. Assumed to have not yet been indexed!
+         * @param file  The file to index. Assumed to have not yet been indexed!
          */
         void index(File1& file);
 
         /**
-         * Removes a file from any lump indexes.
+         * Removes a file from any indexes.
          *
          * @param file  File to remove from the index.
          */
@@ -492,15 +491,15 @@ namespace de
          * Search the file system for a path to a file.
          *
          * @param search        The search term. If a scheme is specified, first check
-         *                      for a similarly named namespace with which to limit the
-         *                      search. If not found within the namespace then perform
-         *                      a wider search of the whole file system.
+         *                      for a similarly named Scheme with which to limit the
+         *                      search. If not found within the scheme then perform a
+         *                      wider search of the whole file system.
          * @param flags         @ref resourceLocationFlags
          * @param rclass        Class of resource being searched for. If no file is found
-         *                      which matches the search term and a non-null resource class
-         *                      is specified try alternative names for the file according
-         *                      to the list of known file extensions for each file type
-         *                      associated with this class of resource.
+         *                      which matches the search term and a non-null resource
+         *                      class is specified try alternative names for the file
+         *                      according to the list of known file extensions for each
+         *                      file type associated with this class of resource.
          *
          * @return  The found path.
          *
@@ -544,7 +543,7 @@ namespace de
         Instance* d;
     };
 
-    Q_DECLARE_OPERATORS_FOR_FLAGS(FS1::Namespace::Flags)
+    Q_DECLARE_OPERATORS_FOR_FLAGS(FS1::Scheme::Flags)
 
 } // namespace de
 
@@ -624,7 +623,7 @@ AutoStr* F_ComposePath(struct file1_s const* file);
 void F_SetCustom(struct file1_s* file, boolean yes);
 
 AutoStr* F_ComposeLumpPath2(struct file1_s* file, int lumpIdx, char delimiter);
-AutoStr* F_ComposeLumpPath(struct file1_s* file, int lumpIdx); /*delimiter='/'*/
+AutoStr* F_ComposeLumpPath(struct file1_s* file, int lumpIdx/*, delimiter ='/' */);
 
 size_t F_ReadLump(struct file1_s* file, int lumpIdx, uint8_t* buffer);
 
diff --git a/doomsday/engine/include/gl/gl_texmanager.h b/doomsday/engine/include/gl/gl_texmanager.h
index 144a5a9cce..1fc72bd6fd 100644
--- a/doomsday/engine/include/gl/gl_texmanager.h
+++ b/doomsday/engine/include/gl/gl_texmanager.h
@@ -108,7 +108,7 @@ void GL_UpdateTexParams(int mipMode);
  */
 void GL_SetTextureParams(int minMode, int gameTex, int uiTex);
 
-/// Release all textures in all namespaces.
+/// Release all textures in all schemes.
 void GL_ReleaseTextures(void);
 
 /// Release all textures flagged 'runtime'.
@@ -118,12 +118,12 @@ void GL_ReleaseRuntimeTextures(void);
 void GL_ReleaseSystemTextures(void);
 
 /**
- * Release all textures in the identified namespace(s).
+ * Release all textures in the identified scheme(s).
  *
- * @param namespaceId  Unique identifier of the namespace to process or @c TN_ANY
- *     to release all textures in any namespace.
+ * @param schemeId  Unique identifier of the scheme to process or @c TS_ANY
+ *     to release all textures in any scheme.
  */
-void GL_ReleaseTexturesByNamespace(texturenamespaceid_t namespaceId);
+void GL_ReleaseTexturesByScheme(textureschemeid_t schemeId);
 
 /**
  * Release all textures associated with the specified @a texture.
diff --git a/doomsday/engine/include/render/r_sky.h b/doomsday/engine/include/render/r_sky.h
index 528d5cde82..59ac14a7b3 100644
--- a/doomsday/engine/include/render/r_sky.h
+++ b/doomsday/engine/include/render/r_sky.h
@@ -37,7 +37,7 @@
 #define DEFAULT_SKY_HEIGHT               ( .666667f )
 #define DEFAULT_SKY_HORIZON_OFFSET       ( 0 )
 #define DEFAULT_SKY_SPHERE_XOFFSET       ( 0 )
-#define DEFAULT_SKY_SPHERE_MATERIAL      ( MN_TEXTURES_NAME":SKY1" )
+#define DEFAULT_SKY_SPHERE_MATERIAL      ( MS_TEXTURES_NAME":SKY1" )
 #define DEFAULT_SKY_SPHERE_FADEOUT_LIMIT ( .3f )
 
 typedef struct skymodel_s {
diff --git a/doomsday/engine/include/resource/fonts.h b/doomsday/engine/include/resource/fonts.h
index 12d54cf862..0bece45de6 100644
--- a/doomsday/engine/include/resource/fonts.h
+++ b/doomsday/engine/include/resource/fonts.h
@@ -53,7 +53,7 @@ extern "C" {
 /// Special value used to signify an invalid font id.
 #define NOFONTID                    0
 
-enum fontnamespaceid_e; // Defined in dd_share.h
+enum fontschemeid_e; // Defined in dd_share.h
 struct font_s;
 
 /// Register the console commands, variables, etc..., of this module.
@@ -72,24 +72,24 @@ void Fonts_Shutdown(void);
 void Fonts_ClearDefinitionLinks(void);
 
 /**
- * Try to interpret a font namespace identifier from @a str.
- * If found to match a known namespace name, return the associated identifier.
+ * Try to interpret a font scheme identifier from @a str.
+ * If found to match a known scheme name, return the associated identifier.
  * If the reference @a str is not valid (i.e., NULL or a zero-length string)
- * then the special identifier @c FN_ANY is returned.
- * Otherwise @c FN_INVALID.
+ * then the special identifier @c FS_ANY is returned.
+ * Otherwise @c FS_INVALID.
  */
-fontnamespaceid_t Fonts_ParseNamespace(const char* str);
+fontschemeid_t Fonts_ParseScheme(const char* str);
 
-/// @return  Name associated with the identified @a namespaceId else a zero-length string.
-const ddstring_t* Fonts_NamespaceName(fontnamespaceid_t namespaceId);
+/// @return  Name associated with the identified @a schemeId else a zero-length string.
+const ddstring_t* Fonts_SchemeName(fontschemeid_t schemeId);
 
 /// @return  Total number of unique Fonts in the collection.
 uint Fonts_Size(void);
 
-/// @return  Number of unique Fonts in the identified @a namespaceId.
-uint Fonts_Count(fontnamespaceid_t namespaceId);
+/// @return  Number of unique Fonts in the identified @a schemeId.
+uint Fonts_Count(fontschemeid_t schemeId);
 
-/// Clear all fonts in all namespaces (and release any acquired GL-textures).
+/// Clear all fonts in all schemes (and release any acquired GL-textures).
 void Fonts_Clear(void);
 
 /// Clear all fonts flagged 'runtime' (and release any acquired GL-textures).
@@ -99,12 +99,12 @@ void Fonts_ClearRuntime(void);
 void Fonts_ClearSystem(void);
 
 /**
- * Clear all fonts in the identified namespace(s) (and release any acquired GL-textures).
+ * Clear all fonts in the identified scheme(s) (and release any acquired GL-textures).
  *
- * @param namespaceId  Unique identifier of the namespace to process
- *     or @c FN_ANY to clear all fonts in any namespace.
+ * @param schemeId  Unique identifier of the scheme to process
+ *     or @c FS_ANY to clear all fonts in any scheme.
  */
-void Fonts_ClearNamespace(fontnamespaceid_t namespaceId);
+void Fonts_ClearScheme(fontschemeid_t schemeId);
 
 /// @return  Unique identifier of the primary name for @a font else @c NOFONTID.
 fontid_t Fonts_Id(struct font_s* font);
@@ -112,14 +112,14 @@ fontid_t Fonts_Id(struct font_s* font);
 /// @return  Font associated with unique identifier @a fontId else @c NULL.
 struct font_s* Fonts_ToFont(fontid_t fontId);
 
-/// @return  Font associated with the namespace-unique identifier @a index else @c NOFONTID.
-textureid_t Fonts_FontForUniqueId(fontnamespaceid_t namespaceId, int uniqueId);
+/// @return  Font associated with the scheme-unique identifier @a index else @c NOFONTID.
+textureid_t Fonts_FontForUniqueId(fontschemeid_t schemeId, int uniqueId);
 
-/// @return  Namespace-unique identfier associated with the identified @a fontId.
+/// @return  Scheme-unique identfier associated with the identified @a fontId.
 int Fonts_UniqueId(fontid_t fontId);
 
-/// @return  Unique identifier of the namespace this name is in.
-fontnamespaceid_t Fonts_Namespace(fontid_t fontId);
+/// @return  Unique identifier of the scheme this name is in.
+fontschemeid_t Fonts_Scheme(fontid_t fontId);
 
 /// @return  Symbolic name/path-to this font as a string.
 AutoStr* Fonts_ComposePath(fontid_t fontId);
@@ -167,7 +167,7 @@ fontid_t Fonts_ResolveUriCString(const char* uri); /*quiet=!(verbose >= 1)*/
  * already exists, its unique identifier is returned..
  *
  * @param uri  Uri representing a path to the font in the virtual hierarchy.
- * @param uniqueId  Namespace-unique identifier to associate with the font.
+ * @param uniqueId  Scheme-unique identifier to associate with the font.
  * @return  Unique identifier for this font unless @a uri is invalid, in
  *     which case @c NOFONTID is returned.
  */
@@ -184,30 +184,30 @@ struct font_s* Fonts_CreateFromDef(fontid_t id, ded_compositefont_t* def);
  * each visited. Iteration ends when all fonts have been visited or a
  * callback returns non-zero.
  *
- * @param namespaceId  If a valid namespace identifier, only consider
- *     fonts in this namespace, otherwise visit all fonts.
+ * @param schemeId  If a valid scheme identifier, only consider
+ *     fonts in this scheme, otherwise visit all fonts.
  * @param callback  Callback function ptr.
  * @param paramaters  Passed to the callback.
  *
  * @return  @c 0 iff iteration completed wholly.
  */
-int Fonts_Iterate2(fontnamespaceid_t namespaceId, int (*callback)(struct font_s* font, void* paramaters), void* paramaters);
-int Fonts_Iterate(fontnamespaceid_t namespaceId, int (*callback)(struct font_s* font, void* paramaters)); /*paramaters=NULL*/
+int Fonts_Iterate2(fontschemeid_t schemeId, int (*callback)(struct font_s* font, void* paramaters), void* paramaters);
+int Fonts_Iterate(fontschemeid_t schemeId, int (*callback)(struct font_s* font, void* paramaters)); /*paramaters=NULL*/
 
 /**
  * Iterate over declared fonts in the collection making a callback for
  * each visited. Iteration ends when all fonts have been visited or a
  * callback returns non-zero.
  *
- * @param namespaceId  If a valid namespace identifier, only consider
- *     fonts in this namespace, otherwise visit all fonts.
+ * @param schemeId  If a valid scheme identifier, only consider
+ *     fonts in this scheme, otherwise visit all fonts.
  * @param callback  Callback function ptr.
  * @param paramaters  Passed to the callback.
  *
  * @return  @c 0 iff iteration completed wholly.
  */
-int Fonts_IterateDeclared2(fontnamespaceid_t namespaceId, int (*callback)(fontid_t textureId, void* paramaters), void* paramaters);
-int Fonts_IterateDeclared(fontnamespaceid_t namespaceId, int (*callback)(fontid_t textureId, void* paramaters)); /*paramaters=NULL*/
+int Fonts_IterateDeclared2(fontschemeid_t schemeId, int (*callback)(fontid_t textureId, void* paramaters), void* paramaters);
+int Fonts_IterateDeclared(fontschemeid_t schemeId, int (*callback)(fontid_t textureId, void* paramaters)); /*paramaters=NULL*/
 
 /*
  * Here follows miscellaneous routines currently awaiting refactoring into the
@@ -220,7 +220,7 @@ int Fonts_IterateDeclared(fontnamespaceid_t namespaceId, int (*callback)(fontid_
  * for fonts.
  *
  * @note Called automatically prior to module shutdown.
- * @todo Define new texture namespaces for font textures and refactor away.
+ * @todo Define new texture schemes for font textures and refactor away.
  */
 void Fonts_ReleaseRuntimeTextures(void);
 void Fonts_ReleaseSystemTextures(void);
diff --git a/doomsday/engine/include/resource/materials.h b/doomsday/engine/include/resource/materials.h
index 4cf478adab..d934b9c58d 100644
--- a/doomsday/engine/include/resource/materials.h
+++ b/doomsday/engine/include/resource/materials.h
@@ -1,6 +1,6 @@
 /**
  * @file materials.h
- * Materials collection, namespaces, bindings and other management. @ingroup resource
+ * Materials collection, schemes, bindings and other management. @ingroup resource
  *
  * @authors Copyright © 2003-2012 Jaakko Keränen 
  * @authors Copyright © 2005-2012 Daniel Swanson 
@@ -34,7 +34,7 @@ struct texturevariantspecification_s;
 struct materialvariant_s;
 struct materialsnapshot_s;
 
-enum materialnamespaceid_e; // Defined in dd_share.h
+enum materialschemeid_e; // Defined in dd_share.h
 
 /// Material (Usage) Context identifiers.
 typedef enum {
@@ -79,21 +79,21 @@ void Materials_PurgeCacheQueue(void);
 void Materials_ClearDefinitionLinks(void);
 
 /**
- * Try to interpret a known material namespace identifier from @a str. If found to match
- * a known namespace name, return the associated identifier. If the reference @a str is
+ * Try to interpret a known material scheme identifier from @a str. If found to match
+ * a known scheme name, return the associated identifier. If the reference @a str is
  * not valid (i.e., equal to NULL or is a zero-length string) then the special identifier
- * @c MN_ANY is returned. Otherwise @c MN_INVALID.
+ * @c MS_ANY is returned. Otherwise @c MS_INVALID.
  */
-enum materialnamespaceid_e Materials_ParseNamespace(const char* str);
+enum materialschemeid_e Materials_ParseSchemeName(const char* str);
 
-/// @return  Name associated with the identified @a namespaceId else a zero-length string.
-const Str* Materials_NamespaceName(enum materialnamespaceid_e namespaceId);
+/// @return  Name associated with the identified @a schemeId else a zero-length string.
+const Str* Materials_SchemeName(enum materialschemeid_e schemeId);
 
 /// @return  Total number of unique Materials in the collection.
 uint Materials_Size(void);
 
-/// @return  Number of unique Materials in the identified @a namespaceId.
-uint Materials_Count(enum materialnamespaceid_e namespaceId);
+/// @return  Number of unique Materials in the identified @a schemeId.
+uint Materials_Count(enum materialschemeid_e schemeId);
 
 /// @return  Unique identifier associated with @a material else @c 0.
 materialid_t Materials_Id(material_t* material);
@@ -101,8 +101,8 @@ materialid_t Materials_Id(material_t* material);
 /// @return  Material associated with unique identifier @a materialId else @c NULL.
 material_t* Materials_ToMaterial(materialid_t materialId);
 
-/// @return  Unique identifier of the namespace this material is in.
-enum materialnamespaceid_e Materials_Namespace(materialid_t materialId);
+/// @return  Unique identifier of the scheme this material is in.
+enum materialschemeid_e Materials_Scheme(materialid_t materialId);
 
 /// @return  Symbolic name/path-to this material. Must be destroyed with Str_Delete().
 AutoStr* Materials_ComposePath(materialid_t materialId);
@@ -144,7 +144,7 @@ materialid_t Materials_ResolveUriCString(const char* uri); /*quiet=!(verbose >=
 
 /**
  * Create a new Material unless an existing Material is found at the path
- * (and within the same namespace) as that specified in @a def, in which case
+ * (and within the same scheme) as that specified in @a def, in which case
  * it is returned instead.
  *
  * @note: May fail on invalid definitions (return= @c NULL).
diff --git a/doomsday/engine/include/resource/textures.h b/doomsday/engine/include/resource/textures.h
index db77ef07d6..1e93771f4a 100644
--- a/doomsday/engine/include/resource/textures.h
+++ b/doomsday/engine/include/resource/textures.h
@@ -48,7 +48,7 @@ typedef uint textureid_t;
 /// Special value used to signify an invalid texture id.
 #define NOTEXTUREID                 0
 
-enum texturenamespaceid_e; // Defined in dd_share.h
+enum textureschemeid_e; // Defined in dd_share.h
 struct texture_s;
 
 /// Register the console commands, variables, etc..., of this module.
@@ -61,23 +61,23 @@ void Textures_Init(void);
 void Textures_Shutdown(void);
 
 /**
- * Try to interpret a texture namespace identifier from @a str. If found to match a known
- * namespace name, return the associated identifier. If the reference @a str is not valid
- * (i.e., NULL or a zero-length string) then the special identifier @c TN_ANY is returned.
- * Otherwise @c TN_INVALID.
+ * Try to interpret a texture scheme identifier from @a str. If found to match a known
+ * scheme name, return the associated identifier. If the reference @a str is not valid
+ * (i.e., NULL or a zero-length string) then the special identifier @c TS_ANY is returned.
+ * Otherwise @c TS_INVALID.
  */
-texturenamespaceid_t Textures_ParseNamespace(const char* str);
+textureschemeid_t Textures_ParseSchemeName(const char* str);
 
-/// @return  Name associated with the identified @a namespaceId else a zero-length string.
-const Str* Textures_NamespaceName(texturenamespaceid_t namespaceId);
+/// @return  Name associated with the identified @a schemeId else a zero-length string.
+const Str* Textures_SchemeName(textureschemeid_t schemeId);
 
 /// @return  Total number of unique Textures in the collection.
 uint Textures_Size(void);
 
-/// @return  Number of unique Textures in the identified @a namespaceId.
-uint Textures_Count(texturenamespaceid_t namespaceId);
+/// @return  Number of unique Textures in the identified @a schemeId.
+uint Textures_Count(textureschemeid_t schemeId);
 
-/// Clear all textures in all namespaces (and release any acquired GL-textures).
+/// Clear all textures in all schemes (and release any acquired GL-textures).
 void Textures_Clear(void);
 
 /// Clear all textures flagged 'runtime' (and release any acquired GL-textures).
@@ -87,12 +87,12 @@ void Textures_ClearRuntime(void);
 void Textures_ClearSystem(void);
 
 /**
- * Clear all textures in the identified namespace(s) (and release any acquired GL-textures).
+ * Clear all textures in the identified scheme(s) (and release any acquired GL-textures).
  *
- * @param namespaceId  Unique identifier of the namespace to process or
- *                     @c TN_ANY to clear all textures in any namespace.
+ * @param schemeId  Unique identifier of the scheme to process or
+ *                  @c TS_ANY to clear all textures in any scheme.
  */
-void Textures_ClearNamespace(texturenamespaceid_t namespaceId);
+void Textures_ClearScheme(textureschemeid_t schemeId);
 
 /// @return  Unique identifier of the primary name for @a texture else @c NOTEXTUREID.
 textureid_t Textures_Id(struct texture_s* texture);
@@ -100,18 +100,18 @@ textureid_t Textures_Id(struct texture_s* texture);
 /// @return  Texture associated with unique identifier @a textureId else @c NULL.
 struct texture_s* Textures_ToTexture(textureid_t textureId);
 
-/// @return  Texture associated with the namespace-unique identifier @a index else @c NOTEXTUREID.
-textureid_t Textures_TextureForUniqueId(texturenamespaceid_t namespaceId, int uniqueId);
+/// @return  Texture associated with the scheme-unique identifier @a index else @c NOTEXTUREID.
+textureid_t Textures_TextureForUniqueId(textureschemeid_t schemeId, int uniqueId);
 
-/// @return  Namespace-unique identfier associated with the identified @a textureId.
+/// @return  Scheme-unique identfier associated with the identified @a textureId.
 int Textures_UniqueId(textureid_t textureId);
 
 /// @return  Declared, percent-encoded path to this data resource,
 ///          else a "null" Uri (no scheme or path).
 const Uri* Textures_ResourcePath(textureid_t textureId);
 
-/// @return  Unique identifier of the namespace this name is in.
-texturenamespaceid_t Textures_Namespace(textureid_t textureId);
+/// @return  Unique identifier of the scheme this name is in.
+textureschemeid_t Textures_Scheme(textureid_t textureId);
 
 /// @return  Symbolic, percent-encoded name/path-to this texture as a string.
 ///          Must be destroyed with Str_Delete().
@@ -143,7 +143,7 @@ textureid_t Textures_ResolveUriCString(const char* uri); /*quiet=!(verbose >= 1)
  * is released (and any GL-textures acquired for it).
  *
  * @param uri           Uri representing a path to the texture in the virtual hierarchy.
- * @param uniqueId      Namespace-unique identifier to associate with the texture.
+ * @param uniqueId      Scheme-unique identifier to associate with the texture.
  * @param resourcepath  The path to the underlying data resource.
  *
  * @return  Unique identifier for this texture unless @a uri is invalid, in which case
@@ -167,29 +167,29 @@ struct texture_s* Textures_Create(textureid_t id, boolean custom, void* userData
  * Iterate over defined Textures in the collection making a callback for each visited.
  * Iteration ends when all textures have been visited or a callback returns non-zero.
  *
- * @param namespaceId   If a valid namespace identifier, only consider textures in this
- *                      namespace, otherwise visit all textures.
+ * @param schemeId      If a valid scheme identifier, only consider textures in this
+ *                      scheme, otherwise visit all textures.
  * @param callback      Callback function ptr.
  * @param parameters    Passed to the callback.
  *
  * @return  @c 0 iff iteration completed wholly.
  */
-int Textures_Iterate2(texturenamespaceid_t namespaceId, int (*callback)(struct texture_s* texture, void* parameters), void* parameters);
-int Textures_Iterate(texturenamespaceid_t namespaceId, int (*callback)(struct texture_s* texture, void* parameters)); /*parameters=NULL*/
+int Textures_Iterate2(textureschemeid_t schemeId, int (*callback)(struct texture_s* texture, void* parameters), void* parameters);
+int Textures_Iterate(textureschemeid_t schemeId, int (*callback)(struct texture_s* texture, void* parameters)); /*parameters=NULL*/
 
 /**
  * Iterate over declared textures in the collection making a callback for each visited.
  * Iteration ends when all textures have been visited or a callback returns non-zero.
  *
- * @param namespaceId   If a valid namespace identifier, only consider textures in this
- *                      namespace, otherwise visit all textures.
+ * @param schemeId      If a valid scheme identifier, only consider textures in this
+ *                      scheme, otherwise visit all textures.
  * @param callback      Callback function ptr.
  * @param parameters    Passed to the callback.
  *
  * @return  @c 0 iff iteration completed wholly.
  */
-int Textures_IterateDeclared2(texturenamespaceid_t namespaceId, int (*callback)(textureid_t textureId, void* parameters), void* parameters);
-int Textures_IterateDeclared(texturenamespaceid_t namespaceId, int (*callback)(textureid_t textureId, void* parameters)); /*parameters=NULL*/
+int Textures_IterateDeclared2(textureschemeid_t schemeId, int (*callback)(textureid_t textureId, void* parameters), void* parameters);
+int Textures_IterateDeclared(textureschemeid_t schemeId, int (*callback)(textureid_t textureId, void* parameters)); /*parameters=NULL*/
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/doomsday/engine/src/dd_games.cpp b/doomsday/engine/src/dd_games.cpp
index a06aa1f43f..8382f8ffa1 100644
--- a/doomsday/engine/src/dd_games.cpp
+++ b/doomsday/engine/src/dd_games.cpp
@@ -194,8 +194,8 @@ GameCollection& GameCollection::locateStartupResources(Game& game)
         d->currentGame = &game;
         DD_ExchangeGamePluginEntryPoints(game.pluginId());
 
-        // Re-init the namespaces using the search paths of this Game.
-        App_FileSystem()->resetAllNamespaces();
+        // Re-init the filesystem subspace schemes using the search paths of this Game.
+        App_FileSystem()->resetAllSchemes();
     }
 
     DENG2_FOR_EACH_CONST(Game::MetaFiles, i, game.metafiles())
@@ -214,8 +214,8 @@ GameCollection& GameCollection::locateStartupResources(Game& game)
         d->currentGame = oldGame;
         DD_ExchangeGamePluginEntryPoints(oldGame->pluginId());
 
-        // Re-init the namespaces using the search paths of this Game.
-        App_FileSystem()->resetAllNamespaces();
+        // Re-init the filesystem subspace schemes using the search paths of this Game.
+        App_FileSystem()->resetAllSchemes();
     }
     return *this;
 }
diff --git a/doomsday/engine/src/dd_main.cpp b/doomsday/engine/src/dd_main.cpp
index 8e60403c81..699b60d118 100644
--- a/doomsday/engine/src/dd_main.cpp
+++ b/doomsday/engine/src/dd_main.cpp
@@ -380,9 +380,9 @@ FileTypes const& DD_FileTypes()
     return fileTypeMap;
 }
 
-static void createPackagesNamespace()
+static void createPackagesScheme()
 {
-    FS1::Namespace& fnamespace = App_FileSystem()->createNamespace("Packages");
+    FS1::Scheme& scheme = App_FileSystem()->createScheme("Packages");
 
     /*
      * Add default search paths.
@@ -397,7 +397,7 @@ static void createPackagesNamespace()
     if(UnixInfo_GetConfigValue("paths", "iwaddir", fn, FILENAME_T_MAXLEN))
     {
         NativePath path = de::App::app().commandLine().startupPath() / fn;
-        fnamespace.addSearchPath(FS1::DefaultPaths, SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
+        scheme.addSearchPath(FS1::DefaultPaths, SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
         LOG_INFO("Using paths.iwaddir: %s") << path.pretty();
     }
 #endif
@@ -406,7 +406,7 @@ static void createPackagesNamespace()
     if(!CommandLine_Check("-nodoomwaddir") && getenv("DOOMWADDIR"))
     {
         NativePath path = App::app().commandLine().startupPath() / getenv("DOOMWADDIR");
-        fnamespace.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
+        scheme.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
         LOG_INFO("Using DOOMWADDIR: %s") << path.pretty();
     }
 
@@ -423,91 +423,91 @@ static void createPackagesNamespace()
         for(int i = allPaths.count(); i--> 0; )
         {
             NativePath path = App::app().commandLine().startupPath() / allPaths[i];
-            fnamespace.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
+            scheme.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), SearchPath::NoDescend));
             LOG_INFO("Using DOOMWADPATH: %s") << path.pretty();
         }
 
 #undef SEP_CHAR
     }
 
-    fnamespace.addSearchPath(SearchPath(de::Uri("$(App.DataPath)/", RC_NULL), SearchPath::NoDescend));
-    fnamespace.addSearchPath(SearchPath(de::Uri("$(App.DataPath)/$(GamePlugin.Name)/", RC_NULL), SearchPath::NoDescend));
+    scheme.addSearchPath(SearchPath(de::Uri("$(App.DataPath)/", RC_NULL), SearchPath::NoDescend));
+    scheme.addSearchPath(SearchPath(de::Uri("$(App.DataPath)/$(GamePlugin.Name)/", RC_NULL), SearchPath::NoDescend));
 }
 
-void DD_CreateFileSystemNamespaces()
+void DD_CreateFileSystemSchemes()
 {
-    int const namespacedef_max_searchpaths = 5;
-    struct namespacedef_s {
+    int const schemedef_max_searchpaths = 5;
+    struct schemedef_s {
         char const* name;
         char const* optOverridePath;
         char const* optFallbackPath;
-        FS1::Namespace::Flags flags;
+        FS1::Scheme::Flags flags;
         SearchPath::Flags searchPathFlags;
         /// Priority is right to left.
-        char const* searchPaths[namespacedef_max_searchpaths];
+        char const* searchPaths[schemedef_max_searchpaths];
     } defs[] = {
-        { "Defs",         NULL,           NULL,           FS1::Namespace::Flag(0), 0,
+        { "Defs",         NULL,           NULL,           FS1::Scheme::Flag(0), 0,
             { "$(App.DefsPath)/", "$(App.DefsPath)/$(GamePlugin.Name)/", "$(App.DefsPath)/$(GamePlugin.Name)/$(Game.IdentityKey)/" }
         },
-        { "Graphics",     "-gfxdir2",     "-gfxdir",      FS1::Namespace::Flag(0), 0,
+        { "Graphics",     "-gfxdir2",     "-gfxdir",      FS1::Scheme::Flag(0), 0,
             { "$(App.DataPath)/graphics/" }
         },
-        { "Models",       "-modeldir2",   "-modeldir",    FS1::Namespace::MappedInPackages, 0,
+        { "Models",       "-modeldir2",   "-modeldir",    FS1::Scheme::MappedInPackages, 0,
             { "$(App.DataPath)/$(GamePlugin.Name)/models/", "$(App.DataPath)/$(GamePlugin.Name)/models/$(Game.IdentityKey)/" }
         },
-        { "Sfx",          "-sfxdir2",     "-sfxdir",      FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Sfx",          "-sfxdir2",     "-sfxdir",      FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/$(GamePlugin.Name)/sfx/", "$(App.DataPath)/$(GamePlugin.Name)/sfx/$(Game.IdentityKey)/" }
         },
-        { "Music",        "-musdir2",     "-musdir",      FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Music",        "-musdir2",     "-musdir",      FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/$(GamePlugin.Name)/music/", "$(App.DataPath)/$(GamePlugin.Name)/music/$(Game.IdentityKey)/" }
         },
-        { "Textures",     "-texdir2",     "-texdir",      FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Textures",     "-texdir2",     "-texdir",      FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/$(GamePlugin.Name)/textures/", "$(App.DataPath)/$(GamePlugin.Name)/textures/$(Game.IdentityKey)/" }
         },
-        { "Flats",        "-flatdir2",    "-flatdir",     FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Flats",        "-flatdir2",    "-flatdir",     FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/$(GamePlugin.Name)/flats/", "$(App.DataPath)/$(GamePlugin.Name)/flats/$(Game.IdentityKey)/" }
         },
-        { "Patches",      "-patdir2",     "-patdir",      FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Patches",      "-patdir2",     "-patdir",      FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/$(GamePlugin.Name)/patches/", "$(App.DataPath)/$(GamePlugin.Name)/patches/$(Game.IdentityKey)/" }
         },
-        { "LightMaps",    "-lmdir2",      "-lmdir",       FS1::Namespace::MappedInPackages, 0,
+        { "LightMaps",    "-lmdir2",      "-lmdir",       FS1::Scheme::MappedInPackages, 0,
             { "$(App.DataPath)/$(GamePlugin.Name)/lightmaps/" }
         },
-        { "Fonts",        "-fontdir2",    "-fontdir",     FS1::Namespace::MappedInPackages, SearchPath::NoDescend,
+        { "Fonts",        "-fontdir2",    "-fontdir",     FS1::Scheme::MappedInPackages, SearchPath::NoDescend,
             { "$(App.DataPath)/fonts/", "$(App.DataPath)/$(GamePlugin.Name)/fonts/", "$(App.DataPath)/$(GamePlugin.Name)/fonts/$(Game.IdentityKey)/" }
         },
-        { 0, 0, 0, FS1::Namespace::Flag(0), 0, { 0 } }
+        { 0, 0, 0, FS1::Scheme::Flag(0), 0, { 0 } }
     };
 
-    createPackagesNamespace();
+    createPackagesScheme();
 
     // Setup the rest...
-    struct namespacedef_s const* def = defs;
+    struct schemedef_s const* def = defs;
     for(int i = 0; defs[i].name; ++i, ++def)
     {
-        FS1::Namespace& fnamespace = App_FileSystem()->createNamespace(def->name, def->flags);
+        FS1::Scheme& scheme = App_FileSystem()->createScheme(def->name, def->flags);
 
         int searchPathCount = 0;
-        while(def->searchPaths[searchPathCount] && ++searchPathCount < namespacedef_max_searchpaths)
+        while(def->searchPaths[searchPathCount] && ++searchPathCount < schemedef_max_searchpaths)
         {}
 
         for(int j = 0; j < searchPathCount; ++j)
         {
-            fnamespace.addSearchPath(SearchPath(de::Uri(def->searchPaths[j], RC_NULL), def->searchPathFlags));
+            scheme.addSearchPath(SearchPath(de::Uri(def->searchPaths[j], RC_NULL), def->searchPathFlags));
         }
 
         if(def->optOverridePath && CommandLine_CheckWith(def->optOverridePath, 1))
         {
             NativePath path = NativePath(CommandLine_NextAsPath());
-            fnamespace.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::OverridePaths);
+            scheme.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::OverridePaths);
             path = path / "$(Game.IdentityKey)";
-            fnamespace.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::OverridePaths);
+            scheme.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::OverridePaths);
         }
 
         if(def->optFallbackPath && CommandLine_CheckWith(def->optFallbackPath, 1))
         {
             NativePath path = NativePath(CommandLine_NextAsPath());
-            fnamespace.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::FallbackPaths);
+            scheme.addSearchPath(SearchPath(de::Uri::fromNativeDirPath(path), def->searchPathFlags), FS1::FallbackPaths);
         }
     }
 }
@@ -792,7 +792,7 @@ static int DD_LoadGameStartupResourcesWorker(void* parameters)
     // Reset file Ids so previously seen files can be processed again.
     App_FileSystem()->resetFileIds();
     initPathMappings();
-    App_FileSystem()->resetAllNamespaces();
+    App_FileSystem()->resetAllSchemes();
 
     if(p->initiatedBusyMode)
         Con_SetProgress(50);
@@ -1041,7 +1041,7 @@ static int DD_LoadAddonResourcesWorker(void* parameters)
 
     // Re-initialize the resource locator as there are now new resources to be found
     // on existing search paths (probably that is).
-    App_FileSystem()->resetAllNamespaces();
+    App_FileSystem()->resetAllSchemes();
 
     if(p->initiatedBusyMode)
     {
@@ -1407,7 +1407,7 @@ bool DD_ChangeGame(de::Game& game, bool allowReload = false)
         initPathLumpMappings();
         initPathMappings();
 
-        App_FileSystem()->resetAllNamespaces();
+        App_FileSystem()->resetAllSchemes();
     }
 
     FI_Shutdown();
@@ -1709,7 +1709,7 @@ boolean DD_Init(void)
     DD_CreateResourceClasses();
     DD_CreateFileTypes();
     F_Init();
-    DD_CreateFileSystemNamespaces();
+    DD_CreateFileSystemSchemes();
 
     Fonts_Init();
     FR_Init();
@@ -1730,7 +1730,7 @@ boolean DD_Init(void)
                                 DD_DummyWorker, 0, "Buffering...");
 
     // Add resource paths specified using -iwad on the command line.
-    FS1::Namespace* fnamespace = App_FileSystem()->namespaceByName(DD_ResourceClassByName("RC_PACKAGE").defaultNamespace());
+    FS1::Scheme* scheme = App_FileSystem()->schemeByName(DD_ResourceClassByName("RC_PACKAGE").defaultScheme());
     for(int p = 0; p < CommandLine_Count(); ++p)
     {
         if(!CommandLine_IsMatchingAlias("-iwad", CommandLine_At(p)))
@@ -1738,14 +1738,14 @@ boolean DD_Init(void)
 
         while(++p != CommandLine_Count() && !CommandLine_IsOption(p))
         {
-            /// @todo Do not add these as search paths, publish them directly
-            ///       to the "packages" Namespace.
+            /// @todo Do not add these as search paths, publish them directly to
+            ///       the "Packages" scheme.
 
             // CommandLine_PathAt() always returns an absolute path.
             directory_t* dir = Dir_FromText(CommandLine_PathAt(p));
             de::Uri uri = de::Uri::fromNativeDirPath(Dir_Path(dir), RC_PACKAGE);
 
-            fnamespace->addSearchPath(SearchPath(uri, SearchPath::NoDescend));
+            scheme->addSearchPath(SearchPath(uri, SearchPath::NoDescend));
 
             Dir_Delete(dir);
         }
@@ -1801,9 +1801,9 @@ boolean DD_Init(void)
 
     initPathLumpMappings();
 
-    // Re-initialize the namespaces as there are now new resources to be found
-    // on existing search paths (probably that is).
-    App_FileSystem()->resetAllNamespaces();
+    // Re-initialize the filesystem subspace schemess as there are now new
+    // resources to be found on existing search paths (probably that is).
+    App_FileSystem()->resetAllSchemes();
 
     // One-time execution of various command line features available during startup.
     if(CommandLine_CheckWith("-dumplump", 1))
@@ -1899,7 +1899,7 @@ boolean DD_Init(void)
         App_FileSystem()->resetFileIds();
         initPathLumpMappings();
         initPathMappings();
-        App_FileSystem()->resetAllNamespaces();
+        App_FileSystem()->resetAllSchemes();
 
         R_InitPatchComposites();
         R_InitFlatTextures();
@@ -1931,7 +1931,7 @@ static void DD_InitResourceSystem(void)
 
     initPathMappings();
 
-    App_FileSystem()->resetAllNamespaces();
+    App_FileSystem()->resetAllSchemes();
 
     // Initialize the definition databases.
     Def_Init();
@@ -2128,8 +2128,8 @@ void DD_UpdateEngineState(void)
     initPathLumpMappings();
     initPathMappings();
 
-    // Re-build the namespaces as there may now be new resources to be found.
-    App_FileSystem()->resetAllNamespaces();
+    // Re-build the filesystem subspace schemes as there may be new resources to be found.
+    App_FileSystem()->resetAllSchemes();
 
     R_InitPatchComposites();
     R_InitFlatTextures();
@@ -2502,57 +2502,57 @@ void DD_SetVariable(int ddvalue, void *parm)
 }
 
 /// @note Part of the Doomsday public API.
-materialnamespaceid_t DD_ParseMaterialNamespace(const char* str)
+materialschemeid_t DD_ParseMaterialSchemeName(const char* str)
 {
-    return Materials_ParseNamespace(str);
+    return Materials_ParseSchemeName(str);
 }
 
 /// @note Part of the Doomsday public API.
-texturenamespaceid_t DD_ParseTextureNamespace(const char* str)
+textureschemeid_t DD_ParseTextureSchemeName(const char* str)
 {
-    return Textures_ParseNamespace(str);
+    return Textures_ParseSchemeName(str);
 }
 
 /// @note Part of the Doomsday public API.
-fontnamespaceid_t DD_ParseFontNamespace(const char* str)
+fontschemeid_t DD_ParseFontSchemeName(const char* str)
 {
-    return Fonts_ParseNamespace(str);
+    return Fonts_ParseScheme(str);
 }
 
-const ddstring_t* DD_MaterialNamespaceNameForTextureNamespace(texturenamespaceid_t texNamespace)
+const ddstring_t* DD_MaterialSchemeNameForTextureScheme(textureschemeid_t texSchemeId)
 {
-    static const materialnamespaceid_t namespaceIds[TEXTURENAMESPACE_COUNT] = {
-        /* TN_SYSTEM */    MN_SYSTEM,
-        /* TN_FLATS */     MN_FLATS,
-        /* TN_TEXTURES */  MN_TEXTURES,
-        /* TN_SPRITES */   MN_SPRITES,
-        /* TN_PATCHES */   MN_ANY, // No materials for these yet.
+    static const materialschemeid_t schemeIds[TEXTURESCHEME_COUNT] = {
+        /* TS_SYSTEM */    MS_SYSTEM,
+        /* TS_FLATS */     MS_FLATS,
+        /* TS_TEXTURES */  MS_TEXTURES,
+        /* TS_SPRITES */   MS_SPRITES,
+        /* TS_PATCHES */   MS_ANY, // No materials for these yet.
 
         // -- No Materials for these --
-        /* TN_DETAILS */   MN_INVALID,
-        /* TN_REFLECTIONS */ MN_INVALID,
-        /* TN_MASKS */      MN_INVALID,
-        /* TN_MODELSKINS */ MN_INVALID,
-        /* TN_MODELREFLECTIONSKINS */ MN_INVALID,
-        /* TN_LIGHTMAPS */ MN_INVALID,
-        /* TN_FLAREMAPS */ MN_INVALID
+        /* TS_DETAILS */              MS_INVALID,
+        /* TS_REFLECTIONS */          MS_INVALID,
+        /* TS_MASKS */                MS_INVALID,
+        /* TS_MODELSKINS */           MS_INVALID,
+        /* TS_MODELREFLECTIONSKINS */ MS_INVALID,
+        /* TS_LIGHTMAPS */            MS_INVALID,
+        /* TS_FLAREMAPS */            MS_INVALID
     };
-    materialnamespaceid_t namespaceId = MN_INVALID; // Unknown.
-    if(VALID_TEXTURENAMESPACEID(texNamespace))
-        namespaceId = namespaceIds[texNamespace-TEXTURENAMESPACE_FIRST];
-    return Materials_NamespaceName(namespaceId);
+    materialschemeid_t schemeId = MS_INVALID; // Unknown.
+    if(VALID_TEXTURESCHEMEID(texSchemeId))
+        schemeId = schemeIds[texSchemeId-TEXTURESCHEME_FIRST];
+    return Materials_SchemeName(schemeId);
 }
 
-materialid_t DD_MaterialForTextureUniqueId(texturenamespaceid_t texNamespaceId, int uniqueId)
+materialid_t DD_MaterialForTextureUniqueId(textureschemeid_t schemeId, int uniqueId)
 {
-    textureid_t texId = Textures_TextureForUniqueId(texNamespaceId, uniqueId);
+    textureid_t texId = Textures_TextureForUniqueId(schemeId, uniqueId);
 
     if(texId == NOTEXTUREID) return NOMATERIALID;
 
     de::Uri* uri = reinterpret_cast(Textures_ComposeUri(texId));
     if(!uri) return NOMATERIALID;
 
-    uri->setScheme(Str_Text(DD_MaterialNamespaceNameForTextureNamespace(texNamespaceId)));
+    uri->setScheme(Str_Text(DD_MaterialSchemeNameForTextureScheme(schemeId)));
     materialid_t matId = Materials_ResolveUri2(reinterpret_cast(uri), true/*quiet please*/);
     delete uri;
     return matId;
diff --git a/doomsday/engine/src/def_main.cpp b/doomsday/engine/src/def_main.cpp
index e0e02da5d2..1a8b890a48 100644
--- a/doomsday/engine/src/def_main.cpp
+++ b/doomsday/engine/src/def_main.cpp
@@ -396,19 +396,19 @@ ded_material_t* Def_GetMaterial(char const* uriCString)
 
         if(uri.scheme().isEmpty())
         {
-            // Caller doesn't care which namespace - use a priority search order.
+            // Caller doesn't care which scheme - use a priority search order.
             de::Uri temp = de::Uri(uri);
 
-            temp.setScheme(MN_SPRITES_NAME);
+            temp.setScheme(MS_SPRITES_NAME);
             def = findMaterialDef(temp);
             if(!def)
             {
-                temp.setScheme(MN_TEXTURES_NAME);
+                temp.setScheme(MS_TEXTURES_NAME);
                 def = findMaterialDef(temp);
             }
             if(!def)
             {
-                temp.setScheme(MN_FLATS_NAME);
+                temp.setScheme(MS_FLATS_NAME);
                 def = findMaterialDef(temp);
             }
         }
@@ -441,7 +441,7 @@ ded_compositefont_t* Def_GetCompositeFont(char const* uriCString)
 
         if(uri.scheme().isEmpty())
         {
-            // Caller doesn't care which namespace - use a priority search order.
+            // Caller doesn't care which scheme - use a priority search order.
             de::Uri temp = de::Uri(uri);
 
             temp.setScheme(FN_GAME_NAME);
@@ -944,7 +944,7 @@ void Def_GenerateGroupsFromAnims(void)
             gmbr->tics = frame->tics;
             gmbr->randomTics = frame->randomTics;
             gmbr->material = Textures_ComposeUri(frame->texture);
-            Uri_SetScheme(gmbr->material, Str_Text(DD_MaterialNamespaceNameForTextureNamespace(Textures_Namespace(frame->texture))));
+            Uri_SetScheme(gmbr->material, Str_Text(DD_MaterialSchemeNameForTextureScheme(Textures_Scheme(frame->texture))));
         }
     }
 }
@@ -964,7 +964,7 @@ static int generateMaterialDefForPatchCompositeTexture(textureid_t texId, void*
     mat->autoGenerated = true;
 
     mat->uri = Uri_Dup(texUri);
-    Uri_SetScheme(mat->uri, MN_TEXTURES_NAME);
+    Uri_SetScheme(mat->uri, MS_TEXTURES_NAME);
 
     tex = Textures_ToTexture(texId);
     if(tex)
@@ -1004,7 +1004,7 @@ static int generateMaterialDefForFlatTexture(textureid_t texId, void* parameters
     mat->autoGenerated = true;
 
     mat->uri = Uri_Dup(texUri);
-    Uri_SetScheme(mat->uri, MN_FLATS_NAME);
+    Uri_SetScheme(mat->uri, MS_FLATS_NAME);
 
     stage = DED_AddMaterialLayerStage(&mat->layers[0]);
     st = &mat->layers[0].stages[stage];
@@ -1042,7 +1042,7 @@ static int generateMaterialDefForSpriteTexture(textureid_t texId, void* paramete
     mat->autoGenerated = true;
 
     mat->uri = Uri_Dup(texUri);
-    Uri_SetScheme(mat->uri, MN_SPRITES_NAME);
+    Uri_SetScheme(mat->uri, MS_SPRITES_NAME);
 
     stage = DED_AddMaterialLayerStage(&mat->layers[0]);
     st = &mat->layers[0].stages[stage];
@@ -1067,9 +1067,9 @@ static int generateMaterialDefForSpriteTexture(textureid_t texId, void* paramete
 
 void Def_GenerateAutoMaterials(void)
 {
-    Textures_IterateDeclared(TN_TEXTURES, generateMaterialDefForPatchCompositeTexture);
-    Textures_IterateDeclared(TN_FLATS,    generateMaterialDefForFlatTexture);
-    Textures_IterateDeclared(TN_SPRITES,  generateMaterialDefForSpriteTexture);
+    Textures_IterateDeclared(TS_TEXTURES, generateMaterialDefForPatchCompositeTexture);
+    Textures_IterateDeclared(TS_FLATS,    generateMaterialDefForFlatTexture);
+    Textures_IterateDeclared(TS_SPRITES,  generateMaterialDefForSpriteTexture);
 }
 
 void Def_Read(void)
@@ -1080,9 +1080,9 @@ void Def_Read(void)
     {
         // We've already initialized the definitions once.
         // Get rid of everything.
-        de::FS1::Namespace* fnamespace = App_FileSystem()->namespaceByName(DD_ResourceClassByName("RC_MODEL").defaultNamespace());
-        DENG_ASSERT(fnamespace);
-        fnamespace->reset();
+        de::FS1::Scheme* scheme = App_FileSystem()->schemeByName(DD_ResourceClassByName("RC_MODEL").defaultScheme());
+        DENG_ASSERT(scheme);
+        scheme->reset();
 
         Materials_ClearDefinitionLinks();
         Fonts_ClearDefinitionLinks();
@@ -1462,15 +1462,15 @@ void Def_PostInit(void)
     }
 
     // Detail textures.
-    Textures_ClearNamespace(TN_DETAILS);
+    Textures_ClearScheme(TS_DETAILS);
     for(int i = 0; i < defs.count.details.num; ++i)
     {
         R_CreateDetailTextureFromDef(&defs.details[i]);
     }
 
     // Lightmaps and flare textures.
-    Textures_ClearNamespace(TN_LIGHTMAPS);
-    Textures_ClearNamespace(TN_FLAREMAPS);
+    Textures_ClearScheme(TS_LIGHTMAPS);
+    Textures_ClearScheme(TS_FLAREMAPS);
     for(int i = 0; i < defs.count.lights.num; ++i)
     {
         ded_light_t* lig = &defs.lights[i];
@@ -1501,8 +1501,8 @@ void Def_PostInit(void)
     }
 
     // Surface reflections.
-    Textures_ClearNamespace(TN_REFLECTIONS);
-    Textures_ClearNamespace(TN_MASKS);
+    Textures_ClearScheme(TS_REFLECTIONS);
+    Textures_ClearScheme(TS_MASKS);
     for(int i = 0; i < defs.count.reflections.num; ++i)
     {
         ded_reflection_t* ref = &defs.reflections[i];
diff --git a/doomsday/engine/src/def_read.cpp b/doomsday/engine/src/def_read.cpp
index eb436f3806..b15277810a 100644
--- a/doomsday/engine/src/def_read.cpp
+++ b/doomsday/engine/src/def_read.cpp
@@ -810,9 +810,9 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
             CHECKSC;
 
             de::Uri newSearchPath = de::Uri::fromNativeDirPath(NativePath(label));
-            FS1::Namespace* fnamespace = App_FileSystem()->namespaceByName(DD_ResourceClassByName("RC_MODEL").defaultNamespace());
-            DENG_ASSERT(fnamespace);
-            fnamespace->addSearchPath(reinterpret_cast(newSearchPath), FS1::ExtraPaths);
+            FS1::Scheme* scheme = App_FileSystem()->schemeByName(DD_ResourceClassByName("RC_MODEL").defaultScheme());
+            DENG_ASSERT(scheme);
+            scheme->addSearchPath(reinterpret_cast(newSearchPath), FS1::ExtraPaths);
         }
 
         if(ISTOKEN("Header"))
@@ -1271,7 +1271,7 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                             for(;;)
                             {
                                 READLABEL;
-                                RV_URI("Texture", &st->texture, 0) // Default to "any" namespace.
+                                RV_URI("Texture", &st->texture, 0) // Default to "any" scheme.
                                 RV_INT("Tics", st->tics)
                                 RV_FLT("Rnd", st->variance)
                                 RV_VEC("Offset", st->texOrigin, 2)
@@ -1521,7 +1521,7 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                     {
                         READLABEL;
                         RV_URI("Material", &sl->material, 0)
-                        RV_URI("Texture", &sl->material, MN_TEXTURES_NAME )
+                        RV_URI("Texture", &sl->material, MS_TEXTURES_NAME )
                         RV_FLAGS("Flags", sl->flags, "slf_")
                         RV_FLT("Offset", sl->offset)
                         RV_FLT("Color limit", sl->colorLimit)
@@ -1632,7 +1632,7 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                     {
                         READLABEL;
                         RV_URI("Material", &sl->material, 0)
-                        RV_URI("Texture", &sl->material, MN_TEXTURES_NAME)
+                        RV_URI("Texture", &sl->material, MS_TEXTURES_NAME)
                         RV_FLAGS("Flags", sl->flags, "slf_")
                         RV_FLT("Offset", sl->offset)
                         RV_FLT("Color limit", sl->colorLimit)
@@ -1728,19 +1728,20 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                     READLABEL;
                     RV_STR("ID", tenv->id)
                     if(ISLABEL("Material") || ISLABEL("Texture") || ISLABEL("Flat"))
-                    {   // A new material path.
-                        ddstring_t mnamespace; Str_Init(&mnamespace);
-                        Str_Set(&mnamespace, ISLABEL("Material")? "" : ISLABEL("Texture")? MN_TEXTURES_NAME : MN_FLATS_NAME);
+                    {
+                        // A new material path.
+                        ddstring_t schemeName; Str_Init(&schemeName);
+                        Str_Set(&schemeName, ISLABEL("Material")? "" : ISLABEL("Texture")? MS_TEXTURES_NAME : MS_FLATS_NAME);
                         mn = (uri_s**) DED_NewEntry((void**)&tenv->materials, &tenv->count, sizeof(*mn));
                         FINDBEGIN;
                         for(;;)
                         {
                             READLABEL;
-                            RV_URI("ID", mn, Str_Text(&mnamespace))
+                            RV_URI("ID", mn, Str_Text(&schemeName))
                             RV_END
                             CHECKSC;
                         }
-                        Str_Free(&mnamespace);
+                        Str_Free(&schemeName);
                     }
                     else RV_END
                     CHECKSC;
@@ -1926,15 +1927,15 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 RV_FLAGS("Flags", dtl->flags, "dtf_")
                 if(ISLABEL("Texture"))
                 {
-                    READURI(&dtl->material1, MN_TEXTURES_NAME)
+                    READURI(&dtl->material1, MS_TEXTURES_NAME)
                 }
                 else if(ISLABEL("Wall")) // Alias
                 {
-                    READURI(&dtl->material1, MN_TEXTURES_NAME)
+                    READURI(&dtl->material1, MS_TEXTURES_NAME)
                 }
                 else if(ISLABEL("Flat"))
                 {
-                    READURI(&dtl->material2, MN_FLATS_NAME)
+                    READURI(&dtl->material2, MS_FLATS_NAME)
                 }
                 else if(ISLABEL("Lump"))
                 {
@@ -1991,11 +1992,11 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 }
                 else if(ISLABEL("Texture"))
                 {
-                    READURI(&ref->material, MN_TEXTURES_NAME)
+                    READURI(&ref->material, MS_TEXTURES_NAME)
                 }
                 else if(ISLABEL("Flat"))
                 {
-                    READURI(&ref->material, MN_FLATS_NAME)
+                    READURI(&ref->material, MS_FLATS_NAME)
                 }
                 else RV_END
                 CHECKSC;
@@ -2040,11 +2041,11 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 }
                 else if(ISLABEL("Flat"))
                 {
-                    READURI(&gen->material, MN_FLATS_NAME)
+                    READURI(&gen->material, MS_FLATS_NAME)
                 }
                 else if(ISLABEL("Texture"))
                 {
-                    READURI(&gen->material, MN_TEXTURES_NAME)
+                    READURI(&gen->material, MS_TEXTURES_NAME)
                 }
                 else
                 RV_STR("Mobj", gen->type)
@@ -2205,11 +2206,11 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 }
                 else if(ISLABEL("Texture"))
                 {
-                    READURI(&decor->material, MN_TEXTURES_NAME)
+                    READURI(&decor->material, MS_TEXTURES_NAME)
                 }
                 else if(ISLABEL("Flat"))
                 {
-                    READURI(&decor->material, MN_FLATS_NAME)
+                    READURI(&decor->material, MS_FLATS_NAME)
                 }
                 else if(ISLABEL("Light"))
                 {
@@ -2282,8 +2283,8 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 if(ISLABEL("Texture") || ISLABEL("Flat"))
                 {
                     ded_group_member_t* memb;
-                    ddstring_t mnamespace; Str_Init(&mnamespace);
-                    Str_Set(&mnamespace, ISLABEL("Texture")? MN_TEXTURES_NAME : MN_FLATS_NAME);
+                    ddstring_t schemeName; Str_Init(&schemeName);
+                    Str_Set(&schemeName, ISLABEL("Texture")? MS_TEXTURES_NAME : MS_FLATS_NAME);
 
                     // Need to allocate new stage?
                     if(sub >= grp->count.num)
@@ -2294,13 +2295,13 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                     for(;;)
                     {
                         READLABEL;
-                        RV_URI("ID", &memb->material, Str_Text(&mnamespace))
+                        RV_URI("ID", &memb->material, Str_Text(&schemeName))
                         RV_FLT("Tics", memb->tics)
                         RV_FLT("Random", memb->randomTics)
                         RV_END
                         CHECKSC;
                     }
-                    Str_Free(&mnamespace);
+                    Str_Free(&schemeName);
                     ++sub;
                 }
                 else RV_FLAGS("Flags", grp->flags, "tgf_")
@@ -2420,7 +2421,7 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 }
                 else if(ISLABEL("Act texture")) // Alias
                 {
-                    READURI(&l->actMaterial, MN_TEXTURES_NAME)
+                    READURI(&l->actMaterial, MS_TEXTURES_NAME)
                 }
                 else if(ISLABEL("Deact material"))
                 {
@@ -2428,7 +2429,7 @@ static int DED_ReadData(ded_t* ded, const char* buffer, const char* _sourceFile)
                 }
                 else if(ISLABEL("Deact texture")) // Alias
                 {
-                    READURI(&l->deactMaterial, MN_TEXTURES_NAME)
+                    READURI(&l->deactMaterial, MS_TEXTURES_NAME)
                 }
                 else
                 RV_INT("Act type", l->actLineType)
diff --git a/doomsday/engine/src/edit_map.cpp b/doomsday/engine/src/edit_map.cpp
index 318dbf0a8f..eb43ff1aaa 100644
--- a/doomsday/engine/src/edit_map.cpp
+++ b/doomsday/engine/src/edit_map.cpp
@@ -1826,7 +1826,7 @@ static void assignSurfaceMaterial(Surface* suf, ddstring_t const* materialUri)
         else
         {
             // No, attempt to resolve this URI and update the dictionary.
-            // First try the preferred namespace, then any.
+            // First try the preferred scheme, then any.
             materialid_t materialId = Materials_ResolveUriCString2(Str_Text(materialUri), true/*quiet please*/);
             if(materialId == NOMATERIALID)
             {
diff --git a/doomsday/engine/src/filesys/fs_main.cpp b/doomsday/engine/src/filesys/fs_main.cpp
index 26ae2912cf..156163d23c 100644
--- a/doomsday/engine/src/filesys/fs_main.cpp
+++ b/doomsday/engine/src/filesys/fs_main.cpp
@@ -109,8 +109,8 @@ struct FS1::Instance
     /// Virtual file-directory mapping.
     PathMappings pathMappings;
 
-    /// System subspaces containing a subset of the total files.
-    Namespaces namespaces;
+    /// System subspace schemes containing subsets of the total files.
+    Schemes schemes;
 
     Instance(FS1* d) : self(*d), loadingForStartup(true),
         openFiles(), loadedFiles(), fileIds(),
@@ -128,16 +128,16 @@ struct FS1::Instance
         pathMappings.clear();
         lumpMappings.clear();
 
-        clearNamespaces();
+        clearAllSchemes();
     }
 
-    void clearNamespaces()
+    void clearAllSchemes()
     {
-        DENG2_FOR_EACH(Namespaces, i, namespaces)
+        DENG2_FOR_EACH(Schemes, i, schemes)
         {
             delete *i;
         }
-        namespaces.clear();
+        schemes.clear();
     }
 
     /// @return  @c true if the FileId associated with @a path was released.
@@ -187,23 +187,23 @@ struct FS1::Instance
 
     String findPath(de::Uri const& search)
     {
-        // Within a namespace?
-        if(FS1::Namespace* fnamespace = self.namespaceByName(search.scheme()))
+        // Within a subspace scheme?
+        if(FS1::Scheme* scheme = self.schemeByName(search.scheme()))
         {
-            LOG_TRACE("Using namespace '%s'...") << fnamespace->name();
+            LOG_TRACE("Using scheme '%s'...") << scheme->name();
 
-            // Ensure the namespace is up to date.
-            fnamespace->rebuild();
+            // Ensure the scheme's index is up to date.
+            scheme->rebuild();
 
-            // The in-namespace name is the file name sans extension.
+            // The in-scheme name is the file name sans extension.
             String name = search.firstSegment().toString().fileNameWithoutExtension();
 
             // Perform the search.
-            FS1::Namespace::FoundNodes foundNodes;
-            if(fnamespace->findAll(name, foundNodes))
+            FS1::Scheme::FoundNodes foundNodes;
+            if(scheme->findAll(name, foundNodes))
             {
                 // At least one node name was matched (perhaps partially).
-                DENG2_FOR_EACH_CONST(FS1::Namespace::FoundNodes, i, foundNodes)
+                DENG2_FOR_EACH_CONST(FS1::Scheme::FoundNodes, i, foundNodes)
                 {
                     PathTree::Node& node = **i;
                     if(!node.comparePath(search, PCF_NO_BRANCH))
@@ -405,18 +405,18 @@ FS1::~FS1()
     FileHandleBuilder::shutdown();
 }
 
-FS1::Namespace& FS1::createNamespace(String name, Namespace::Flags flags)
+FS1::Scheme& FS1::createScheme(String name, Scheme::Flags flags)
 {
-    DENG_ASSERT(name.length() >= Namespace::min_name_length);
+    DENG_ASSERT(name.length() >= Scheme::min_name_length);
 
     // Ensure this is a unique name.
-    Namespace* fnamespace = namespaceByName(name);
-    if(fnamespace) return *fnamespace;
+    Scheme* scheme = schemeByName(name);
+    if(scheme) return *scheme;
 
-    // Create a new namespace.
-    fnamespace = new Namespace(name, flags);
-    d->namespaces.insert(name.toLower(), fnamespace);
-    return *fnamespace;
+    // Create a new scheme.
+    scheme = new Scheme(name, flags);
+    d->schemes.insert(name.toLower(), scheme);
+    return *scheme;
 }
 
 void FS1::consoleRegister()
@@ -1130,19 +1130,19 @@ void FS1::printDirectory(String path)
     }
 }
 
-FS1::Namespace* FS1::namespaceByName(String name)
+FS1::Scheme* FS1::schemeByName(String name)
 {
     if(!name.isEmpty())
     {
-        Namespaces::iterator found = d->namespaces.find(name.toLower());
-        if(found != d->namespaces.end()) return *found;
+        Schemes::iterator found = d->schemes.find(name.toLower());
+        if(found != d->schemes.end()) return *found;
     }
     return 0; // Not found.
 }
 
-FS1::Namespaces const& FS1::namespaces()
+FS1::Schemes const& FS1::schemes()
 {
-    return d->namespaces;
+    return d->schemes;
 }
 
 /// Print contents of directories as Doomsday sees them.
diff --git a/doomsday/engine/src/filesys/fs_namespace.cpp b/doomsday/engine/src/filesys/fs_scheme.cpp
similarity index 86%
rename from doomsday/engine/src/filesys/fs_namespace.cpp
rename to doomsday/engine/src/filesys/fs_scheme.cpp
index a267fc96ad..859109a650 100644
--- a/doomsday/engine/src/filesys/fs_namespace.cpp
+++ b/doomsday/engine/src/filesys/fs_scheme.cpp
@@ -1,7 +1,7 @@
 /**
- * @file fs_namespace.cpp
+ * @file fs_scheme.cpp
  *
- * File system namespace. @ingroup fs
+ * File system (subspace) scheme. @ingroup fs
  *
  * @author Copyright © 2003-2012 Jaakko Keränen 
  * @author Copyright © 2006-2012 Daniel Swanson 
@@ -161,18 +161,18 @@ struct NameHash
     }
 };
 
-struct FS1::Namespace::Instance
+struct FS1::Scheme::Instance
 {
-    FS1::Namespace& self;
+    FS1::Scheme& self;
 
     /// Symbolic name.
     String name;
 
     /// Flags which govern behavior.
-    FS1::Namespace::Flags flags;
+    FS1::Scheme::Flags flags;
 
     /// Associated path directory.
-    /// @todo It should not be necessary for a unique directory per namespace.
+    /// @todo It should not be necessary for a unique directory per scheme.
     PathTree directory;
 
     /// As the directory is relative, this special node serves as the root.
@@ -186,15 +186,15 @@ struct FS1::Namespace::Instance
 
     /// Sets of search paths to look for files to be included.
     /// Each set is in order of greatest-importance, right to left.
-    FS1::Namespace::SearchPaths searchPaths;
+    FS1::Scheme::SearchPaths searchPaths;
 
-    Instance(FS1::Namespace& d, String _name, FS1::Namespace::Flags _flags)
+    Instance(FS1::Scheme& d, String _name, FS1::Scheme::Flags _flags)
         : self(d), name(_name), flags(_flags), directory(), rootNode(0),
           nameHash(), nameHashIsDirty(true)
     {}
 
     /**
-     * Add files to this namespace by resolving search path, searching the
+     * Add files to this scheme by resolving search path, searching the
      * file system and populating our internal directory with the results.
      * Duplicates are automatically pruned.
      *
@@ -215,13 +215,13 @@ struct FS1::Namespace::Instance
     }
 
     /**
-     * Add files to this namespace by resolving each search path in @a group.
+     * Add files to this scheme by resolving each search path in @a group.
      *
      * @param group  Group of paths to search.
      */
     void addFromSearchPaths(FS1::PathGroup group)
     {
-        for(FS1::Namespace::SearchPaths::const_iterator i = searchPaths.find(group);
+        for(FS1::Scheme::SearchPaths::const_iterator i = searchPaths.find(group);
             i != searchPaths.end() && i.key() == group; ++i)
         {
             addFromSearchPath(*i);
@@ -325,22 +325,22 @@ struct FS1::Namespace::Instance
     }
 };
 
-FS1::Namespace::Namespace(String symbolicName, Flags flags)
+FS1::Scheme::Scheme(String symbolicName, Flags flags)
 {
     d = new Instance(*this, symbolicName, flags);
 }
 
-FS1::Namespace::~Namespace()
+FS1::Scheme::~Scheme()
 {
     delete d;
 }
 
-String const& FS1::Namespace::name() const
+String const& FS1::Scheme::name() const
 {
     return d->name;
 }
 
-void FS1::Namespace::clear()
+void FS1::Scheme::clear()
 {
     d->nameHash.clear();
     d->nameHashIsDirty = true;
@@ -348,12 +348,12 @@ void FS1::Namespace::clear()
     d->rootNode = 0;
 }
 
-void FS1::Namespace::rebuild()
+void FS1::Scheme::rebuild()
 {
     // Is a rebuild not necessary?
     if(!d->nameHashIsDirty) return;
 
-    LOG_AS("FS1::Namespace::rebuild");
+    LOG_AS("FS1::Scheme::rebuild");
     LOG_DEBUG("Rebuilding '%s'...") << d->name;
 
     // uint startTime = Timer_RealMilliseconds();
@@ -375,17 +375,17 @@ void FS1::Namespace::rebuild()
 #endif*/
 }
 
-static inline String composeNamespaceName(String const& filePath)
+static inline String composeSchemeName(String const& filePath)
 {
     return filePath.fileNameWithoutExtension();
 }
 
-bool FS1::Namespace::add(PathTree::Node& resourceNode)
+bool FS1::Scheme::add(PathTree::Node& resourceNode)
 {
     // We are only interested in leafs (i.e., files and not folders).
     if(!resourceNode.isLeaf()) return false;
 
-    String name = composeNamespaceName(resourceNode.name());
+    String name = composeSchemeName(resourceNode.name());
     NameHash::hash_type hashKey = NameHash::hashName(name);
 
     // Is this a new file?
@@ -408,8 +408,8 @@ bool FS1::Namespace::add(PathTree::Node& resourceNode)
         bucket.last = hashNode;
         if(!bucket.first) bucket.first = hashNode;
 
-        // We will need to rebuild this namespace (if we aren't already doing so,
-        // in the case of auto-populated namespaces built from FileDirectorys).
+        // We will need to rebuild this scheme (if we aren't already doing so,
+        // in the case of auto-populated schemes built from FileDirectorys).
         d->nameHashIsDirty = true;
     }
 
@@ -432,9 +432,9 @@ static String const& nameForPathGroup(FS1::PathGroup group)
     return names[int(group)];
 }
 
-bool FS1::Namespace::addSearchPath(SearchPath const& search, FS1::PathGroup group)
+bool FS1::Scheme::addSearchPath(SearchPath const& search, FS1::PathGroup group)
 {
-    LOG_AS("FS1::Namespace::addSearchPath");
+    LOG_AS("FS1::Scheme::addSearchPath");
 
     // Ensure this is a well formed path.
     if(search.isEmpty() ||
@@ -442,7 +442,7 @@ bool FS1::Namespace::addSearchPath(SearchPath const& search, FS1::PathGroup grou
        !search.path().endsWith("/"))
         return false;
 
-    // The addition of a new search path means the namespace is now dirty.
+    // The addition of a new search path means the scheme is now dirty.
     d->nameHashIsDirty = true;
 
     // Have we seen this path already (we don't want duplicates)?
@@ -459,28 +459,28 @@ bool FS1::Namespace::addSearchPath(SearchPath const& search, FS1::PathGroup grou
     // Prepend to the path list - newer paths have priority.
     d->searchPaths.insert(group, search);
 
-    LOG_DEBUG("'%s' path \"%s\" added to namespace '%s'.")
+    LOG_DEBUG("'%s' path \"%s\" added to scheme '%s'.")
         << nameForPathGroup(group) << search << name();
 
     return true;
 }
 
-void FS1::Namespace::clearSearchPathGroup(PathGroup group)
+void FS1::Scheme::clearSearchPathGroup(PathGroup group)
 {
     d->searchPaths.remove(group);
 }
 
-void FS1::Namespace::clearAllSearchPaths()
+void FS1::Scheme::clearAllSearchPaths()
 {
     d->searchPaths.clear();
 }
 
-FS1::Namespace::SearchPaths const& FS1::Namespace::searchPaths() const
+FS1::Scheme::SearchPaths const& FS1::Scheme::searchPaths() const
 {
     return d->searchPaths;
 }
 
-int FS1::Namespace::findAll(String name, FoundNodes& found)
+int FS1::Scheme::findAll(String name, FoundNodes& found)
 {
     int numFoundSoFar = found.count();
 
@@ -513,11 +513,11 @@ int FS1::Namespace::findAll(String name, FoundNodes& found)
     return found.count() - numFoundSoFar;
 }
 
-bool FS1::Namespace::mapPath(String& path) const
+bool FS1::Scheme::mapPath(String& path) const
 {
     if(path.isEmpty()) return false;
 
-    // Are virtual path mappings in effect for this namespace?
+    // Are virtual path mappings in effect for this scheme?
     if(!(d->flags & MappedInPackages)) return false;
 
     // Does this path qualify for mapping?
@@ -531,12 +531,12 @@ bool FS1::Namespace::mapPath(String& path) const
 }
 
 #if _DEBUG
-void FS1::Namespace::debugPrint() const
+void FS1::Scheme::debugPrint() const
 {
-    LOG_AS("FS1::Namespace::debugPrint");
+    LOG_AS("FS1::Scheme::debugPrint");
     LOG_DEBUG("[%p]:") << de::dintptr(this);
 
-    uint namespaceIdx = 0;
+    uint schemeIdx = 0;
     for(NameHash::hash_type key = 0; key < NameHash::hash_range; ++key)
     {
         NameHash::Bucket& bucket = d->nameHash.buckets[key];
@@ -545,15 +545,15 @@ void FS1::Namespace::debugPrint() const
             FileRef const& fileRef = node->fileRef;
 
             LOG_DEBUG("  %u - %u:\"%s\" => %s")
-                << namespaceIdx << key << fileRef.name()
+                << schemeIdx << key << fileRef.name()
                 << NativePath(fileRef.directoryNode().composePath()).pretty();
 
-            ++namespaceIdx;
+            ++schemeIdx;
         }
     }
 
-    LOG_DEBUG("  %u %s in namespace.") << namespaceIdx << (namespaceIdx == 1? "file" : "files");
+    LOG_DEBUG("  %u %s in scheme.") << schemeIdx << (schemeIdx == 1? "file" : "files");
 }
 #endif
 
-} // namespace de
+} // scheme de
diff --git a/doomsday/engine/src/gl/dgl_common.c b/doomsday/engine/src/gl/dgl_common.c
index cda7bf6c33..3de1fbf8c4 100644
--- a/doomsday/engine/src/gl/dgl_common.c
+++ b/doomsday/engine/src/gl/dgl_common.c
@@ -760,7 +760,7 @@ void DGL_SetMaterialUI(material_t* mat, DGLint wrapS, DGLint wrapT)
 
 void DGL_SetPatch(patchid_t id, DGLint wrapS, DGLint wrapT)
 {
-    Texture* tex = Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, id));
+    Texture* tex = Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, id));
     if(!tex) return;
     GL_BindTexture(GL_PreparePatchTexture2(tex, DGL_ToGLWrapCap(wrapS), DGL_ToGLWrapCap(wrapT)));
 }
diff --git a/doomsday/engine/src/gl/gl_texmanager.c b/doomsday/engine/src/gl/gl_texmanager.c
index 803b2f77b1..130e1eb760 100644
--- a/doomsday/engine/src/gl/gl_texmanager.c
+++ b/doomsday/engine/src/gl/gl_texmanager.c
@@ -530,7 +530,7 @@ static int pruneUnusedVariantSpecificationsInList(variantspecificationlist_t* li
     while(node)
     {
         texturevariantspecificationlist_node_t* next = node->next;
-        if(!Textures_Iterate2(TN_ANY, findTextureUsingVariantSpecificationWorker, (void*)node->spec))
+        if(!Textures_Iterate2(TS_ANY, findTextureUsingVariantSpecificationWorker, (void*)node->spec))
         {
             destroyVariantSpecification(node->spec);
             ++numPruned;
@@ -698,17 +698,17 @@ static TexSource loadSourceImage(Texture* tex, const texturevariantspecification
     assert(tex && baseSpec && image);
 
     spec = TS_GENERAL(baseSpec);
-    switch(Textures_Namespace(Textures_Id(tex)))
+    switch(Textures_Scheme(Textures_Id(tex)))
     {
-    case TN_FLATS:
+    case TS_FLATS:
         // Attempt to load an external replacement for this flat?
         if(!noHighResTex && (loadExtAlways || highResWithPWAD || !Texture_IsCustom(tex)))
         {
             const Str suffix = { "-ck" };
             AutoStr* path = Textures_ComposePath(Textures_Id(tex));
 
-            // First try the flats namespace then the old-fashioned "flat-name"
-            // in the textures namespace.
+            // First try the flats scheme then the old-fashioned "flat-name"
+            // in the textures scheme.
             AutoStr* searchPath = Str_Appendf(AutoStr_NewStd(), "Flats:%s", Str_Text(path));
             source = GL_LoadExtTextureEX(image, Str_Text(searchPath), Str_Text(&suffix), true/*quiet please*/);
 
@@ -742,7 +742,7 @@ static TexSource loadSourceImage(Texture* tex, const texturevariantspecification
         }
         break;
 
-    case TN_PATCHES: {
+    case TS_PATCHES: {
         int tclass = 0, tmap = 0;
         if(spec->flags & TSF_HAS_COLORPALETTE_XLAT)
         {
@@ -775,7 +775,7 @@ static TexSource loadSourceImage(Texture* tex, const texturevariantspecification
         }
         break; }
 
-    case TN_SPRITES: {
+    case TS_SPRITES: {
         int tclass = 0, tmap = 0;
         if(spec->flags & TSF_HAS_COLORPALETTE_XLAT)
         {
@@ -827,7 +827,7 @@ static TexSource loadSourceImage(Texture* tex, const texturevariantspecification
         }
         break; }
 
-    case TN_DETAILS: {
+    case TS_DETAILS: {
         const Uri* resourcePath = Textures_ResourcePath(Textures_Id(tex));
         if(Str_CompareIgnoreCase(Uri_Scheme(resourcePath), "Lumps"))
         {
@@ -846,20 +846,20 @@ static TexSource loadSourceImage(Texture* tex, const texturevariantspecification
         }
         break; }
 
-    case TN_SYSTEM:
-    case TN_REFLECTIONS:
-    case TN_MASKS:
-    case TN_LIGHTMAPS:
-    case TN_FLAREMAPS:
-    case TN_MODELSKINS:
-    case TN_MODELREFLECTIONSKINS: {
+    case TS_SYSTEM:
+    case TS_REFLECTIONS:
+    case TS_MASKS:
+    case TS_LIGHTMAPS:
+    case TS_FLAREMAPS:
+    case TS_MODELSKINS:
+    case TS_MODELREFLECTIONSKINS: {
         const Uri* resourcePath = Textures_ResourcePath(Textures_Id(tex));
         AutoStr* path = Uri_Compose(resourcePath);
         source = GL_LoadExtTextureEX(image, Str_Text(path), NULL, true/*quiet please*/);
         break; }
 
     default:
-        Con_Error("Textures::loadSourceImage: Unknown texture namespace %i.", (int) Textures_Namespace(Textures_Id(tex)));
+        Con_Error("Textures::loadSourceImage: Unknown texture scheme %i.", (int) Textures_Scheme(Textures_Id(tex)));
         exit(1); // Unreachable.
     }
     return source;
@@ -1357,7 +1357,7 @@ void GL_ReleaseSystemTextures(void)
     }
     memset(sysFlareTextures, 0, sizeof(sysFlareTextures));
 
-    GL_ReleaseTexturesByNamespace(TN_SYSTEM);
+    GL_ReleaseTexturesByScheme(TS_SYSTEM);
 
     UI_ReleaseTextures();
     Rend_ParticleReleaseSystemTextures();
@@ -1377,17 +1377,17 @@ void GL_ReleaseRuntimeTextures(void)
     RL_DeleteLists();
 
     // texture-wrapped GL textures; textures, flats, sprites...
-    GL_ReleaseTexturesByNamespace(TN_FLATS);
-    GL_ReleaseTexturesByNamespace(TN_TEXTURES);
-    GL_ReleaseTexturesByNamespace(TN_PATCHES);
-    GL_ReleaseTexturesByNamespace(TN_SPRITES);
-    GL_ReleaseTexturesByNamespace(TN_DETAILS);
-    GL_ReleaseTexturesByNamespace(TN_REFLECTIONS);
-    GL_ReleaseTexturesByNamespace(TN_MASKS);
-    GL_ReleaseTexturesByNamespace(TN_MODELSKINS);
-    GL_ReleaseTexturesByNamespace(TN_MODELREFLECTIONSKINS);
-    GL_ReleaseTexturesByNamespace(TN_LIGHTMAPS);
-    GL_ReleaseTexturesByNamespace(TN_FLAREMAPS);
+    GL_ReleaseTexturesByScheme(TS_FLATS);
+    GL_ReleaseTexturesByScheme(TS_TEXTURES);
+    GL_ReleaseTexturesByScheme(TS_PATCHES);
+    GL_ReleaseTexturesByScheme(TS_SPRITES);
+    GL_ReleaseTexturesByScheme(TS_DETAILS);
+    GL_ReleaseTexturesByScheme(TS_REFLECTIONS);
+    GL_ReleaseTexturesByScheme(TS_MASKS);
+    GL_ReleaseTexturesByScheme(TS_MODELSKINS);
+    GL_ReleaseTexturesByScheme(TS_MODELREFLECTIONSKINS);
+    GL_ReleaseTexturesByScheme(TS_LIGHTMAPS);
+    GL_ReleaseTexturesByScheme(TS_FLAREMAPS);
     GL_ReleaseTexturesForRawImages();
 
     Rend_ParticleReleaseExtraTextures();
@@ -2573,7 +2573,7 @@ TexSource GL_LoadPatchComposite(image_t* image, Texture* tex)
     assert(image && tex);
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(tex)) != TN_TEXTURES)
+    if(Textures_Scheme(Textures_Id(tex)) != TS_TEXTURES)
         Con_Error("GL_LoadPatchComposite: Internal error, texture [%p id:%i] is not a PatchCompositeTex!", (void*)tex, Textures_Id(tex));
 #endif
     texDef = (patchcompositetex_t*)Texture_UserDataPointer(tex);
@@ -2627,7 +2627,7 @@ TexSource GL_LoadPatchCompositeAsSky(image_t* image, Texture* tex, boolean zeroM
     assert(image && tex);
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(tex)) != TN_TEXTURES)
+    if(Textures_Scheme(Textures_Id(tex)) != TS_TEXTURES)
         Con_Error("GL_LoadPatchCompositeAsSky: Internal error, texture [%p id:%i] is not a PatchCompositeTex!", (void*)tex, Textures_Id(tex));
 #endif
     texDef = (patchcompositetex_t*)Texture_UserDataPointer(tex);
@@ -2851,7 +2851,7 @@ TextureVariant* GL_PreparePatchTexture2(Texture* tex, int wrapS, int wrapT)
     texturevariantspecification_t* texSpec;
     patchtex_t* pTex;
     if(novideo || !tex) return 0;
-    if(Textures_Namespace(Textures_Id(tex)) != TN_PATCHES)
+    if(Textures_Scheme(Textures_Id(tex)) != TS_PATCHES)
     {
 #if _DEBUG
         Con_Message("Warning:GL_PreparePatchTexture: Attempted to prepare non-patch [%p].\n", (void*)tex);
@@ -3039,7 +3039,7 @@ void GL_DoTexReset(void)
 
 void GL_DoResetDetailTextures(void)
 {
-    GL_ReleaseTexturesByNamespace(TN_DETAILS);
+    GL_ReleaseTexturesByScheme(TS_DETAILS);
 }
 
 void GL_ReleaseTexturesForRawImages(void)
@@ -3085,7 +3085,7 @@ void GL_SetAllTexturesMinFilter(int minFilter)
     /// @todo This is no longer correct logic. Changing the global minification
     ///        filter should not modify the uploaded texture content.
 #if 0
-    Textures_Iterate2(TN_ANY, setVariantMinFilterWorker, (void*)&localMinFilter);
+    Textures_Iterate2(TS_ANY, setVariantMinFilterWorker, (void*)&localMinFilter);
 #endif
 }
 
@@ -3298,7 +3298,7 @@ static boolean tryLoadImageAndPrepareVariant(Texture* tex,
     assert(initedOk && spec);
 
     // Load the source image data.
-    if(TN_TEXTURES == Textures_Namespace(Textures_Id(tex)))
+    if(TS_TEXTURES == Textures_Scheme(Textures_Id(tex)))
     {
         // Try to load a replacement version of this texture?
         if(!noHighResTex && (loadExtAlways || highResWithPWAD || !Texture_IsCustom(tex)))
@@ -3542,9 +3542,9 @@ int GL_ReleaseGLTexturesByTexture(Texture* tex)
     return GL_ReleaseGLTexturesByTexture2(tex, NULL);
 }
 
-void GL_ReleaseTexturesByNamespace(texturenamespaceid_t texNamespace)
+void GL_ReleaseTexturesByScheme(textureschemeid_t schemeId)
 {
-    Textures_Iterate(texNamespace, GL_ReleaseGLTexturesByTexture2);
+    Textures_Iterate(schemeId, GL_ReleaseGLTexturesByTexture2);
 }
 
 void GL_ReleaseVariantTexturesBySpec(Texture* tex, texturevariantspecification_t* spec)
@@ -3574,7 +3574,7 @@ static int releaseGLTexturesByColorPaletteWorker(Texture* tex, void* paramaters)
 
 void GL_ReleaseTexturesByColorPalette(colorpaletteid_t paletteId)
 {
-    Textures_Iterate2(TN_ANY, releaseGLTexturesByColorPaletteWorker, (void*)&paletteId);
+    Textures_Iterate2(TS_ANY, releaseGLTexturesByColorPaletteWorker, (void*)&paletteId);
 }
 
 void GL_InitTextureContent(texturecontent_t* content)
@@ -3671,7 +3671,7 @@ AutoStr* GL_ComposeCacheNameForTexture(Texture* tex)
     textureid_t texId = Textures_Id(tex);
     AutoStr* path = Textures_ComposePath(texId);
     AutoStr* cacheName = Str_Appendf(AutoStr_NewStd(), "texcache/%s/%s.png",
-                                     Str_Text(Textures_NamespaceName(Textures_Namespace(texId))), Str_Text(path));
+                                     Str_Text(Textures_SchemeName(Textures_Scheme(texId))), Str_Text(path));
     return cacheName;
 }
 
diff --git a/doomsday/engine/src/map/r_world.c b/doomsday/engine/src/map/r_world.c
index 86f63f51b6..f8b036ca95 100644
--- a/doomsday/engine/src/map/r_world.c
+++ b/doomsday/engine/src/map/r_world.c
@@ -1735,7 +1735,7 @@ static material_t* chooseFixMaterial(SideDef* s, SideDefSection section)
     if(choice2) return choice2;
 
     // We'll assign the special "missing" material...
-    return Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":missing"));
+    return Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":missing"));
 }
 
 static void addMissingMaterial(SideDef* s, SideDefSection section)
diff --git a/doomsday/engine/src/render/r_draw.c b/doomsday/engine/src/render/r_draw.c
index d80f749377..dd8dacb1e3 100644
--- a/doomsday/engine/src/render/r_draw.c
+++ b/doomsday/engine/src/render/r_draw.c
@@ -159,7 +159,7 @@ void R_ShutdownViewWindow(void)
 void R_DrawPatch3(Texture* tex, int x, int y, int w, int h, boolean useOffsets)
 {
     if(!tex) return;
-    if(Textures_Namespace(Textures_Id(tex)) != TN_PATCHES)
+    if(Textures_Scheme(Textures_Id(tex)) != TS_PATCHES)
     {
 #if _DEBUG
         Con_Message("Warning:R_DrawPatch3: Attempted to draw a non-patch [%p].\n", (void*)tex);
@@ -252,10 +252,10 @@ void R_DrawViewBorder(void)
 
     if(border != 0)
     {
-        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_TOP])), vd->window.origin.x, vd->window.origin.y - border, vd->window.size.width, border, GL_REPEAT, GL_CLAMP_TO_EDGE);
-        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_BOTTOM])), vd->window.origin.x, vd->window.origin.y + vd->window.size.height , vd->window.size.width, border, GL_REPEAT, GL_CLAMP_TO_EDGE);
-        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_LEFT])), vd->window.origin.x - border, vd->window.origin.y, border, vd->window.size.height, GL_CLAMP_TO_EDGE, GL_REPEAT);
-        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_RIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y, border, vd->window.size.height, GL_CLAMP_TO_EDGE, GL_REPEAT);
+        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_TOP])), vd->window.origin.x, vd->window.origin.y - border, vd->window.size.width, border, GL_REPEAT, GL_CLAMP_TO_EDGE);
+        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_BOTTOM])), vd->window.origin.x, vd->window.origin.y + vd->window.size.height , vd->window.size.width, border, GL_REPEAT, GL_CLAMP_TO_EDGE);
+        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_LEFT])), vd->window.origin.x - border, vd->window.origin.y, border, vd->window.size.height, GL_CLAMP_TO_EDGE, GL_REPEAT);
+        R_DrawPatchTiled(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_RIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y, border, vd->window.size.height, GL_CLAMP_TO_EDGE, GL_REPEAT);
     }
 
     glMatrixMode(GL_TEXTURE);
@@ -263,10 +263,10 @@ void R_DrawViewBorder(void)
 
     if(border != 0)
     {
-        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_TOPLEFT])), vd->window.origin.x - border, vd->window.origin.y - border, border, border, false);
-        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_TOPRIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y - border, border, border, false);
-        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_BOTTOMRIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y + vd->window.size.height, border, border, false);
-        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, borderPatches[BG_BOTTOMLEFT])), vd->window.origin.x - border, vd->window.origin.y + vd->window.size.height, border, border, false);
+        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_TOPLEFT])), vd->window.origin.x - border, vd->window.origin.y - border, border, border, false);
+        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_TOPRIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y - border, border, border, false);
+        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_BOTTOMRIGHT])), vd->window.origin.x + vd->window.size.width, vd->window.origin.y + vd->window.size.height, border, border, false);
+        R_DrawPatch3(Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, borderPatches[BG_BOTTOMLEFT])), vd->window.origin.x - border, vd->window.origin.y + vd->window.size.height, border, border, false);
     }
 
     glDisable(GL_TEXTURE_2D);
diff --git a/doomsday/engine/src/render/r_lumobjs.c b/doomsday/engine/src/render/r_lumobjs.c
index 62e6a30e6f..0dec709dd4 100644
--- a/doomsday/engine/src/render/r_lumobjs.c
+++ b/doomsday/engine/src/render/r_lumobjs.c
@@ -772,7 +772,7 @@ static void addLuminous(mobj_t* mo)
     }
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TN_SPRITES)
+    if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TS_SPRITES)
         Con_Error("LO_AddLuminous: Internal error, material snapshot's primary texture is not a SpriteTex!");
 #endif
 
diff --git a/doomsday/engine/src/render/r_things.c b/doomsday/engine/src/render/r_things.c
index 5ade565776..69ba035eaa 100644
--- a/doomsday/engine/src/render/r_things.c
+++ b/doomsday/engine/src/render/r_things.c
@@ -372,7 +372,7 @@ static int buildSpriteRotationsWorker(textureid_t texId, void* parameters)
         link = true;
     }
 
-    uri = Uri_NewWithPath2(MN_SPRITES_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_SPRITES_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(path));
     frame->mat = Materials_ToMaterial(Materials_ResolveUri(uri));
     Uri_Delete(uri);
@@ -427,7 +427,7 @@ static void buildSpriteRotations(void)
     spriteRecordBlockSet = BlockSet_New(sizeof(spriterecord_t), 64),
     spriteRecordFrameBlockSet = BlockSet_New(sizeof(spriterecord_frame_t), 256);
 
-    Textures_IterateDeclared(TN_SPRITES, buildSpriteRotationsWorker);
+    Textures_IterateDeclared(TS_SPRITES, buildSpriteRotationsWorker);
 
     VERBOSE2( Con_Message("buildSpriteRotations: Done in %.2f seconds.\n", (Timer_RealMilliseconds() - startTime) / 1000.0f) )
 }
@@ -647,7 +647,7 @@ boolean R_GetSpriteInfo(int sprite, int frame, spriteinfo_t* info)
     ms = Materials_Prepare(mat, spec, false);
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TN_SPRITES)
+    if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TS_SPRITES)
         Con_Error("R_GetSpriteInfo: Internal error, material snapshot's primary texture is not a SpriteTex!");
 #endif
 
@@ -1256,7 +1256,7 @@ void R_ProjectSprite(mobj_t* mo)
     ms   = Materials_Prepare(mat, spec, true);
 
     // An invalid sprite texture?
-    if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TN_SPRITES) return;
+    if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TS_SPRITES) return;
 
     pTex = (patchtex_t*) Texture_UserDataPointer(MSU_texture(ms, MTU_PRIMARY));
     assert(pTex);
diff --git a/doomsday/engine/src/render/rend_main.c b/doomsday/engine/src/render/rend_main.c
index 0f3bb17f3b..9834e61671 100644
--- a/doomsday/engine/src/render/rend_main.c
+++ b/doomsday/engine/src/render/rend_main.c
@@ -1675,13 +1675,13 @@ static boolean rendHEdgeSection(HEdge* hedge, SideDefSection section,
             if(renderTextures == 2)
             {
                 // Lighting debug mode; render using System:gray.
-                mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+                mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
             }
             else if(!surface->material ||
                     ((surface->inFlags & SUIF_FIX_MISSING_MATERIAL) && devNoTexFix))
             {
                 // Missing material debug mode; render using System:missing.
-                mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":missing"));
+                mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":missing"));
             }
             else
             {
@@ -2796,10 +2796,10 @@ static void Rend_RenderPlanes(void)
         else if(texMode == 1)
             // For debug, render the "missing" texture instead of the texture
             // chosen for surfaces to fix the HOMs.
-            mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":missing"));
+            mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":missing"));
         else
             // For lighting debug, render all solid surfaces using the gray texture.
-            mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+            mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
 
         V2f_Copy(texOffset, suf->visOffset);
         // Add the Y offset to orient the Y flipped texture.
@@ -3970,7 +3970,7 @@ static void Rend_RenderBoundingBoxes(void)
     glEnable(GL_TEXTURE_2D);
     glDisable(GL_CULL_FACE);
 
-    mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":bbox"));
+    mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":bbox"));
     spec = Materials_VariantSpecificationForContext(MC_SPRITE, 0, 0, 0, 0,
         GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, 1, -2, -1, true, true, true, false);
     ms = Materials_Prepare(mat, spec, true);
diff --git a/doomsday/engine/src/render/rend_model.c b/doomsday/engine/src/render/rend_model.c
index dc25e351c7..aa654ad99d 100644
--- a/doomsday/engine/src/render/rend_model.c
+++ b/doomsday/engine/src/render/rend_model.c
@@ -1161,7 +1161,7 @@ static void Mod_RenderSubModel(uint number, const rendmodelparams_t* params)
     if(renderTextures == 2)
     {
         // For lighting debug, render all surfaces using the gray texture.
-        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
         if(mat)
         {
             const materialvariantspecification_t* spec = Materials_VariantSpecificationForContext(
diff --git a/doomsday/engine/src/render/rend_sky.c b/doomsday/engine/src/render/rend_sky.c
index 9de646436a..c92c16f70a 100644
--- a/doomsday/engine/src/render/rend_sky.c
+++ b/doomsday/engine/src/render/rend_sky.c
@@ -255,14 +255,14 @@ static void configureRenderHemisphereStateForLayer(int layer, hemispherecap_t se
 
         if(renderTextures == 2)
         {
-            mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+            mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
         }
         else
         {
             mat = R_SkyLayerMaterial(layer);
             if(!mat)
             {
-                mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":missing"));
+                mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":missing"));
                 rs.texXFlip = false;
             }
         }
diff --git a/doomsday/engine/src/render/rend_sprite.c b/doomsday/engine/src/render/rend_sprite.c
index efdc95abbb..858409a599 100644
--- a/doomsday/engine/src/render/rend_sprite.c
+++ b/doomsday/engine/src/render/rend_sprite.c
@@ -345,7 +345,7 @@ static void setupPSpriteParams(rendpspriteparams_t* params, vispsprite_t* spr)
     ms = Materials_Prepare(sprFrame->mats[0], spec, true);
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TN_SPRITES)
+    if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TS_SPRITES)
         Con_Error("setupPSpriteParams: Internal error, material snapshot's primary texture is not a SpriteTex!");
 #endif
 
@@ -430,7 +430,7 @@ void Rend_DrawPSprite(const rendpspriteparams_t *params)
     }
     else if(renderTextures == 2)
     {   // For lighting debug, render all solid surfaces using the gray texture.
-        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
         const materialvariantspecification_t* spec = Materials_VariantSpecificationForContext(
             MC_SPRITE, 0, 0, 0, 0, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, 1, -2, 0, false, true, true, false);
         const materialsnapshot_t* ms = Materials_Prepare(mat, spec, true);
@@ -910,7 +910,7 @@ static MaterialVariant* chooseSpriteMaterial(const rendspriteparams_t* p)
     if(renderTextures == 2)
     {
         // For lighting debug, render all solid surfaces using the gray texture.
-        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MN_SYSTEM_NAME":gray"));
+        material_t* mat = Materials_ToMaterial(Materials_ResolveUriCString(MS_SYSTEM_NAME":gray"));
         const materialvariantspecification_t* spec = Materials_VariantSpecificationForContext(
             MC_SPRITE, 0, 0, 0, 0, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE,
             1, -2, -1, true, true, false, false);
@@ -961,7 +961,7 @@ void Rend_RenderSprite(const rendspriteparams_t* params)
 
         TextureVariant_Coords(MST(ms, MTU_PRIMARY), &s, &t);
 
-        if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) == TN_SPRITES)
+        if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) == TS_SPRITES)
         {
             pTex = (patchtex_t*) Texture_UserDataPointer(MSU_texture(ms, MTU_PRIMARY));
             assert(pTex);
diff --git a/doomsday/engine/src/resource/bitmapfont.c b/doomsday/engine/src/resource/bitmapfont.c
index e1e6bb71bb..880050003c 100644
--- a/doomsday/engine/src/resource/bitmapfont.c
+++ b/doomsday/engine/src/resource/bitmapfont.c
@@ -559,7 +559,7 @@ void BitmapCompositeFont_Prepare(font_t* font)
         ch->geometry.size.height += font->_marginHeight * 2;
         ch->border = 0;
 
-        texId = Textures_TextureForUniqueId(TN_PATCHES, patch);
+        texId = Textures_TextureForUniqueId(TS_PATCHES, patch);
         ch->tex = GL_PrepareTextureVariant(Textures_ToTexture(texId), BitmapCompositeFont_CharSpec());
         if(ch->tex && TextureVariant_Source(ch->tex) == TEXS_ORIGINAL)
         {
diff --git a/doomsday/engine/src/resource/fonts.cpp b/doomsday/engine/src/resource/fonts.cpp
index ee1cefd5fe..3959e6ec1b 100644
--- a/doomsday/engine/src/resource/fonts.cpp
+++ b/doomsday/engine/src/resource/fonts.cpp
@@ -48,19 +48,19 @@ typedef de::PathTree FontRepository;
  */
 struct FontRecord
 {
-    /// Namespace-unique identifier chosen by the owner of the collection.
+    /// Scheme-unique identifier chosen by the owner of the collection.
     int uniqueId;
 
     /// The defined font instance (if any).
     font_t* font;
 };
 
-struct FontNamespace
+struct FontScheme
 {
     /// FontRepository contains mappings between names and unique font records.
     FontRepository* repository;
 
-    /// LUT which translates namespace-unique-ids to their associated fontid_t (if any).
+    /// LUT which translates scheme-unique-ids to their associated fontid_t (if any).
     /// Index with uniqueId - uniqueIdBase.
     int uniqueIdBase;
     bool uniqueIdMapDirty;
@@ -73,7 +73,7 @@ D_CMD(ListFonts);
 D_CMD(PrintFontStats);
 #endif
 
-static int iterateDirectory(fontnamespaceid_t namespaceId,
+static int iterateDirectory(fontschemeid_t schemeId,
     int (*callback)(FontRepository::Node& node, void* parameters), void* parameters);
 
 static de::Uri* emptyUri;
@@ -82,8 +82,8 @@ static de::Uri* emptyUri;
 static uint fontIdMapSize;
 static FontRepository::Node** fontIdMap;
 
-// Font namespace set.
-static FontNamespace namespaces[FONTNAMESPACE_COUNT];
+// Font scheme set.
+static FontScheme schemes[FONTSCHEME_COUNT];
 
 void Fonts_Register(void)
 {
@@ -93,22 +93,22 @@ void Fonts_Register(void)
 #endif
 }
 
-static inline FontRepository* repositoryByNamespaceId(fontnamespaceid_t id)
+static inline FontRepository* repositoryBySchemeId(fontschemeid_t id)
 {
-    DENG_ASSERT(VALID_FONTNAMESPACEID(id));
-    return namespaces[id - FONTNAMESPACE_FIRST].repository;
+    DENG_ASSERT(VALID_FONTSCHEMEID(id));
+    return schemes[id - FONTSCHEME_FIRST].repository;
 }
 
-static fontnamespaceid_t namespaceIdForRepository(FontRepository& pt)
+static fontschemeid_t schemeIdForRepository(FontRepository& pt)
 {
-    for(uint i = uint(FONTNAMESPACE_FIRST); i <= uint(FONTNAMESPACE_LAST); ++i)
+    for(uint i = uint(FONTSCHEME_FIRST); i <= uint(FONTSCHEME_LAST); ++i)
     {
-        uint idx = i - FONTNAMESPACE_FIRST;
-        if(namespaces[idx].repository == &pt) return fontnamespaceid_t(i);
+        uint idx = i - FONTSCHEME_FIRST;
+        if(schemes[idx].repository == &pt) return fontschemeid_t(i);
     }
     // Only reachable if attempting to find the id for a Font that is not
     // in the collection, or the collection has not yet been initialized.
-    Con_Error("Fonts::namespaceIdForRepository: Failed to determine id for directory %p.", (void*)&pt);
+    Con_Error("Fonts::schemeIdForRepository: Failed to determine id for directory %p.", (void*)&pt);
     exit(1); // Unreachable.
 }
 
@@ -134,16 +134,16 @@ static fontid_t findBindIdForDirectoryNode(FontRepository::Node const& node)
     return NOFONTID; // Not linked.
 }
 
-static inline fontnamespaceid_t namespaceIdForDirectoryNode(FontRepository::Node const& node)
+static inline fontschemeid_t schemeIdForDirectoryNode(FontRepository::Node const& node)
 {
-    return namespaceIdForRepository(node.tree());
+    return schemeIdForRepository(node.tree());
 }
 
 /// @return  Newly composed Uri for @a node. Must be released with Uri_Delete()
 static de::Uri composeUriForDirectoryNode(FontRepository::Node const& node)
 {
-    Str const* namespaceName = Fonts_NamespaceName(namespaceIdForDirectoryNode(node));
-    return node.composeUri().setScheme(Str_Text(namespaceName));
+    Str const* schemeName = Fonts_SchemeName(schemeIdForDirectoryNode(node));
+    return node.composeUri().setScheme(Str_Text(schemeName));
 }
 
 /// @pre fontIdMap has been initialized and is large enough!
@@ -160,8 +160,8 @@ static int linkRecordInUniqueIdMap(FontRepository::Node& node, void* parameters)
     DENG_UNUSED(parameters);
 
     FontRecord const* record = (FontRecord*) node.userPointer();
-    fontnamespaceid_t const namespaceId = namespaceIdForRepository(node.tree());
-    FontNamespace& fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
+    fontschemeid_t const schemeId = schemeIdForRepository(node.tree());
+    FontScheme& fn = schemes[schemeId - FONTSCHEME_FIRST];
     fn.uniqueIdMap[record->uniqueId - fn.uniqueIdBase] = findBindIdForDirectoryNode(node);
     return 0; // Continue iteration.
 }
@@ -172,8 +172,8 @@ static int unlinkRecordInUniqueIdMap(FontRepository::Node& node, void* parameter
     DENG_UNUSED(parameters);
 
     FontRecord const* record = (FontRecord*) node.userPointer();
-    fontnamespaceid_t const namespaceId = namespaceIdForRepository(node.tree());
-    FontNamespace& fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
+    fontschemeid_t const schemeId = schemeIdForRepository(node.tree());
+    FontScheme& fn = schemes[schemeId - FONTSCHEME_FIRST];
     if(fn.uniqueIdMap)
     {
         fn.uniqueIdMap[record->uniqueId - fn.uniqueIdBase] = NOFONTID;
@@ -186,7 +186,7 @@ static int unlinkRecordInUniqueIdMap(FontRepository::Node& node, void* parameter
  * @ingroup flags
  */
 ///@{
-#define VFUF_ALLOW_NAMESPACE_ANY    0x1 ///< The namespace of the uri may be of zero-length; signifying "any namespace".
+#define VFUF_ALLOW_ANY_SCHEME       0x1 ///< The scheme of the uri may be of zero-length; signifying "any scheme".
 #define VFUF_NO_URN                 0x2 ///< Do not accept a URN.
 ///@}
 
@@ -210,25 +210,25 @@ static bool validateUri(de::Uri const& uri, int flags, bool quiet = false)
         return false;
     }
 
-    // If this is a URN we extract the namespace from the path.
-    de::String namespaceString;
+    // If this is a URN we extract the scheme from the path.
+    de::String schemeString;
     if(!uri.scheme().compareWithoutCase("urn"))
     {
         if(flags & VFUF_NO_URN) return false;
-        namespaceString = uri.path();
+        schemeString = uri.path();
     }
     else
     {
-        namespaceString = uri.scheme();
+        schemeString = uri.scheme();
     }
 
-    fontnamespaceid_t namespaceId = Fonts_ParseNamespace(namespaceString.toUtf8().constData());
-    if(!((flags & VFUF_ALLOW_NAMESPACE_ANY) && namespaceId == FN_ANY) &&
-       !VALID_FONTNAMESPACEID(namespaceId))
+    fontschemeid_t schemeId = Fonts_ParseScheme(schemeString.toUtf8().constData());
+    if(!((flags & VFUF_ALLOW_ANY_SCHEME) && schemeId == FS_ANY) &&
+       !VALID_FONTSCHEMEID(schemeId))
     {
         if(!quiet)
         {
-            LOG_MSG("Unknown namespace in Font uri \"%s\".") << uri;
+            LOG_MSG("Unknown scheme in Font uri \"%s\".") << uri;
         }
         return false;
     }
@@ -239,7 +239,7 @@ static bool validateUri(de::Uri const& uri, int flags, bool quiet = false)
 /**
  * Given a directory and path, search the Fonts collection for a match.
  *
- * @param directory  Namespace-specific PathTree to search in.
+ * @param directory  Scheme-specific PathTree to search in.
  * @param path  Path of the font to search for.
  * @return  Found DirectoryNode else @c NULL
  */
@@ -260,13 +260,13 @@ static FontRepository::Node* findDirectoryNodeForUri(de::Uri const& uri)
 {
     if(!uri.scheme().compareWithoutCase("urn"))
     {
-        // This is a URN of the form; urn:namespacename:uniqueid
-        fontnamespaceid_t namespaceId = Fonts_ParseNamespace(uri.pathCStr());
+        // This is a URN of the form; urn:schemename:uniqueid
+        fontschemeid_t schemeId = Fonts_ParseScheme(uri.pathCStr());
         int uidPos = uri.path().indexOf(':');
         if(uidPos >= 0)
         {
-            int uid = uri.path().mid(uidPos + 1/*skip namespace delimiter*/).toInt();
-            fontid_t id = Fonts_FontForUniqueId(namespaceId, uid);
+            int uid = uri.path().mid(uidPos + 1/*skip scheme delimiter*/).toInt();
+            fontid_t id = Fonts_FontForUniqueId(schemeId, uid);
             if(id != NOFONTID)
             {
                 return findDirectoryNodeForBindId(id);
@@ -276,26 +276,26 @@ static FontRepository::Node* findDirectoryNodeForUri(de::Uri const& uri)
     }
 
     // This is a URI.
-    fontnamespaceid_t namespaceId = Fonts_ParseNamespace(uri.schemeCStr());
+    fontschemeid_t schemeId = Fonts_ParseScheme(uri.schemeCStr());
     de::String const& path = uri.path();
-    if(namespaceId != FN_ANY)
+    if(schemeId != FS_ANY)
     {
-        // Caller wants a font in a specific namespace.
-        return findDirectoryNodeForPath(*repositoryByNamespaceId(namespaceId), path);
+        // Caller wants a font in a specific scheme.
+        return findDirectoryNodeForPath(*repositoryBySchemeId(schemeId), path);
     }
 
-    // Caller does not care which namespace.
-    // Check for the font in these namespaces in priority order.
-    static const fontnamespaceid_t order[] = {
-        FN_GAME, FN_SYSTEM, FN_ANY
+    // Caller does not care which scheme.
+    // Check for the font in these schemes in priority order.
+    static const fontschemeid_t order[] = {
+        FS_GAME, FS_SYSTEM, FS_ANY
     };
 
     FontRepository::Node* node = NULL;
     int n = 0;
     do
     {
-        node = findDirectoryNodeForPath(*repositoryByNamespaceId(order[n]), path);
-    } while(!node && order[++n] != FN_ANY);
+        node = findDirectoryNodeForPath(*repositoryBySchemeId(order[n]), path);
+    } while(!node && order[++n] != FS_ANY);
     return node;
 }
 
@@ -366,9 +366,9 @@ void Fonts_Init(void)
     fontIdMap = 0;
     fontIdMapSize = 0;
 
-    for(int i = 0; i < FONTNAMESPACE_COUNT; ++i)
+    for(int i = 0; i < FONTSCHEME_COUNT; ++i)
     {
-        FontNamespace& fn = namespaces[i];
+        FontScheme& fn = schemes[i];
         fn.repository = new FontRepository();
         fn.uniqueIdBase = 0;
         fn.uniqueIdMapSize = 0;
@@ -388,9 +388,9 @@ void Fonts_Shutdown(void)
 {
     Fonts_Clear();
 
-    for(int i = 0; i < FONTNAMESPACE_COUNT; ++i)
+    for(int i = 0; i < FONTSCHEME_COUNT; ++i)
     {
-        FontNamespace& fn = namespaces[i];
+        FontScheme& fn = schemes[i];
 
         if(fn.repository)
         {
@@ -419,47 +419,47 @@ void Fonts_Shutdown(void)
     }
 }
 
-fontnamespaceid_t Fonts_ParseNamespace(char const* str)
+fontschemeid_t Fonts_ParseScheme(char const* str)
 {
-    static const struct namespace_s {
+    static const struct scheme_s {
         const char* name;
         size_t nameLen;
-        fontnamespaceid_t id;
-    } namespaces[FONTNAMESPACE_COUNT+1] = {
+        fontschemeid_t id;
+    } schemes[FONTSCHEME_COUNT+1] = {
         // Ordered according to a best guess of occurance frequency.
-        { FN_GAME_NAME,     sizeof(FN_GAME_NAME)   - 1, FN_GAME   },
-        { FN_SYSTEM_NAME,   sizeof(FN_SYSTEM_NAME) - 1, FN_SYSTEM },
-        { NULL,             0,                          FN_ANY    }
+        { FN_GAME_NAME,     sizeof(FN_GAME_NAME)   - 1, FS_GAME   },
+        { FN_SYSTEM_NAME,   sizeof(FN_SYSTEM_NAME) - 1, FS_SYSTEM },
+        { NULL,             0,                          FS_ANY    }
     };
     size_t len, n;
 
-    // Special case: zero-length string means "any namespace".
-    if(!str || 0 == (len = strlen(str))) return FN_ANY;
+    // Special case: zero-length string means "any scheme".
+    if(!str || 0 == (len = strlen(str))) return FS_ANY;
 
     // Stop comparing characters at the first occurance of ':'
     char const* end = strchr(str, ':');
     if(end) len = end - str;
 
-    for(n = 0; namespaces[n].name; ++n)
+    for(n = 0; schemes[n].name; ++n)
     {
-        if(len < namespaces[n].nameLen) continue;
-        if(strnicmp(str, namespaces[n].name, len)) continue;
-        return namespaces[n].id;
+        if(len < schemes[n].nameLen) continue;
+        if(strnicmp(str, schemes[n].name, len)) continue;
+        return schemes[n].id;
     }
 
-    return FN_INVALID; // Unknown.
+    return FS_INVALID; // Unknown.
 }
 
-ddstring_t const* Fonts_NamespaceName(fontnamespaceid_t id)
+ddstring_t const* Fonts_SchemeName(fontschemeid_t id)
 {
-    static de::Str const namespaces[1 + FONTNAMESPACE_COUNT] = {
-        /* No namespace name */ "",
-        /* FN_SYSTEM */         FN_SYSTEM_NAME,
-        /* FN_SYSTEM */         FN_GAME_NAME
+    static de::Str const schemes[1 + FONTSCHEME_COUNT] = {
+        /* No scheme name */ "",
+        /* FS_SYSTEM */         FN_SYSTEM_NAME,
+        /* FS_SYSTEM */         FN_GAME_NAME
     };
-    if(VALID_FONTNAMESPACEID(id))
-        return namespaces[1 + (id - FONTNAMESPACE_FIRST)];
-    return namespaces[0];
+    if(VALID_FONTSCHEMEID(id))
+        return schemes[1 + (id - FONTSCHEME_FIRST)];
+    return schemes[0];
 }
 
 uint Fonts_Size(void)
@@ -467,11 +467,11 @@ uint Fonts_Size(void)
     return fontIdMapSize;
 }
 
-uint Fonts_Count(fontnamespaceid_t namespaceId)
+uint Fonts_Count(fontschemeid_t schemeId)
 {
-    if(!VALID_FONTNAMESPACEID(namespaceId) || !Fonts_Size()) return 0;
+    if(!VALID_FONTSCHEMEID(schemeId) || !Fonts_Size()) return 0;
 
-    FontRepository* directory = repositoryByNamespaceId(namespaceId);
+    FontRepository* directory = repositoryBySchemeId(schemeId);
     if(!directory) return 0;
     return directory->size();
 }
@@ -480,7 +480,7 @@ void Fonts_Clear(void)
 {
     if(!Fonts_Size()) return;
 
-    Fonts_ClearNamespace(FN_ANY);
+    Fonts_ClearScheme(FS_ANY);
     GL_PruneTextureVariantSpecifications();
 }
 
@@ -488,7 +488,7 @@ void Fonts_ClearRuntime(void)
 {
     if(!Fonts_Size()) return;
 
-    Fonts_ClearNamespace(FN_GAME);
+    Fonts_ClearScheme(FS_GAME);
     GL_PruneTextureVariantSpecifications();
 }
 
@@ -496,7 +496,7 @@ void Fonts_ClearSystem(void)
 {
     if(!Textures_Size()) return;
 
-    Fonts_ClearNamespace(FN_SYSTEM);
+    Fonts_ClearScheme(FS_SYSTEM);
     GL_PruneTextureVariantSpecifications();
 }
 
@@ -506,29 +506,29 @@ static int destroyFontAndRecordWorker(FontRepository::Node& node, void* /*parame
     return 0; // Continue iteration.
 }
 
-void Fonts_ClearNamespace(fontnamespaceid_t namespaceId)
+void Fonts_ClearScheme(fontschemeid_t schemeId)
 {
     if(!Fonts_Size()) return;
 
-    fontnamespaceid_t from, to;
-    if(namespaceId == FN_ANY)
+    fontschemeid_t from, to;
+    if(schemeId == FS_ANY)
     {
-        from = FONTNAMESPACE_FIRST;
-        to   = FONTNAMESPACE_LAST;
+        from = FONTSCHEME_FIRST;
+        to   = FONTSCHEME_LAST;
     }
-    else if(VALID_FONTNAMESPACEID(namespaceId))
+    else if(VALID_FONTSCHEMEID(schemeId))
     {
-        from = to = namespaceId;
+        from = to = schemeId;
     }
     else
     {
-        Con_Error("Fonts::ClearNamespace: Invalid font namespace %i.", (int) namespaceId);
+        Con_Error("Fonts::ClearScheme: Invalid font scheme %i.", (int) schemeId);
         exit(1); // Unreachable.
     }
 
     for(uint i = uint(from); i <= uint(to); ++i)
     {
-        FontNamespace& fn = namespaces[i - FONTNAMESPACE_FIRST];
+        FontScheme& fn = schemes[i - FONTSCHEME_FIRST];
 
         if(fn.repository)
         {
@@ -652,19 +652,19 @@ static int findUniqueIdBounds(FontRepository::Node& node, void* parameters)
     return 0; // Continue iteration.
 }
 
-static void rebuildUniqueIdMap(fontnamespaceid_t namespaceId)
+static void rebuildUniqueIdMap(fontschemeid_t schemeId)
 {
-    FontNamespace fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
-    fontnamespaceid_t localNamespaceId = namespaceId;
+    FontScheme fn = schemes[schemeId - FONTSCHEME_FIRST];
+    fontschemeid_t localSchemeId = schemeId;
     finduniqueidbounds_params_t p;
-    DENG_ASSERT(VALID_FONTNAMESPACEID(namespaceId));
+    DENG_ASSERT(VALID_FONTSCHEMEID(schemeId));
 
     if(!fn.uniqueIdMapDirty) return;
 
     // Determine the size of the LUT.
     p.minId = DDMAXINT;
     p.maxId = DDMININT;
-    iterateDirectory(namespaceId, findUniqueIdBounds, (void*)&p);
+    iterateDirectory(schemeId, findUniqueIdBounds, (void*)&p);
 
     if(p.minId > p.maxId)
     {
@@ -686,18 +686,18 @@ static void rebuildUniqueIdMap(fontnamespaceid_t namespaceId)
     if(fn.uniqueIdMapSize)
     {
         memset(fn.uniqueIdMap, NOFONTID, sizeof *fn.uniqueIdMap * fn.uniqueIdMapSize);
-        iterateDirectory(namespaceId, linkRecordInUniqueIdMap, (void*)&localNamespaceId);
+        iterateDirectory(schemeId, linkRecordInUniqueIdMap, (void*)&localSchemeId);
     }
     fn.uniqueIdMapDirty = false;
 }
 
-fontid_t Fonts_FontForUniqueId(fontnamespaceid_t namespaceId, int uniqueId)
+fontid_t Fonts_FontForUniqueId(fontschemeid_t schemeId, int uniqueId)
 {
-    if(VALID_FONTNAMESPACEID(namespaceId))
+    if(VALID_FONTSCHEMEID(schemeId))
     {
-        FontNamespace fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
+        FontScheme fn = schemes[schemeId - FONTSCHEME_FIRST];
 
-        rebuildUniqueIdMap(namespaceId);
+        rebuildUniqueIdMap(schemeId);
         if(fn.uniqueIdMap && uniqueId >= fn.uniqueIdBase &&
            (unsigned)(uniqueId - fn.uniqueIdBase) <= fn.uniqueIdMapSize)
         {
@@ -715,7 +715,7 @@ fontid_t Fonts_ResolveUri2(Uri const* _uri, boolean quiet)
 
     de::Uri const& uri = reinterpret_cast(*_uri);
 
-    if(!validateUri(uri, VFUF_ALLOW_NAMESPACE_ANY, true /*quiet please*/))
+    if(!validateUri(uri, VFUF_ALLOW_ANY_SCHEME, true /*quiet please*/))
     {
 #if _DEBUG
         LOG_WARNING("Uri \"%s\" failed validation, returning NOFONTID.") << uri;
@@ -802,8 +802,8 @@ fontid_t Fonts_Declare(Uri* _uri, int uniqueId)//, const Uri* resourcePath)
         record->font = 0;
         record->uniqueId = uniqueId;
 
-        fontnamespaceid_t namespaceId = Fonts_ParseNamespace(uri.schemeCStr());
-        FontNamespace& fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
+        fontschemeid_t schemeId = Fonts_ParseScheme(uri.schemeCStr());
+        FontScheme& fn = schemes[schemeId - FONTSCHEME_FIRST];
 
         node = fn.repository->insert(uri);
         node->setUserPointer(record);
@@ -831,8 +831,8 @@ fontid_t Fonts_Declare(Uri* _uri, int uniqueId)//, const Uri* resourcePath)
         releaseFont = true;
 
         // We'll need to rebuild the id map too.
-        fontnamespaceid_t namespaceId = namespaceIdForRepository(node->tree());
-        FontNamespace& fn = namespaces[namespaceId - FONTNAMESPACE_FIRST];
+        fontschemeid_t schemeId = schemeIdForRepository(node->tree());
+        FontScheme& fn = schemes[schemeId - FONTSCHEME_FIRST];
         fn.uniqueIdMapDirty = true;
     }
 
@@ -1049,21 +1049,21 @@ fontid_t Fonts_Id(font_t* font)
     return Font_PrimaryBind(font);
 }
 
-fontnamespaceid_t Fonts_Namespace(fontid_t id)
+fontschemeid_t Fonts_Scheme(fontid_t id)
 {
-    LOG_AS("Fonts::namespace");
+    LOG_AS("Fonts::scheme");
     FontRepository::Node* node = findDirectoryNodeForBindId(id);
     if(!node)
     {
 #if _DEBUG
         if(id != NOFONTID)
         {
-            LOG_WARNING("Attempted with unbound fontId #%u, returning FN_ANY.") << id;
+            LOG_WARNING("Attempted with unbound fontId #%u, returning FS_ANY.") << id;
         }
 #endif
-        return FN_ANY;
+        return FS_ANY;
     }
-    return namespaceIdForDirectoryNode(*node);
+    return schemeIdForDirectoryNode(*node);
 }
 
 AutoStr* Fonts_ComposePath(fontid_t id)
@@ -1117,12 +1117,12 @@ Uri* Fonts_ComposeUrn(fontid_t id)
     FontRecord const* record = (FontRecord*) node->userPointer();
     DENG_ASSERT(record);
 
-    ddstring_t const* namespaceName = Fonts_NamespaceName(namespaceIdForDirectoryNode(*node));
+    ddstring_t const* schemeName = Fonts_SchemeName(schemeIdForDirectoryNode(*node));
 
     ddstring_t path; Str_Init(&path);
-    Str_Reserve(&path, Str_Length(namespaceName) +1/*delimiter*/ + M_NumDigits(DDMAXINT));
+    Str_Reserve(&path, Str_Length(schemeName) +1/*delimiter*/ + M_NumDigits(DDMAXINT));
 
-    Str_Appendf(&path, "%s:%i", Str_Text(namespaceName), record->uniqueId);
+    Str_Appendf(&path, "%s:%i", Str_Text(schemeName), record->uniqueId);
 
     de::Uri* uri = new de::Uri();
     uri->setScheme("urn").setPath(Str_Text(&path));
@@ -1175,24 +1175,24 @@ static int iterateDirectoryWorker(FontRepository::Node& node, void* parameters)
     return 0; // Continue iteration.
 }
 
-static int iterateDirectory(fontnamespaceid_t namespaceId,
+static int iterateDirectory(fontschemeid_t schemeId,
     int (*callback)(FontRepository::Node& node, void* parameters), void* parameters)
 {
-    fontnamespaceid_t from, to;
-    if(VALID_FONTNAMESPACEID(namespaceId))
+    fontschemeid_t from, to;
+    if(VALID_FONTSCHEMEID(schemeId))
     {
-        from = to = namespaceId;
+        from = to = schemeId;
     }
     else
     {
-        from = FONTNAMESPACE_FIRST;
-        to   = FONTNAMESPACE_LAST;
+        from = FONTSCHEME_FIRST;
+        to   = FONTSCHEME_LAST;
     }
 
     int result = 0;
     for(uint i = uint(from); i <= uint(to); ++i)
     {
-        FontRepository* directory = repositoryByNamespaceId(fontnamespaceid_t(i));
+        FontRepository* directory = repositoryBySchemeId(fontschemeid_t(i));
         if(!directory) continue;
 
         result = directory->traverse(PCF_NO_BRANCH, NULL, FontRepository::no_hash, callback, parameters);
@@ -1201,7 +1201,7 @@ static int iterateDirectory(fontnamespaceid_t namespaceId,
     return result;
 }
 
-int Fonts_Iterate2(fontnamespaceid_t namespaceId,
+int Fonts_Iterate2(fontschemeid_t schemeId,
     int (*callback)(font_t* font, void* parameters), void* parameters)
 {
     if(!callback) return 0;
@@ -1210,16 +1210,16 @@ int Fonts_Iterate2(fontnamespaceid_t namespaceId,
     p.definedCallback = callback;
     p.declaredCallback = NULL;
     p.parameters = parameters;
-    return iterateDirectory(namespaceId, iterateDirectoryWorker, &p);
+    return iterateDirectory(schemeId, iterateDirectoryWorker, &p);
 }
 
-int Fonts_Iterate(fontnamespaceid_t namespaceId,
+int Fonts_Iterate(fontschemeid_t schemeId,
     int (*callback)(font_t* font, void* parameters))
 {
-    return Fonts_Iterate2(namespaceId, callback, NULL/*no parameters*/);
+    return Fonts_Iterate2(schemeId, callback, NULL/*no parameters*/);
 }
 
-int Fonts_IterateDeclared2(fontnamespaceid_t namespaceId,
+int Fonts_IterateDeclared2(fontschemeid_t schemeId,
     int (*callback)(fontid_t fontId, void* parameters), void* parameters)
 {
     if(!callback) return 0;
@@ -1228,26 +1228,26 @@ int Fonts_IterateDeclared2(fontnamespaceid_t namespaceId,
     p.declaredCallback = callback;
     p.definedCallback = NULL;
     p.parameters = parameters;
-    return iterateDirectory(namespaceId, iterateDirectoryWorker, &p);
+    return iterateDirectory(schemeId, iterateDirectoryWorker, &p);
 }
 
-int Fonts_IterateDeclared(fontnamespaceid_t namespaceId,
+int Fonts_IterateDeclared(fontschemeid_t schemeId,
     int (*callback)(fontid_t fontId, void* parameters))
 {
-    return Fonts_IterateDeclared2(namespaceId, callback, NULL/*no parameters*/);
+    return Fonts_IterateDeclared2(schemeId, callback, NULL/*no parameters*/);
 }
 
-static void printFontOverview(FontRepository::Node& node, bool printNamespace)
+static void printFontOverview(FontRepository::Node& node, bool printSchemeName)
 {
     FontRecord* record = (FontRecord*) node.userPointer();
     fontid_t fontId = findBindIdForDirectoryNode(node);
     int numUidDigits = MAX_OF(3/*uid*/, M_NumDigits(Fonts_Size()));
     Uri* uri = record->font? Fonts_ComposeUri(fontId) : Uri_New();
-    Str const* path = (printNamespace? Uri_ToString(uri) : Uri_Path(uri));
+    Str const* path = (printSchemeName? Uri_ToString(uri) : Uri_Path(uri));
     font_t* font = record->font;
 
     Con_FPrintf(!font? CPF_LIGHT : CPF_WHITE,
-        "%-*s %*u %s", printNamespace? 22 : 14, F_PrettyPath(Str_Text(path)),
+        "%-*s %*u %s", printSchemeName? 22 : 14, F_PrettyPath(Str_Text(path)),
         numUidDigits, fontId, !font? "unknown" : Font_Type(font) == FT_BITMAP? "bitmap" : "bitmap_composite");
 
     if(font && Font_IsPrepared(font))
@@ -1301,20 +1301,20 @@ static int collectDirectoryNodeWorker(FontRepository::Node& node, void* paramete
     return 0; // Continue iteration.
 }
 
-static FontRepository::Node** collectDirectoryNodes(fontnamespaceid_t namespaceId,
+static FontRepository::Node** collectDirectoryNodes(fontschemeid_t schemeId,
     de::String like, uint* count, FontRepository::Node** storage)
 {
-    fontnamespaceid_t fromId, toId;
-    if(VALID_FONTNAMESPACEID(namespaceId))
+    fontschemeid_t fromId, toId;
+    if(VALID_FONTSCHEMEID(schemeId))
     {
-        // Only consider fonts in this namespace.
-        fromId = toId = namespaceId;
+        // Only consider fonts in this scheme.
+        fromId = toId = schemeId;
     }
     else
     {
-        // Consider fonts in any namespace.
-        fromId = FONTNAMESPACE_FIRST;
-        toId   = FONTNAMESPACE_LAST;
+        // Consider fonts in any scheme.
+        fromId = FONTSCHEME_FIRST;
+        toId   = FONTSCHEME_LAST;
     }
 
     collectdirectorynodeworker_params_t p;
@@ -1324,7 +1324,7 @@ static FontRepository::Node** collectDirectoryNodes(fontnamespaceid_t namespaceI
 
     for(uint i = uint(fromId); i <= uint(toId); ++i)
     {
-        FontRepository* fontDirectory = repositoryByNamespaceId(fontnamespaceid_t(i));
+        FontRepository* fontDirectory = repositoryBySchemeId(fontschemeid_t(i));
         if(!fontDirectory) continue;
 
         fontDirectory->traverse(PCF_NO_BRANCH | PCF_MATCH_FULL, NULL, FontRepository::no_hash, collectDirectoryNodeWorker, (void*)&p);
@@ -1346,7 +1346,7 @@ static FontRepository::Node** collectDirectoryNodes(fontnamespaceid_t namespaceI
     storage = (FontRepository::Node**) M_Malloc(sizeof *storage * (p.idx+1));
     if(!storage)
         Con_Error("collectFonts: Failed on allocation of %lu bytes for new collection.", (unsigned long) (sizeof* storage * (p.idx+1)));
-    return collectDirectoryNodes(namespaceId, like, count, storage);
+    return collectDirectoryNodes(schemeId, like, count, storage);
 }
 
 static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
@@ -1366,7 +1366,7 @@ static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
  * @ingroup flags
  */
 ///@{
-#define PFF_TRANSFORM_PATH_NO_NAMESPACE 0x1 /// Do not print the namespace.
+#define PFF_TRANSFORM_PATH_NO_SCHEME 0x1 /// Do not print the scheme.
 ///@}
 
 #define DEFAULT_PRINTFONTFLAGS          0
@@ -1374,19 +1374,19 @@ static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
 /**
  * @param flags  @ref printFontFlags
  */
-static size_t printFonts3(fontnamespaceid_t namespaceId, char const* like, int flags)
+static size_t printFonts3(fontschemeid_t schemeId, char const* like, int flags)
 {
-    bool const  printNamespace = !(flags & PFF_TRANSFORM_PATH_NO_NAMESPACE);
+    bool const printScheme = !(flags & PFF_TRANSFORM_PATH_NO_SCHEME);
     uint idx, count = 0;
-    FontRepository::Node** foundFonts = collectDirectoryNodes(namespaceId, like, &count, NULL);
+    FontRepository::Node** foundFonts = collectDirectoryNodes(schemeId, like, &count, NULL);
     FontRepository::Node** iter;
     int numFoundDigits, numUidDigits;
 
     if(!foundFonts) return 0;
 
-    if(!printNamespace)
-        Con_FPrintf(CPF_YELLOW, "Known fonts in namespace '%s'", Str_Text(Fonts_NamespaceName(namespaceId)));
-    else // Any namespace.
+    if(!printScheme)
+        Con_FPrintf(CPF_YELLOW, "Known fonts in scheme '%s'", Str_Text(Fonts_SchemeName(schemeId)));
+    else // Any scheme.
         Con_FPrintf(CPF_YELLOW, "Known fonts");
 
     if(like && like[0])
@@ -1397,7 +1397,7 @@ static size_t printFonts3(fontnamespaceid_t namespaceId, char const* like, int f
     numFoundDigits = MAX_OF(3/*idx*/, M_NumDigits((int)count));
     numUidDigits = MAX_OF(3/*uid*/, M_NumDigits((int)Fonts_Size()));
     Con_Printf(" %*s: %-*s %*s type", numFoundDigits, "idx",
-               printNamespace? 22 : 14, printNamespace? "namespace:path" : "path",
+               printScheme ? 22 : 14, printScheme? "scheme:path" : "path",
                numUidDigits, "uid");
 
     // Fonts may be prepared only if GL is inited thus if we can't prepare, we can't list property values.
@@ -1416,35 +1416,35 @@ static size_t printFonts3(fontnamespaceid_t namespaceId, char const* like, int f
     {
         FontRepository::Node* node = *iter;
         Con_Printf(" %*u: ", numFoundDigits, idx++);
-        printFontOverview(*node, printNamespace);
+        printFontOverview(*node, printScheme);
     }
 
     M_Free(foundFonts);
     return count;
 }
 
-static void printFonts2(fontnamespaceid_t namespaceId, const char* like, int flags)
+static void printFonts2(fontschemeid_t schemeId, const char* like, int flags)
 {
     size_t printTotal = 0;
-    // Do we care which namespace?
-    if(namespaceId == FN_ANY && like && like[0])
+    // Do we care which scheme?
+    if(schemeId == FS_ANY && like && like[0])
     {
-        printTotal = printFonts3(namespaceId, like, flags & ~PFF_TRANSFORM_PATH_NO_NAMESPACE);
+        printTotal = printFonts3(schemeId, like, flags & ~PFF_TRANSFORM_PATH_NO_SCHEME);
         Con_PrintRuler();
     }
-    // Only one namespace to print?
-    else if(VALID_FONTNAMESPACEID(namespaceId))
+    // Only one scheme to print?
+    else if(VALID_FONTSCHEMEID(schemeId))
     {
-        printTotal = printFonts3(namespaceId, like, flags | PFF_TRANSFORM_PATH_NO_NAMESPACE);
+        printTotal = printFonts3(schemeId, like, flags | PFF_TRANSFORM_PATH_NO_SCHEME);
         Con_PrintRuler();
     }
     else
     {
-        // Collect and sort in each namespace separately.
+        // Collect and sort in each scheme separately.
         int i;
-        for(i = FONTNAMESPACE_FIRST; i <= FONTNAMESPACE_LAST; ++i)
+        for(i = FONTSCHEME_FIRST; i <= FONTSCHEME_LAST; ++i)
         {
-            size_t printed = printFonts3((fontnamespaceid_t)i, like, flags | PFF_TRANSFORM_PATH_NO_NAMESPACE);
+            size_t printed = printFonts3((fontschemeid_t)i, like, flags | PFF_TRANSFORM_PATH_NO_SCHEME);
             if(printed != 0)
             {
                 printTotal += printed;
@@ -1455,9 +1455,9 @@ static void printFonts2(fontnamespaceid_t namespaceId, const char* like, int fla
     Con_Printf("Found %lu %s.\n", (unsigned long) printTotal, printTotal == 1? "Font" : "Fonts");
 }
 
-static void printFonts(fontnamespaceid_t namespaceId, const char* like)
+static void printFonts(fontschemeid_t schemeId, const char* like)
 {
-    printFonts2(namespaceId, like, DEFAULT_PRINTFONTFLAGS);
+    printFonts2(schemeId, like, DEFAULT_PRINTFONTFLAGS);
 }
 
 static int clearDefinitionLinks(font_t* font, void* parameters)
@@ -1473,7 +1473,7 @@ static int clearDefinitionLinks(font_t* font, void* parameters)
 void Fonts_ClearDefinitionLinks(void)
 {
     if(!Fonts_Size()) return;
-    Fonts_Iterate(FN_ANY, clearDefinitionLinks);
+    Fonts_Iterate(FS_ANY, clearDefinitionLinks);
 }
 
 static int releaseFontTextures(font_t* font, void* parameters)
@@ -1494,26 +1494,26 @@ static int releaseFontTextures(font_t* font, void* parameters)
     return 0; // Continue iteration.
 }
 
-void Fonts_ReleaseTexturesByNamespace(fontnamespaceid_t namespaceId)
+void Fonts_ReleaseTexturesByScheme(fontschemeid_t schemeId)
 {
     if(novideo || isDedicated) return;
     if(!Fonts_Size()) return;
-    Fonts_Iterate(namespaceId, releaseFontTextures);
+    Fonts_Iterate(schemeId, releaseFontTextures);
 }
 
 void Fonts_ReleaseTextures(void)
 {
-    Fonts_ReleaseTexturesByNamespace(FN_ANY);
+    Fonts_ReleaseTexturesByScheme(FS_ANY);
 }
 
 void Fonts_ReleaseRuntimeTextures(void)
 {
-    Fonts_ReleaseTexturesByNamespace(FN_GAME);
+    Fonts_ReleaseTexturesByScheme(FS_GAME);
 }
 
 void Fonts_ReleaseSystemTextures(void)
 {
-    Fonts_ReleaseTexturesByNamespace(FN_SYSTEM);
+    Fonts_ReleaseTexturesByScheme(FS_SYSTEM);
 }
 
 ddstring_t** Fonts_CollectNames(int* rCount)
@@ -1521,7 +1521,7 @@ ddstring_t** Fonts_CollectNames(int* rCount)
     uint count = 0;
     ddstring_t** list = NULL;
 
-    FontRepository::Node** foundFonts = collectDirectoryNodes(FN_ANY, "", &count, 0);
+    FontRepository::Node** foundFonts = collectDirectoryNodes(FS_ANY, "", &count, 0);
     if(foundFonts)
     {
         qsort(foundFonts, (size_t)count, sizeof *foundFonts, composeAndCompareDirectoryNodePaths);
@@ -1548,7 +1548,7 @@ D_CMD(ListFonts)
 {
     DENG_UNUSED(src);
 
-    fontnamespaceid_t namespaceId = FN_ANY;
+    fontschemeid_t schemeId = FS_ANY;
     char const* like = NULL;
     de::Uri uri;
 
@@ -1558,29 +1558,29 @@ D_CMD(ListFonts)
         return true;
     }
 
-    // "listfonts [namespace] [name]"
+    // "listfonts [scheme] [name]"
     if(argc > 2)
     {
         uri.setScheme(argv[1]).setPath(argv[2]);
 
-        namespaceId = Fonts_ParseNamespace(uri.schemeCStr());
-        if(!VALID_FONTNAMESPACEID(namespaceId))
+        schemeId = Fonts_ParseScheme(uri.schemeCStr());
+        if(!VALID_FONTSCHEMEID(schemeId))
         {
-            Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+            Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
             return false;
         }
         like = uri.pathCStr();
     }
-    // "listfonts [namespace:name]" i.e., a partial Uri
+    // "listfonts [scheme:name]" i.e., a partial Uri
     else if(argc > 1)
     {
         uri.setUri(argv[1], RC_NULL);
         if(!uri.scheme().isEmpty())
         {
-            namespaceId = Fonts_ParseNamespace(uri.schemeCStr());
-            if(!VALID_FONTNAMESPACEID(namespaceId))
+            schemeId = Fonts_ParseScheme(uri.schemeCStr());
+            if(!VALID_FONTSCHEMEID(schemeId))
             {
-                Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+                Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
                 return false;
             }
 
@@ -1589,17 +1589,17 @@ D_CMD(ListFonts)
         }
         else
         {
-            namespaceId = Fonts_ParseNamespace(uri.pathCStr());
+            schemeId = Fonts_ParseScheme(uri.pathCStr());
 
-            if(!VALID_FONTNAMESPACEID(namespaceId))
+            if(!VALID_FONTSCHEMEID(schemeId))
             {
-                namespaceId = FN_ANY;
+                schemeId = FS_ANY;
                 like = argv[1];
             }
         }
     }
 
-    printFonts(namespaceId, like);
+    printFonts(schemeId, like);
 
     return true;
 }
@@ -1616,15 +1616,15 @@ D_CMD(PrintFontStats)
     }
 
     Con_FPrintf(CPF_YELLOW, "Font Statistics:\n");
-    for(uint i = uint(FONTNAMESPACE_FIRST); i <= uint(FONTNAMESPACE_LAST); ++i)
+    for(uint i = uint(FONTSCHEME_FIRST); i <= uint(FONTSCHEME_LAST); ++i)
     {
-        FontRepository* fontDirectory = repositoryByNamespaceId(fontnamespaceid_t(i));
+        FontRepository* fontDirectory = repositoryBySchemeId(fontschemeid_t(i));
         uint size;
 
         if(!fontDirectory) continue;
 
         size = fontDirectory->size();
-        Con_Printf("Namespace: %s (%u %s)\n", Str_Text(Fonts_NamespaceName(fontnamespaceid_t(i))), size, size==1? "font":"fonts");
+        Con_Printf("Scheme: %s (%u %s)\n", Str_Text(Fonts_SchemeName(fontschemeid_t(i))), size, size==1? "font":"fonts");
         FontRepository::debugPrintHashDistribution(*fontDirectory);
         FontRepository::debugPrint(*fontDirectory);
     }
diff --git a/doomsday/engine/src/resource/materialarchive.c b/doomsday/engine/src/resource/materialarchive.c
index fd923d0754..601de3b2b8 100644
--- a/doomsday/engine/src/resource/materialarchive.c
+++ b/doomsday/engine/src/resource/materialarchive.c
@@ -210,10 +210,10 @@ static int readRecord(MaterialArchive* mArc, materialarchive_record_t* rec, Read
         oldMNI = Reader_ReadByte(reader);
         switch(oldMNI % 4)
         {
-        case 0: Uri_SetScheme(rec->uri, MN_TEXTURES_NAME); break;
-        case 1: Uri_SetScheme(rec->uri, MN_FLATS_NAME);    break;
-        case 2: Uri_SetScheme(rec->uri, MN_SPRITES_NAME);  break;
-        case 3: Uri_SetScheme(rec->uri, MN_SYSTEM_NAME);   break;
+        case 0: Uri_SetScheme(rec->uri, MS_TEXTURES_NAME); break;
+        case 1: Uri_SetScheme(rec->uri, MS_FLATS_NAME);    break;
+        case 2: Uri_SetScheme(rec->uri, MS_SPRITES_NAME);  break;
+        case 3: Uri_SetScheme(rec->uri, MS_SYSTEM_NAME);   break;
         }
         Uri_SetPath(rec->uri, Str_Text(&path));
         Str_Free(&path);
@@ -225,7 +225,7 @@ static int readRecord(MaterialArchive* mArc, materialarchive_record_t* rec, Read
  * Same as readRecord except we are reading the old record format used
  * by Doomsday 1.8.6 and earlier.
  */
-static int readRecord_v186(materialarchive_record_t* rec, const char* mnamespace, Reader* reader)
+static int readRecord_v186(materialarchive_record_t* rec, const char* scheme, Reader* reader)
 {
     char buf[9];
     ddstring_t path;
@@ -236,12 +236,12 @@ static int readRecord_v186(materialarchive_record_t* rec, const char* mnamespace
     Str_Init(&path);
     Str_PercentEncode(Str_StripRight(Str_Appendf(&path, "%s", buf)));
     Uri_SetPath(rec->uri, Str_Text(&path));
-    Uri_SetScheme(rec->uri, mnamespace);
+    Uri_SetScheme(rec->uri, scheme);
     Str_Free(&path);
     return true; // Continue iteration.
 }
 
-static void readMaterialGroup(MaterialArchive* mArc, const char* defaultNamespace, Reader *reader)
+static void readMaterialGroup(MaterialArchive* mArc, const char* defaultScheme, Reader *reader)
 {
     // Read the group header.
     uint num = Reader_ReadUInt16(reader);
@@ -254,7 +254,7 @@ static void readMaterialGroup(MaterialArchive* mArc, const char* defaultNamespac
         if(mArc->version >= 1)
             readRecord(mArc, &temp, reader);
         else
-            readRecord_v186(&temp, mArc->version <= 1? defaultNamespace : 0, reader);
+            readRecord_v186(&temp, mArc->version <= 1? defaultScheme : 0, reader);
 
         insertSerialId(mArc, mArc->count+1, temp.uri, 0);
         if(temp.uri)
@@ -371,12 +371,12 @@ void MaterialArchive_Read(MaterialArchive* arc, int forcedVersion, Reader* reade
     }
 
     arc->count = 0;
-    readMaterialGroup(arc, (forcedVersion >= 1? "" : MN_FLATS_NAME":"), reader);
+    readMaterialGroup(arc, (forcedVersion >= 1? "" : MS_FLATS_NAME":"), reader);
 
     if(arc->version == 0)
     {
         // The old format saved flats and textures in seperate groups.
         arc->numFlats = arc->count;
-        readMaterialGroup(arc, (forcedVersion >= 1? "" : MN_TEXTURES_NAME":"), reader);
+        readMaterialGroup(arc, (forcedVersion >= 1? "" : MS_TEXTURES_NAME":"), reader);
     }
 }
diff --git a/doomsday/engine/src/resource/materials.cpp b/doomsday/engine/src/resource/materials.cpp
index 1ed46eee0a..02a91ce105 100644
--- a/doomsday/engine/src/resource/materials.cpp
+++ b/doomsday/engine/src/resource/materials.cpp
@@ -1,6 +1,6 @@
 /**
  * @file materials.cpp
- * Materials collection, namespaces, bindings and other management. @ingroup resource
+ * Materials collection, schemes, bindings and other management. @ingroup resource
  *
  * @authors Copyright © 2003-2012 Jaakko Keränen 
  * @authors Copyright © 2006-2012 Daniel Swanson 
@@ -208,9 +208,9 @@ static VariantCacheQueue* variantCacheQueue;
  * 4) Material name bindings are semi-independant from the materials. There
  *    may be multiple name bindings for a given material (aliases).
  *    The only requirement is that their symbolic names must be unique among
- *    those in the same namespace.
+ *    those in the same scheme.
  * 5) Super-fast look up by public material identifier.
- * 6) Fast look up by material name (a hashing scheme is used).
+ * 6) Fast look up by material name (hashing is used).
  */
 static blockset_t* materialsBlockSet;
 static MaterialList* materials;
@@ -222,8 +222,8 @@ static uint bindingCount;
 static uint bindingIdMapSize;
 static MaterialBind** bindingIdMap;
 
-// Material namespaces contain mappings between names and MaterialBind instances.
-static MaterialRepository* namespaces[MATERIALNAMESPACE_COUNT];
+// Material schemes contain mappings between names and MaterialBind instances.
+static MaterialRepository* schemes[MATERIALSCHEME_COUNT];
 
 void Materials_Register(void)
 {
@@ -241,31 +241,31 @@ static void errorIfNotInited(const char* callerName)
                                     .arg(callerName));
 }
 
-static inline MaterialRepository& getDirectoryForNamespaceId(materialnamespaceid_t id)
+static inline MaterialRepository& schemeById(materialschemeid_t id)
 {
-    DENG2_ASSERT(VALID_MATERIALNAMESPACEID(id));
-    DENG2_ASSERT(namespaces[id-MATERIALNAMESPACE_FIRST]);
-    return *namespaces[id-MATERIALNAMESPACE_FIRST];
+    DENG2_ASSERT(VALID_MATERIALSCHEMEID(id));
+    DENG2_ASSERT(schemes[id-MATERIALSCHEME_FIRST]);
+    return *schemes[id-MATERIALSCHEME_FIRST];
 }
 
-static materialnamespaceid_t namespaceIdForDirectory(MaterialRepository& directory)
+static materialschemeid_t schemeIdForDirectory(MaterialRepository& directory)
 {
-    for(uint i = uint(MATERIALNAMESPACE_FIRST); i <= uint(MATERIALNAMESPACE_LAST); ++i)
+    for(uint i = uint(MATERIALSCHEME_FIRST); i <= uint(MATERIALSCHEME_LAST); ++i)
     {
-        uint idx = i - MATERIALNAMESPACE_FIRST;
-        if(namespaces[idx] == &directory) return materialnamespaceid_t(i);
+        uint idx = i - MATERIALSCHEME_FIRST;
+        if(schemes[idx] == &directory) return materialschemeid_t(i);
     }
 
     // Should never happen.
-    throw de::Error("Materials::namespaceIdForDirectory",
+    throw de::Error("Materials::schemeIdForDirectory",
                     de::String().sprintf("Failed to determine id for directory %p.", (void*)&directory));
 }
 
 /// @return  Newly composed Uri for @a node. Must be deleted when no longer needed.
 static de::Uri composeUriForDirectoryNode(MaterialRepository::Node const& node)
 {
-    Str const* namespaceName = Materials_NamespaceName(namespaceIdForDirectory(node.tree()));
-    return node.composeUri().setScheme(Str_Text(namespaceName));
+    Str const* schemeName = Materials_SchemeName(schemeIdForDirectory(node.tree()));
+    return node.composeUri().setScheme(Str_Text(schemeName));
 }
 
 static MaterialAnim* getAnimGroup(int number)
@@ -460,7 +460,7 @@ static void updateMaterialBindInfo(MaterialBind& mb, bool canCreateInfo)
 
 static bool newMaterialBind(de::Uri& uri, material_t* material)
 {
-    MaterialRepository& matDirectory = getDirectoryForNamespaceId(Materials_ParseNamespace(uri.schemeCStr()));
+    MaterialRepository& matDirectory = schemeById(Materials_ParseSchemeName(uri.schemeCStr()));
     MaterialRepository::Node* node;
     MaterialBind* mb;
 
@@ -550,9 +550,9 @@ void Materials_Init(void)
     bindingIdMap = NULL;
     bindingIdMapSize = 0;
 
-    for(i = 0; i < MATERIALNAMESPACE_COUNT; ++i)
+    for(i = 0; i < MATERIALSCHEME_COUNT; ++i)
     {
-        namespaces[i] = new MaterialRepository();
+        schemes[i] = new MaterialRepository();
     }
 
     initedOk = true;
@@ -578,11 +578,11 @@ static void destroyBindings(void)
     int i;
     DENG2_ASSERT(initedOk);
 
-    for(i = 0; i < MATERIALNAMESPACE_COUNT; ++i)
+    for(i = 0; i < MATERIALSCHEME_COUNT; ++i)
     {
-        if(!namespaces[i]) continue;
+        if(!schemes[i]) continue;
 
-        DENG2_FOR_EACH_CONST(MaterialRepository::Nodes, nodeIt, namespaces[i]->leafNodes())
+        DENG2_FOR_EACH_CONST(MaterialRepository::Nodes, nodeIt, schemes[i]->leafNodes())
         {
             MaterialBind* mb = reinterpret_cast((*nodeIt)->userPointer());
             if(mb)
@@ -592,7 +592,7 @@ static void destroyBindings(void)
                 delete mb;
             }
         }
-        delete namespaces[i]; namespaces[i] = NULL;
+        delete schemes[i]; schemes[i] = NULL;
     }
 
     // Clear the binding index/map.
@@ -617,41 +617,41 @@ void Materials_Shutdown(void)
     initedOk = false;
 }
 
-materialnamespaceid_t Materials_ParseNamespace(const char* str)
+materialschemeid_t Materials_ParseSchemeName(const char* str)
 {
-    if(!str || 0 == strlen(str)) return MN_ANY;
+    if(!str || 0 == strlen(str)) return MS_ANY;
 
-    if(!stricmp(str, MN_TEXTURES_NAME)) return MN_TEXTURES;
-    if(!stricmp(str, MN_FLATS_NAME))    return MN_FLATS;
-    if(!stricmp(str, MN_SPRITES_NAME))  return MN_SPRITES;
-    if(!stricmp(str, MN_SYSTEM_NAME))   return MN_SYSTEM;
+    if(!stricmp(str, MS_TEXTURES_NAME)) return MS_TEXTURES;
+    if(!stricmp(str, MS_FLATS_NAME))    return MS_FLATS;
+    if(!stricmp(str, MS_SPRITES_NAME))  return MS_SPRITES;
+    if(!stricmp(str, MS_SYSTEM_NAME))   return MS_SYSTEM;
 
-    return MN_INVALID; // Unknown.
+    return MS_INVALID; // Unknown.
 }
 
-Str const* Materials_NamespaceName(materialnamespaceid_t id)
+Str const* Materials_SchemeName(materialschemeid_t id)
 {
-    static de::Str const namespaces[1+MATERIALNAMESPACE_COUNT] = {
-        /* No namespace name */ "",
-        /* MN_SYSTEM */         MN_SYSTEM_NAME,
-        /* MN_FLATS */          MN_FLATS_NAME,
-        /* MN_TEXTURES */       MN_TEXTURES_NAME,
-        /* MN_SPRITES */        MN_SPRITES_NAME
+    static de::Str const names[1+MATERIALSCHEME_COUNT] = {
+        /* No scheme name */    "",
+        /* MS_SYSTEM */         MS_SYSTEM_NAME,
+        /* MS_FLATS */          MS_FLATS_NAME,
+        /* MS_TEXTURES */       MS_TEXTURES_NAME,
+        /* MS_SPRITES */        MS_SPRITES_NAME
     };
-    if(VALID_MATERIALNAMESPACEID(id))
-        return namespaces[1 + (id - MATERIALNAMESPACE_FIRST)];
-    return namespaces[0];
+    if(VALID_MATERIALSCHEMEID(id))
+        return names[1 + (id - MATERIALSCHEME_FIRST)];
+    return names[0];
 }
 
-materialnamespaceid_t Materials_Namespace(materialid_t id)
+materialschemeid_t Materials_Scheme(materialid_t id)
 {
     MaterialBind* bind = getMaterialBindForId(id);
     if(!bind)
     {
-        DEBUG_Message(("Warning: Materials::Namespace: Attempted with unbound materialId #%u, returning 'any' namespace.\n", id));
-        return MN_ANY;
+        DEBUG_Message(("Warning: Materials::Scheme: Attempted with unbound materialId #%u, returning 'any' scheme.\n", id));
+        return MS_ANY;
     }
-    return namespaceIdForDirectory(bind->directoryNode().tree());
+    return schemeIdForDirectory(bind->directoryNode().tree());
 }
 
 static void clearBindingDefinitionLinks(MaterialBind* mb)
@@ -677,9 +677,9 @@ void Materials_ClearDefinitionLinks(void)
         Material_SetDefinition(mat, NULL);
     }
 
-    for(uint i = uint(MATERIALNAMESPACE_FIRST); i <= uint(MATERIALNAMESPACE_LAST); ++i)
+    for(uint i = uint(MATERIALSCHEME_FIRST); i <= uint(MATERIALSCHEME_LAST); ++i)
     {
-        MaterialRepository& matDirectory = getDirectoryForNamespaceId(materialnamespaceid_t(i));
+        MaterialRepository& matDirectory = schemeById(materialschemeid_t(i));
 
         DENG2_FOR_EACH_CONST(MaterialRepository::Nodes, nodeIt, matDirectory.leafNodes())
         {
@@ -756,7 +756,7 @@ materialid_t Materials_Id(material_t* mat)
  * @ingroup flags
  */
 ///@{
-#define VMUF_ALLOW_NAMESPACE_ANY        0x1 ///< The Scheme component of the uri may be of zero-length; signifying "any namespace".
+#define VMUF_ALLOW_ANY_SCHEME           0x1 ///< The Scheme component of the uri may be of zero-length; signifying "any scheme".
 ///@}
 
 /**
@@ -767,24 +767,24 @@ materialid_t Materials_Id(material_t* mat)
  */
 static bool validateMaterialUri(de::Uri const& uri, int flags, boolean quiet=false)
 {
-    materialnamespaceid_t namespaceId;
+    materialschemeid_t schemeId;
 
     if(uri.isEmpty())
     {
         if(!quiet)
         {
-            LOG_MSG("Invalid path in Material uri \"%s\".") <(*_uri);
-    if(!validateMaterialUri(uri, VMUF_ALLOW_NAMESPACE_ANY, true /*quiet please*/))
+    if(!validateMaterialUri(uri, VMUF_ALLOW_ANY_SCHEME, true /*quiet please*/))
     {
 #if _DEBUG
         LOG_WARNING("\"%s\" failed validation, returning NOMATERIALID.") << uri;
@@ -1362,10 +1362,10 @@ uint Materials_Size(void)
     return materialCount;
 }
 
-uint Materials_Count(materialnamespaceid_t namespaceId)
+uint Materials_Count(materialschemeid_t schemeId)
 {
-    if(!VALID_MATERIALNAMESPACEID(namespaceId) || !Materials_Size()) return 0;
-    return getDirectoryForNamespaceId(namespaceId).size();
+    if(!VALID_MATERIALSCHEMEID(schemeId) || !Materials_Size()) return 0;
+    return schemeById(schemeId).size();
 }
 
 const struct materialvariantspecification_s* Materials_VariantSpecificationForContext(
@@ -1474,13 +1474,13 @@ static void printMaterialInfo(material_t* mat)
     Uri_Delete(uri);
 }
 
-static void printMaterialOverview(material_t* mat, bool printNamespace)
+static void printMaterialOverview(material_t* mat, bool printScheme)
 {
     int numUidDigits = MAX_OF(3/*uid*/, M_NumDigits(Materials_Size()));
     Uri* uri = Materials_ComposeUri(Materials_Id(mat));
-    AutoStr* path = (printNamespace? Uri_ToString(uri) : Str_PercentDecode(AutoStr_FromTextStd(Str_Text(Uri_Path(uri)))));
+    AutoStr* path = (printScheme? Uri_ToString(uri) : Str_PercentDecode(AutoStr_FromTextStd(Str_Text(Uri_Path(uri)))));
 
-    Con_Printf("%-*s %*u %s\n", printNamespace? 22 : 14, F_PrettyPath(Str_Text(path)),
+    Con_Printf("%-*s %*u %s\n", printScheme? 22 : 14, F_PrettyPath(Str_Text(path)),
                numUidDigits, Materials_Id(mat),
                !Material_IsCustom(mat) ? "game" : (Material_Definition(mat)->autoGenerated? "addon" : "def"));
 
@@ -1493,27 +1493,27 @@ static void printMaterialOverview(material_t* mat, bool printNamespace)
  * However this is only presently used for the material search/listing console commands
  * so is not hugely important right now.
  */
-static MaterialRepository::Node** collectDirectoryNodes(materialnamespaceid_t namespaceId,
+static MaterialRepository::Node** collectDirectoryNodes(materialschemeid_t schemeId,
     de::String like, int* count, MaterialRepository::Node** storage)
 {
-    materialnamespaceid_t fromId, toId;
+    materialschemeid_t fromId, toId;
 
-    if(VALID_MATERIALNAMESPACEID(namespaceId))
+    if(VALID_MATERIALSCHEMEID(schemeId))
     {
-        // Only consider materials in this namespace.
-        fromId = toId = namespaceId;
+        // Only consider materials in this scheme.
+        fromId = toId = schemeId;
     }
     else
     {
-        // Consider materials in any namespace.
-        fromId = MATERIALNAMESPACE_FIRST;
-        toId   = MATERIALNAMESPACE_LAST;
+        // Consider materials in any scheme.
+        fromId = MATERIALSCHEME_FIRST;
+        toId   = MATERIALSCHEME_LAST;
     }
 
     int idx = 0;
     for(uint i = uint(fromId); i <= uint(toId); ++i)
     {
-        MaterialRepository& matDirectory = getDirectoryForNamespaceId(materialnamespaceid_t(i));
+        MaterialRepository& matDirectory = schemeById(materialschemeid_t(i));
 
         DENG2_FOR_EACH_CONST(MaterialRepository::Nodes, nodeIt, matDirectory.leafNodes())
         {
@@ -1553,7 +1553,7 @@ static MaterialRepository::Node** collectDirectoryNodes(materialnamespaceid_t na
     storage = (MaterialRepository::Node**)M_Malloc(sizeof *storage * (idx+1));
     if(!storage)
         Con_Error("Materials::collectDirectoryNodes: Failed on allocation of %lu bytes for new MaterialRepository::Node collection.", (unsigned long) (sizeof* storage * (idx+1)));
-    return collectDirectoryNodes(namespaceId, like, count, storage);
+    return collectDirectoryNodes(schemeId, like, count, storage);
 }
 
 static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
@@ -1568,18 +1568,18 @@ static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
     return Str_CompareIgnoreCase(pathA, Str_Text(pathB));
 }
 
-static size_t printMaterials2(materialnamespaceid_t namespaceId, char const* like,
-    bool printNamespace)
+static size_t printMaterials2(materialschemeid_t schemeId, char const* like,
+    bool printSchemeName)
 {
     int numFoundDigits, numUidDigits, idx, count = 0;
-    MaterialRepository::Node** foundMaterials = collectDirectoryNodes(namespaceId, like, &count, NULL);
+    MaterialRepository::Node** foundMaterials = collectDirectoryNodes(schemeId, like, &count, NULL);
     MaterialRepository::Node** iter;
 
     if(!foundMaterials) return 0;
 
-    if(!printNamespace)
-        Con_FPrintf(CPF_YELLOW, "Known materials in namespace '%s'", Str_Text(Materials_NamespaceName(namespaceId)));
-    else // Any namespace.
+    if(!printSchemeName)
+        Con_FPrintf(CPF_YELLOW, "Known materials in scheme '%s'", Str_Text(Materials_SchemeName(schemeId)));
+    else // Any scheme.
         Con_FPrintf(CPF_YELLOW, "Known materials");
 
     if(like && like[0])
@@ -1590,7 +1590,7 @@ static size_t printMaterials2(materialnamespaceid_t namespaceId, char const* lik
     numFoundDigits = MAX_OF(3/*idx*/, M_NumDigits(count));
     numUidDigits = MAX_OF(3/*uid*/, M_NumDigits(Materials_Size()));
     Con_Printf(" %*s: %-*s %*s origin\n", numFoundDigits, "idx",
-        printNamespace? 22 : 14, printNamespace? "namespace:path" : "path", numUidDigits, "uid");
+        printSchemeName? 22 : 14, printSchemeName? "scheme:path" : "path", numUidDigits, "uid");
     Con_PrintRuler();
 
     // Sort and print the index.
@@ -1603,35 +1603,35 @@ static size_t printMaterials2(materialnamespaceid_t namespaceId, char const* lik
         MaterialBind* mb = reinterpret_cast(node->userPointer());
         material_t* mat = mb->material();
         Con_Printf(" %*i: ", numFoundDigits, idx++);
-        printMaterialOverview(mat, printNamespace);
+        printMaterialOverview(mat, printSchemeName);
     }
 
     M_Free(foundMaterials);
     return count;
 }
 
-static void printMaterials(materialnamespaceid_t namespaceId, const char* like)
+static void printMaterials(materialschemeid_t schemeId, const char* like)
 {
     size_t printTotal = 0;
-    // Do we care which namespace?
-    if(namespaceId == MN_ANY && like && like[0])
+    // Do we care which scheme?
+    if(schemeId == MS_ANY && like && like[0])
     {
-        printTotal = printMaterials2(namespaceId, like, true);
+        printTotal = printMaterials2(schemeId, like, true);
         Con_PrintRuler();
     }
-    // Only one namespace to print?
-    else if(VALID_MATERIALNAMESPACEID(namespaceId))
+    // Only one scheme to print?
+    else if(VALID_MATERIALSCHEMEID(schemeId))
     {
-        printTotal = printMaterials2(namespaceId, like, false);
+        printTotal = printMaterials2(schemeId, like, false);
         Con_PrintRuler();
     }
     else
     {
-        // Collect and sort in each namespace separately.
+        // Collect and sort in each scheme separately.
         int i;
-        for(i = MATERIALNAMESPACE_FIRST; i <= MATERIALNAMESPACE_LAST; ++i)
+        for(i = MATERIALSCHEME_FIRST; i <= MATERIALSCHEME_LAST; ++i)
         {
-            size_t printed = printMaterials2((materialnamespaceid_t)i, like, false);
+            size_t printed = printMaterials2((materialschemeid_t)i, like, false);
             if(printed != 0)
             {
                 printTotal += printed;
@@ -1915,33 +1915,33 @@ D_CMD(ListMaterials)
         return true;
     }
 
-    materialnamespaceid_t namespaceId = MN_ANY;
+    materialschemeid_t schemeId = MS_ANY;
     char const* like = 0;
     de::Uri uri;
 
-    // "listmaterials [namespace] [name]"
+    // "listmaterials [scheme] [path]"
     if(argc > 2)
     {
         uri.setScheme(argv[1]).setPath(argv[2]);
 
-        namespaceId = DD_ParseMaterialNamespace(uri.schemeCStr());
-        if(!VALID_MATERIALNAMESPACEID(namespaceId))
+        schemeId = DD_ParseMaterialSchemeName(uri.schemeCStr());
+        if(!VALID_MATERIALSCHEMEID(schemeId))
         {
-            Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+            Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
             return false;
         }
         like = uri.pathCStr();
     }
-    // "listmaterials [namespace:name]" i.e., a partial Uri
+    // "listmaterials [scheme:path]" (i.e., a partial Uri)
     else if(argc > 1)
     {
         uri.setUri(argv[1], RC_NULL);
         if(!uri.scheme().isEmpty())
         {
-            namespaceId = DD_ParseMaterialNamespace(uri.schemeCStr());
-            if(!VALID_MATERIALNAMESPACEID(namespaceId))
+            schemeId = DD_ParseMaterialSchemeName(uri.schemeCStr());
+            if(!VALID_MATERIALSCHEMEID(schemeId))
             {
-                Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+                Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
                 return false;
             }
 
@@ -1950,17 +1950,17 @@ D_CMD(ListMaterials)
         }
         else
         {
-            namespaceId = DD_ParseMaterialNamespace(uri.pathCStr());
+            schemeId = DD_ParseMaterialSchemeName(uri.pathCStr());
 
-            if(!VALID_MATERIALNAMESPACEID(namespaceId))
+            if(!VALID_MATERIALSCHEMEID(schemeId))
             {
-                namespaceId = MN_ANY;
+                schemeId = MS_ANY;
                 like = argv[1];
             }
         }
     }
 
-    printMaterials(namespaceId, like);
+    printMaterials(schemeId, like);
 
     return true;
 }
@@ -2040,10 +2040,10 @@ D_CMD(InspectMaterial)
 
     if(!search.scheme().isEmpty())
     {
-        materialnamespaceid_t namespaceId = DD_ParseMaterialNamespace(search.schemeCStr());
-        if(!VALID_MATERIALNAMESPACEID(namespaceId))
+        materialschemeid_t schemeId = DD_ParseMaterialSchemeName(search.schemeCStr());
+        if(!VALID_MATERIALSCHEMEID(schemeId))
         {
-            Con_Printf("Invalid namespace \"%s\".\n", search.schemeCStr());
+            Con_Printf("Invalid scheme \"%s\".\n", search.schemeCStr());
             return false;
         }
     }
@@ -2067,13 +2067,13 @@ D_CMD(PrintMaterialStats)
     DENG2_UNUSED(src); DENG2_UNUSED(argc); DENG2_UNUSED(argv);
 
     Con_FPrintf(CPF_YELLOW, "Material Statistics:\n");
-    for(uint i = uint(MATERIALNAMESPACE_FIRST); i <= uint(MATERIALNAMESPACE_LAST); ++i)
+    for(uint i = uint(MATERIALSCHEME_FIRST); i <= uint(MATERIALSCHEME_LAST); ++i)
     {
-        materialnamespaceid_t namespaceId = materialnamespaceid_t(i);
-        MaterialRepository& matDirectory = getDirectoryForNamespaceId(namespaceId);
+        materialschemeid_t schemeId = materialschemeid_t(i);
+        MaterialRepository& matDirectory = schemeById(schemeId);
         uint size = matDirectory.size();
 
-        Con_Printf("Namespace: %s (%u %s)\n", Str_Text(Materials_NamespaceName(namespaceId)), size, size==1? "material":"materials");
+        Con_Printf("Scheme: %s (%u %s)\n", Str_Text(Materials_SchemeName(schemeId)), size, size==1? "material":"materials");
         MaterialRepository::debugPrintHashDistribution(matDirectory);
         MaterialRepository::debugPrint(matDirectory);
     }
diff --git a/doomsday/engine/src/resource/models.cpp b/doomsday/engine/src/resource/models.cpp
index 6c3b1bd1fb..8f1cbe66a5 100644
--- a/doomsday/engine/src/resource/models.cpp
+++ b/doomsday/engine/src/resource/models.cpp
@@ -920,7 +920,7 @@ static void scaleModelToSprite(modeldef_t& mf, int sprite, int frame)
     materialsnapshot_t const* ms = Materials_Prepare(spr.spriteFrames[frame].mats[0], spec, true);
 
 #if _DEBUG
-    if(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TN_SPRITES)
+    if(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))) != TS_SPRITES)
         throw Error("scaleModelToSprite", "Material snapshot primary texture is not a SpriteTex");
 #endif
 
diff --git a/doomsday/engine/src/resource/r_data.c b/doomsday/engine/src/resource/r_data.c
index 220274d2d9..e9ba3b7340 100644
--- a/doomsday/engine/src/resource/r_data.c
+++ b/doomsday/engine/src/resource/r_data.c
@@ -1090,7 +1090,7 @@ void R_InitSystemTextures(void)
 
     VERBOSE( Con_Message("Initializing System textures...\n") )
 
-    Uri_SetScheme(uri, TN_SYSTEM_NAME);
+    Uri_SetScheme(uri, TS_SYSTEM_NAME);
     for(i = 0; defs[i].texPath; ++i)
     {
         Uri_SetPath(uri, defs[i].texPath);
@@ -1118,7 +1118,7 @@ static textureid_t findPatchTextureIdByName(const char* encodedName)
     assert(encodedName && encodedName[0]);
 
     uri = Uri_NewWithPath2(encodedName, RC_NULL);
-    Uri_SetScheme(uri, TN_PATCHES_NAME);
+    Uri_SetScheme(uri, TS_PATCHES_NAME);
     texId = Textures_ResolveUri2(uri, true/*quiet please*/);
     Uri_Delete(uri);
     return texId;
@@ -1168,7 +1168,7 @@ patchid_t R_DeclarePatch(const char* name)
     }
 
     // Compose the resource name
-    uri = Uri_NewWithPath2(TN_PATCHES_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(TS_PATCHES_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&encodedName));
     Str_Free(&encodedName);
 
@@ -1176,7 +1176,7 @@ patchid_t R_DeclarePatch(const char* name)
     resourcePath = Uri_NewWithPath2("Lumps:", RC_NULL);
     Uri_SetPath(resourcePath, Str_Text(F_LumpName(lumpNum)));
 
-    uniqueId = Textures_Count(TN_PATCHES)+1; // 1-based index.
+    uniqueId = Textures_Count(TS_PATCHES)+1; // 1-based index.
     texId = Textures_Declare(uri, uniqueId, resourcePath);
     Uri_Delete(resourcePath);
     Uri_Delete(uri);
@@ -1244,7 +1244,7 @@ boolean R_GetPatchInfo(patchid_t id, patchinfo_t* info)
         Con_Error("R_GetPatchInfo: Argument 'info' cannot be NULL.");
 
     memset(info, 0, sizeof *info);
-    tex = Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, id));
+    tex = Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, id));
     if(tex)
     {
         const patchtex_t* pTex = (patchtex_t*)Texture_UserDataPointer(tex);
@@ -1281,13 +1281,13 @@ boolean R_GetPatchInfo(patchid_t id, patchinfo_t* info)
 /// @note Part of the Doomsday public API.
 Uri* R_ComposePatchUri(patchid_t id)
 {
-    return Textures_ComposeUri(Textures_TextureForUniqueId(TN_PATCHES, id));
+    return Textures_ComposeUri(Textures_TextureForUniqueId(TS_PATCHES, id));
 }
 
 /// @note Part of the Doomsday public API.
 AutoStr* R_ComposePatchPath(patchid_t id)
 {
-    textureid_t texId = Textures_TextureForUniqueId(TN_PATCHES, id);
+    textureid_t texId = Textures_TextureForUniqueId(TS_PATCHES, id);
     if(texId == NOTEXTUREID) return AutoStr_NewStd();
     return Textures_ComposePath(texId);
 }
@@ -2061,7 +2061,7 @@ static void createTexturesForPatchCompositeDefs(patchcompositetex_t** defs, int
     int i;
     assert(defs);
 
-    Uri_SetScheme(uri, TN_TEXTURES_NAME);
+    Uri_SetScheme(uri, TS_TEXTURES_NAME);
     for(i = 0; i < count; ++i)
     {
         patchcompositetex_t* pcTex = defs[i];
@@ -2135,7 +2135,7 @@ static Uri* composeFlatUri(char const* lumpName)
     Uri* uri;
     AutoStr* flatName = AutoStr_NewStd();
     F_FileName(flatName, lumpName);
-    uri = Uri_NewWithPath2(TN_FLATS_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(TS_FLATS_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(flatName));
     return uri;
 }
@@ -2293,7 +2293,7 @@ int RIT_DefineSpriteTexture(textureid_t texId, void* paramaters)
 /// @todo Defer until necessary (sprite is first de-referenced).
 static void defineAllSpriteTextures(void)
 {
-    Textures_IterateDeclared(TN_SPRITES, RIT_DefineSpriteTexture);
+    Textures_IterateDeclared(TS_SPRITES, RIT_DefineSpriteTexture);
 }
 
 void R_InitSpriteTextures(void)
@@ -2306,7 +2306,7 @@ void R_InitSpriteTextures(void)
 
     VERBOSE( Con_Message("Initializing Sprite textures...\n") )
 
-    uri = Uri_NewWithPath2(TN_SPRITES_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(TS_SPRITES_NAME":", RC_NULL);
     resourcePath = Uri_NewWithPath2("Lumps:", RC_NULL);
 
     Str_Init(&spriteName);
@@ -2393,7 +2393,7 @@ Texture* R_CreateSkinTex(const Uri* filePath, boolean isShinySkin)
     }
     if(tex) return tex;
 
-    uniqueId = Textures_Count(isShinySkin? TN_MODELREFLECTIONSKINS : TN_MODELSKINS)+1;
+    uniqueId = Textures_Count(isShinySkin? TS_MODELREFLECTIONSKINS : TS_MODELSKINS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
 #if _DEBUG
@@ -2404,7 +2404,7 @@ Texture* R_CreateSkinTex(const Uri* filePath, boolean isShinySkin)
 
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, (isShinySkin? TN_MODELREFLECTIONSKINS_NAME : TN_MODELSKINS_NAME));
+    Uri_SetScheme(uri, (isShinySkin? TS_MODELREFLECTIONSKINS_NAME : TS_MODELSKINS_NAME));
 
     texId = Textures_Declare(uri, uniqueId, filePath);
     Uri_Delete(uri);
@@ -2494,7 +2494,7 @@ Texture* R_FindModelSkinForResourcePath(const Uri* path)
 {
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path))) return NULL;
-    result = Textures_IterateDeclared2(TN_MODELSKINS, findModelSkinForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_MODELSKINS, findModelSkinForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2503,7 +2503,7 @@ Texture* R_FindModelReflectionSkinForResourcePath(const Uri* path)
 {
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path))) return NULL;
-    result = Textures_IterateDeclared2(TN_MODELREFLECTIONSKINS, findModelSkinForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_MODELREFLECTIONSKINS, findModelSkinForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2737,7 +2737,7 @@ Texture* R_CreateDetailTextureFromDef(const ded_detailtexture_t* def)
     tex = R_FindDetailTextureForResourcePath(def->detailTex);
     if(tex) return tex;
 
-    uniqueId = Textures_Count(TN_DETAILS)+1;
+    uniqueId = Textures_Count(TS_DETAILS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
         Con_Message("Warning: failed to create new detail texture (max:%i).\n", DDMAXINT);
@@ -2746,7 +2746,7 @@ Texture* R_CreateDetailTextureFromDef(const ded_detailtexture_t* def)
 
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, TN_DETAILS_NAME);
+    Uri_SetScheme(uri, TS_DETAILS_NAME);
 
     texId = Textures_Declare(uri, uniqueId, def->detailTex);
     Uri_Delete(uri);
@@ -2776,7 +2776,7 @@ Texture* R_FindDetailTextureForResourcePath(const Uri* path)
 {
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path))) return NULL;
-    result = Textures_IterateDeclared2(TN_DETAILS, findDetailTextureForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_DETAILS, findDetailTextureForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2796,7 +2796,7 @@ Texture* R_CreateLightMap(const Uri* resourcePath)
     tex = R_FindLightMapForResourcePath(resourcePath);
     if(tex) return tex;
 
-    uniqueId = Textures_Count(TN_LIGHTMAPS)+1;
+    uniqueId = Textures_Count(TS_LIGHTMAPS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
         Con_Message("Warning: Failed declaring new LightMap (max:%i), ignoring.\n", DDMAXINT);
@@ -2805,7 +2805,7 @@ Texture* R_CreateLightMap(const Uri* resourcePath)
 
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, TN_LIGHTMAPS_NAME);
+    Uri_SetScheme(uri, TS_LIGHTMAPS_NAME);
 
     texId = Textures_Declare(uri, uniqueId, resourcePath);
     Uri_Delete(uri);
@@ -2840,7 +2840,7 @@ Texture* R_FindLightMapForResourcePath(const Uri* path)
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path)) || !Str_CompareIgnoreCase(Uri_Path(path), "-")) return NULL;
 
-    result = Textures_IterateDeclared2(TN_LIGHTMAPS, findLightMapTextureForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_LIGHTMAPS, findLightMapTextureForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2865,7 +2865,7 @@ Texture* R_CreateFlareTexture(const Uri* resourcePath)
     tex = R_FindFlareTextureForResourcePath(resourcePath);
     if(tex) return tex;
 
-    uniqueId = Textures_Count(TN_FLAREMAPS)+1;
+    uniqueId = Textures_Count(TS_FLAREMAPS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
         Con_Message("Warning: Failed declaring new FlareTex (max:%i), ignoring.\n", DDMAXINT);
@@ -2875,7 +2875,7 @@ Texture* R_CreateFlareTexture(const Uri* resourcePath)
     // Create a texture for it.
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, TN_FLAREMAPS_NAME);
+    Uri_SetScheme(uri, TS_FLAREMAPS_NAME);
 
     texId = Textures_Declare(uri, uniqueId, resourcePath);
     Uri_Delete(uri);
@@ -2909,7 +2909,7 @@ Texture* R_FindFlareTextureForResourcePath(const Uri* path)
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path)) || !Str_CompareIgnoreCase(Uri_Path(path), "-")) return NULL;
 
-    result = Textures_IterateDeclared2(TN_FLAREMAPS, findFlareTextureForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_FLAREMAPS, findFlareTextureForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2928,7 +2928,7 @@ Texture* R_CreateReflectionTexture(const Uri* resourcePath)
     tex = R_FindReflectionTextureForResourcePath(resourcePath);
     if(tex) return tex;
 
-    uniqueId = Textures_Count(TN_REFLECTIONS)+1;
+    uniqueId = Textures_Count(TS_REFLECTIONS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
         Con_Message("Warning: Failed declaring new ShinyTex (max:%i), ignoring.\n", DDMAXINT);
@@ -2937,7 +2937,7 @@ Texture* R_CreateReflectionTexture(const Uri* resourcePath)
 
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, TN_REFLECTIONS_NAME);
+    Uri_SetScheme(uri, TS_REFLECTIONS_NAME);
 
     texId = Textures_Declare(uri, uniqueId, resourcePath);
     Uri_Delete(uri);
@@ -2973,7 +2973,7 @@ Texture* R_FindReflectionTextureForResourcePath(const Uri* path)
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path))) return NULL;
 
-    result = Textures_IterateDeclared2(TN_REFLECTIONS, findReflectionTextureForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_REFLECTIONS, findReflectionTextureForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -2992,7 +2992,7 @@ Texture* R_CreateMaskTexture(const Uri* resourcePath, const Size2Raw* size)
     tex = R_FindMaskTextureForResourcePath(resourcePath);
     if(tex) return tex;
 
-    uniqueId = Textures_Count(TN_MASKS)+1;
+    uniqueId = Textures_Count(TS_MASKS)+1;
     if(M_NumDigits(uniqueId) > 8)
     {
         Con_Message("Warning: Failed declaring Mask texture (max:%i), ignoring.\n", DDMAXINT);
@@ -3001,7 +3001,7 @@ Texture* R_CreateMaskTexture(const Uri* resourcePath, const Size2Raw* size)
 
     dd_snprintf(name, 9, "%0*i", 8, uniqueId);
     uri = Uri_NewWithPath2(name, RC_NULL);
-    Uri_SetScheme(uri, TN_MASKS_NAME);
+    Uri_SetScheme(uri, TS_MASKS_NAME);
 
     texId = Textures_Declare(uri, uniqueId, resourcePath);
     Uri_Delete(uri);
@@ -3042,7 +3042,7 @@ Texture* R_FindMaskTextureForResourcePath(const Uri* path)
     int result;
     if(!path || Str_IsEmpty(Uri_Path(path))) return NULL;
 
-    result = Textures_IterateDeclared2(TN_MASKS, findMaskTextureForResourcePathWorker, (void*)path);
+    result = Textures_IterateDeclared2(TS_MASKS, findMaskTextureForResourcePathWorker, (void*)path);
     if(!result) return NULL;
     return Textures_ToTexture((textureid_t)result);
 }
@@ -3163,7 +3163,7 @@ boolean R_IsTextureInAnimGroup(const Uri* texture, int groupNum)
 
 font_t* R_CreateFontFromFile(Uri* uri, char const* resourcePath)
 {
-    fontnamespaceid_t namespaceId;
+    fontschemeid_t schemeId;
     fontid_t fontId;
     int uniqueId;
     font_t* font;
@@ -3177,15 +3177,15 @@ font_t* R_CreateFontFromFile(Uri* uri, char const* resourcePath)
         return NULL;
     }
 
-    namespaceId = Fonts_ParseNamespace(Str_Text(Uri_Scheme(uri)));
-    if(!VALID_FONTNAMESPACEID(namespaceId))
+    schemeId = Fonts_ParseScheme(Str_Text(Uri_Scheme(uri)));
+    if(!VALID_FONTSCHEMEID(schemeId))
     {
         AutoStr* path = Uri_ToString(uri);
-        Con_Message("Warning: Invalid font namespace in Font Uri \"%s\", ignoring.\n", Str_Text(path));
+        Con_Message("Warning: Invalid font scheme in Font Uri \"%s\", ignoring.\n", Str_Text(path));
         return NULL;
     }
 
-    uniqueId = Fonts_Count(namespaceId)+1; // 1-based index.
+    uniqueId = Fonts_Count(schemeId)+1; // 1-based index.
     fontId = Fonts_Declare(uri, uniqueId/*, resourcePath*/);
     if(fontId == NOFONTID) return NULL; // Invalid uri?
 
@@ -3210,7 +3210,7 @@ font_t* R_CreateFontFromFile(Uri* uri, char const* resourcePath)
 
 font_t* R_CreateFontFromDef(ded_compositefont_t* def)
 {
-    fontnamespaceid_t namespaceId;
+    fontschemeid_t schemeId;
     fontid_t fontId;
     int uniqueId;
     font_t* font;
@@ -3218,20 +3218,20 @@ font_t* R_CreateFontFromDef(ded_compositefont_t* def)
     if(!def || !def->uri)
     {
 #if _DEBUG
-        Con_Message("Warning:R_CreateFontFromDef: Invalid Definition or Uri reference, ignoring.\n");
+        Con_Message("Warning: R_CreateFontFromDef: Invalid Definition or Uri reference, ignoring.\n");
 #endif
         return NULL;
     }
 
-    namespaceId = Fonts_ParseNamespace(Str_Text(Uri_Scheme(def->uri)));
-    if(!VALID_FONTNAMESPACEID(namespaceId))
+    schemeId = Fonts_ParseScheme(Str_Text(Uri_Scheme(def->uri)));
+    if(!VALID_FONTSCHEMEID(schemeId))
     {
         AutoStr* path = Uri_ToString(def->uri);
-        Con_Message("Warning: Invalid font namespace in Font Definition Uri \"%s\", ignoring.\n", Str_Text(path));
+        Con_Message("Warning: Invalid URI scheme in font definition \"%s\", ignoring.\n", Str_Text(path));
         return NULL;
     }
 
-    uniqueId = Fonts_Count(namespaceId)+1; // 1-based index.
+    uniqueId = Fonts_Count(schemeId)+1; // 1-based index.
     fontId = Fonts_Declare(def->uri, uniqueId);
     if(fontId == NOFONTID) return NULL; // Invalid uri?
 
diff --git a/doomsday/engine/src/resource/textures.cpp b/doomsday/engine/src/resource/textures.cpp
index 9c371e35bb..d6db62a0f8 100644
--- a/doomsday/engine/src/resource/textures.cpp
+++ b/doomsday/engine/src/resource/textures.cpp
@@ -45,7 +45,7 @@ typedef de::PathTree TextureRepository;
  */
 struct TextureRecord
 {
-    /// Namespace-unique identifier chosen by the owner of the collection.
+    /// Scheme-unique identifier chosen by the owner of the collection.
     int uniqueId;
 
     /// Path to the data resource which contains/wraps the loadable texture data.
@@ -55,12 +55,12 @@ struct TextureRecord
     Texture* texture;
 };
 
-struct TextureNamespace
+struct TextureScheme
 {
     /// The texture directory contains the mappings between names and unique texture records.
     TextureRepository* directory;
 
-    /// LUT which translates namespace-unique-ids to their associated textureid_t (if any).
+    /// LUT which translates scheme-unique-ids to their associated textureid_t (if any).
     /// Index with uniqueId - uniqueIdBase.
     bool uniqueIdMapDirty;
     int uniqueIdBase;
@@ -80,8 +80,8 @@ static de::Uri* emptyUri;
 static uint textureIdMapSize;
 static TextureRepository::Node** textureIdMap;
 
-// Texture namespaces contain mappings between names and TextureRecord instances.
-static TextureNamespace namespaces[TEXTURENAMESPACE_COUNT];
+// Texture schemes contain mappings between names and TextureRecord instances.
+static TextureScheme schemes[TEXTURESCHEME_COUNT];
 
 void Textures_Register(void)
 {
@@ -99,24 +99,24 @@ const char* TexSource_Name(TexSource source)
     return "none";
 }
 
-static inline TextureRepository& getDirectoryForNamespaceId(texturenamespaceid_t id)
+static inline TextureRepository& schemeById(textureschemeid_t id)
 {
-    DENG2_ASSERT(VALID_TEXTURENAMESPACEID(id));
-    DENG2_ASSERT(namespaces[id-TEXTURENAMESPACE_FIRST].directory);
-    return *namespaces[id-TEXTURENAMESPACE_FIRST].directory;
+    DENG2_ASSERT(VALID_TEXTURESCHEMEID(id));
+    DENG2_ASSERT(schemes[id-TEXTURESCHEME_FIRST].directory);
+    return *schemes[id-TEXTURESCHEME_FIRST].directory;
 }
 
-static texturenamespaceid_t namespaceIdForDirectory(TextureRepository const& directory)
+static textureschemeid_t schemeIdForDirectory(TextureRepository const& directory)
 {
-    for(uint i = uint(TEXTURENAMESPACE_FIRST); i <= uint(TEXTURENAMESPACE_LAST); ++i)
+    for(uint i = uint(TEXTURESCHEME_FIRST); i <= uint(TEXTURESCHEME_LAST); ++i)
     {
-        uint idx = i - TEXTURENAMESPACE_FIRST;
-        if(namespaces[idx].directory == &directory) return texturenamespaceid_t(i);
+        uint idx = i - TEXTURESCHEME_FIRST;
+        if(schemes[idx].directory == &directory) return textureschemeid_t(i);
     }
 
     // Only reachable if attempting to find the id for a Texture that is not
     // in the collection, or the collection has not yet been initialized.
-    throw de::Error("Textures::namespaceIdForDirectory",
+    throw de::Error("Textures::schemeIdForDirectory",
                     de::String().sprintf("Failed to determine id for directory %p.", (void*)&directory));
 }
 
@@ -142,16 +142,16 @@ static textureid_t findBindIdForDirectoryNode(TextureRepository::Node const& nod
     return NOTEXTUREID; // Not linked.
 }
 
-static inline texturenamespaceid_t namespaceIdForDirectoryNode(TextureRepository::Node const& node)
+static inline textureschemeid_t schemeIdForDirectoryNode(TextureRepository::Node const& node)
 {
-    return namespaceIdForDirectory(node.tree());
+    return schemeIdForDirectory(node.tree());
 }
 
 /// @return  Newly composed Uri for @a node. Must be delete'd when no longer needed.
 static de::Uri composeUriForDirectoryNode(TextureRepository::Node const& node)
 {
-    Str const* namespaceName = Textures_NamespaceName(namespaceIdForDirectoryNode(node));
-    return node.composeUri().setScheme(Str_Text(namespaceName));
+    Str const* schemeName = Textures_SchemeName(schemeIdForDirectoryNode(node));
+    return node.composeUri().setScheme(Str_Text(schemeName));
 }
 
 /// @pre textureIdMap has been initialized and is large enough!
@@ -163,7 +163,7 @@ static void unlinkDirectoryNodeFromBindIdMap(TextureRepository::Node const& node
 }
 
 /// @pre uniqueIdMap has been initialized and is large enough!
-static void linkRecordInUniqueIdMap(TextureRecord const* record, TextureNamespace* tn,
+static void linkRecordInUniqueIdMap(TextureRecord const* record, TextureScheme* tn,
                                     textureid_t textureId)
 {
     DENG2_ASSERT(record && tn);
@@ -172,7 +172,7 @@ static void linkRecordInUniqueIdMap(TextureRecord const* record, TextureNamespac
 }
 
 /// @pre uniqueIdMap is large enough if initialized!
-static void unlinkRecordInUniqueIdMap(TextureRecord const* record, TextureNamespace* tn)
+static void unlinkRecordInUniqueIdMap(TextureRecord const* record, TextureScheme* tn)
 {
     DENG2_ASSERT(record && tn);
     // If the map is already considered 'dirty' do not unlink.
@@ -188,7 +188,7 @@ static void unlinkRecordInUniqueIdMap(TextureRecord const* record, TextureNamesp
  * @ingroup flags
  */
 ///@{
-#define VTUF_ALLOW_NAMESPACE_ANY    0x1 ///< The namespace of the uri may be of zero-length; signifying "any namespace".
+#define VTUF_ALLOW_ANY_SCHEME       0x1 ///< The scheme of the URI may be of zero-length; signifying "any scheme".
 #define VTUF_NO_URN                 0x2 ///< Do not accept a URN.
 ///@}
 
@@ -207,30 +207,30 @@ static bool validateTextureUri(de::Uri const& uri, int flags, bool quiet = false
     {
         if(!quiet)
         {
-            LOG_MSG("Invalid path in Texture uri \"%s\".") << uri;
+            LOG_MSG("Invalid path in texture URI \"%s\".") << uri;
         }
         return false;
     }
 
-    // If this is a URN we extract the namespace from the path.
-    de::String namespaceString;
+    // If this is a URN we extract the scheme from the path.
+    de::String schemeString;
     if(!uri.scheme().compareWithoutCase("urn"))
     {
         if(flags & VTUF_NO_URN) return false;
-        namespaceString = uri.path();
+        schemeString = uri.path();
     }
     else
     {
-        namespaceString = uri.scheme();
+        schemeString = uri.scheme();
     }
 
-    texturenamespaceid_t namespaceId = Textures_ParseNamespace(namespaceString.toUtf8().constData());
-    if(!((flags & VTUF_ALLOW_NAMESPACE_ANY) && namespaceId == TN_ANY) &&
-       !VALID_TEXTURENAMESPACEID(namespaceId))
+    textureschemeid_t schemeId = Textures_ParseSchemeName(schemeString.toUtf8().constData());
+    if(!((flags & VTUF_ALLOW_ANY_SCHEME) && schemeId == TS_ANY) &&
+       !VALID_TEXTURESCHEMEID(schemeId))
     {
         if(!quiet)
         {
-            LOG_MSG("Unknown namespace in Texture uri \"%s\".") << uri;
+            LOG_MSG("Unknown scheme in texture URI \"%s\".") << uri;
         }
         return false;
     }
@@ -241,7 +241,7 @@ static bool validateTextureUri(de::Uri const& uri, int flags, bool quiet = false
 /**
  * Given a directory and path, search the Textures collection for a match.
  *
- * @param directory Namespace-specific TextureRepository to search in.
+ * @param directory Scheme-specific TextureRepository to search in.
  * @param path      Path of the texture to search for.
  *
  * @return  Found DirectoryNode else @c NULL
@@ -263,13 +263,13 @@ static TextureRepository::Node* findDirectoryNodeForUri(de::Uri const& uri)
 {
     if(!uri.scheme().compareWithoutCase("urn"))
     {
-        // This is a URN of the form; urn:namespacename:uniqueid
-        texturenamespaceid_t namespaceId = Textures_ParseNamespace(uri.pathCStr());
+        // This is a URN of the form; urn:schemename:uniqueid
+        textureschemeid_t schemeId = Textures_ParseSchemeName(uri.pathCStr());
         int uidPos = uri.path().indexOf(':');
         if(uidPos >= 0)
         {
-            int uid = uri.path().mid(uidPos + 1 /*skip namespace delimiter*/).toInt();
-            textureid_t id = Textures_TextureForUniqueId(namespaceId, uid);
+            int uid = uri.path().mid(uidPos + 1 /*skip scheme delimiter*/).toInt();
+            textureid_t id = Textures_TextureForUniqueId(schemeId, uid);
             if(id != NOTEXTUREID)
             {
                 return directoryNodeForBindId(id);
@@ -279,39 +279,39 @@ static TextureRepository::Node* findDirectoryNodeForUri(de::Uri const& uri)
     }
 
     // This is a URI.
-    texturenamespaceid_t namespaceId = Textures_ParseNamespace(uri.schemeCStr());
+    textureschemeid_t schemeId = Textures_ParseSchemeName(uri.schemeCStr());
     de::String const& path = uri.path();
 
     TextureRepository::Node* node = NULL;
-    if(namespaceId != TN_ANY)
+    if(schemeId != TS_ANY)
     {
-        // Caller wants a texture in a specific namespace.
-        node = findDirectoryNodeForPath(getDirectoryForNamespaceId(namespaceId), path);
+        // Caller wants a texture in a specific scheme.
+        node = findDirectoryNodeForPath(schemeById(schemeId), path);
     }
     else
     {
-        // Caller does not care which namespace.
-        // Check for the texture in these namespaces in priority order.
-        static const texturenamespaceid_t order[] = {
-            TN_SPRITES,
-            TN_TEXTURES,
-            TN_FLATS,
-            TN_PATCHES,
-            TN_SYSTEM,
-            TN_DETAILS,
-            TN_REFLECTIONS,
-            TN_MASKS,
-            TN_MODELSKINS,
-            TN_MODELREFLECTIONSKINS,
-            TN_LIGHTMAPS,
-            TN_FLAREMAPS,
-            TN_ANY
+        // Caller does not care which scheme.
+        // Check for the texture in these schemes in priority order.
+        static const textureschemeid_t order[] = {
+            TS_SPRITES,
+            TS_TEXTURES,
+            TS_FLATS,
+            TS_PATCHES,
+            TS_SYSTEM,
+            TS_DETAILS,
+            TS_REFLECTIONS,
+            TS_MASKS,
+            TS_MODELSKINS,
+            TS_MODELREFLECTIONSKINS,
+            TS_LIGHTMAPS,
+            TS_FLAREMAPS,
+            TS_ANY
         };
         int n = 0;
         do
         {
-            node = findDirectoryNodeForPath(getDirectoryForNamespaceId(order[n]), path);
-        } while(!node && order[++n] != TN_ANY);
+            node = findDirectoryNodeForPath(schemeById(order[n]), path);
+        } while(!node && order[++n] != TS_ANY);
     }
     return node;
 }
@@ -333,19 +333,19 @@ static void destroyTexture(Texture* tex)
     DENG2_ASSERT(tex);
 
     GL_ReleaseGLTexturesByTexture(tex);
-    switch(Textures_Namespace(Textures_Id(tex)))
-    {
-    case TN_SYSTEM:
-    case TN_DETAILS:
-    case TN_REFLECTIONS:
-    case TN_MASKS:
-    case TN_MODELSKINS:
-    case TN_MODELREFLECTIONSKINS:
-    case TN_LIGHTMAPS:
-    case TN_FLAREMAPS:
-    case TN_FLATS: break;
-
-    case TN_TEXTURES: {
+    switch(Textures_Scheme(Textures_Id(tex)))
+    {
+    case TS_SYSTEM:
+    case TS_DETAILS:
+    case TS_REFLECTIONS:
+    case TS_MASKS:
+    case TS_MODELSKINS:
+    case TS_MODELREFLECTIONSKINS:
+    case TS_LIGHTMAPS:
+    case TS_FLAREMAPS:
+    case TS_FLATS: break;
+
+    case TS_TEXTURES: {
         patchcompositetex_t* pcTex = (patchcompositetex_t*)Texture_UserDataPointer(tex);
         if(pcTex)
         {
@@ -355,20 +355,20 @@ static void destroyTexture(Texture* tex)
         }
         break;
     }
-    case TN_SPRITES: {
+    case TS_SPRITES: {
         patchtex_t* pTex = (patchtex_t*)Texture_UserDataPointer(tex);
         if(pTex) M_Free(pTex);
         break;
     }
-    case TN_PATCHES: {
+    case TS_PATCHES: {
         patchtex_t* pTex = (patchtex_t*)Texture_UserDataPointer(tex);
         if(pTex) M_Free(pTex);
         break;
     }
     default:
         throw de::Error("Textures::destroyTexture",
-                        de::String("Internal error, invalid namespace id %1.")
-                            .arg((int)Textures_Namespace(Textures_Id(tex))));
+                        de::String("Internal error, invalid scheme id %1.")
+                            .arg((int)Textures_Scheme(Textures_Id(tex))));
     }
 
     clearTextureAnalyses(tex);
@@ -408,8 +408,8 @@ static void destroyRecord(TextureRepository::Node& node)
 
         unlinkDirectoryNodeFromBindIdMap(node);
 
-        texturenamespaceid_t const namespaceId = namespaceIdForDirectoryNode(node);
-        TextureNamespace* tn = &namespaces[namespaceId - TEXTURENAMESPACE_FIRST];
+        textureschemeid_t const schemeId = schemeIdForDirectoryNode(node);
+        TextureScheme* tn = &schemes[schemeId - TEXTURESCHEME_FIRST];
         unlinkRecordInUniqueIdMap(record, tn);
 
         // Detach our user data from this node.
@@ -427,9 +427,9 @@ void Textures_Init(void)
     textureIdMap = NULL;
     textureIdMapSize = 0;
 
-    for(uint i = 0; i < TEXTURENAMESPACE_COUNT; ++i)
+    for(uint i = 0; i < TEXTURESCHEME_COUNT; ++i)
     {
-        TextureNamespace* tn = &namespaces[i];
+        TextureScheme* tn = &schemes[i];
         tn->directory = new TextureRepository();
         tn->uniqueIdBase = 0;
         tn->uniqueIdMapSize = 0;
@@ -442,9 +442,9 @@ void Textures_Shutdown(void)
 {
     Textures_Clear();
 
-    for(uint i = 0; i < TEXTURENAMESPACE_COUNT; ++i)
+    for(uint i = 0; i < TEXTURESCHEME_COUNT; ++i)
     {
-        TextureNamespace* tn = &namespaces[i];
+        TextureScheme* tn = &schemes[i];
 
         if(tn->directory)
         {
@@ -476,69 +476,69 @@ void Textures_Shutdown(void)
     }
 }
 
-texturenamespaceid_t Textures_ParseNamespace(const char* str)
+textureschemeid_t Textures_ParseSchemeName(const char* str)
 {
-    static const struct namespace_s {
+    static const struct scheme_s {
         const char* name;
         size_t nameLen;
-        texturenamespaceid_t id;
-    } namespaces[TEXTURENAMESPACE_COUNT+1] = {
+        textureschemeid_t id;
+    } schemeNameIdMap[TEXTURESCHEME_COUNT+1] = {
         // Ordered according to a best guess of occurance frequency.
-        { TN_TEXTURES_NAME,     sizeof(TN_TEXTURES_NAME)-1,     TN_TEXTURES },
-        { TN_FLATS_NAME,        sizeof(TN_FLATS_NAME)-1,        TN_FLATS },
-        { TN_SPRITES_NAME,      sizeof(TN_SPRITES_NAME)-1,      TN_SPRITES },
-        { TN_PATCHES_NAME,      sizeof(TN_PATCHES_NAME)-1,      TN_PATCHES },
-        { TN_SYSTEM_NAME,       sizeof(TN_SYSTEM_NAME)-1,       TN_SYSTEM },
-        { TN_DETAILS_NAME,      sizeof(TN_DETAILS_NAME)-1,      TN_DETAILS },
-        { TN_REFLECTIONS_NAME,  sizeof(TN_REFLECTIONS_NAME)-1,  TN_REFLECTIONS },
-        { TN_MASKS_NAME,        sizeof(TN_MASKS_NAME)-1,        TN_MASKS },
-        { TN_MODELSKINS_NAME,   sizeof(TN_MODELSKINS_NAME)-1,   TN_MODELSKINS },
-        { TN_MODELREFLECTIONSKINS_NAME, sizeof(TN_MODELREFLECTIONSKINS_NAME)-1, TN_MODELREFLECTIONSKINS },
-        { TN_LIGHTMAPS_NAME,    sizeof(TN_LIGHTMAPS_NAME)-1,    TN_LIGHTMAPS },
-        { TN_FLAREMAPS_NAME,    sizeof(TN_FLAREMAPS_NAME)-1,    TN_FLAREMAPS },
-        { NULL,                 0,                              TN_INVALID }
+        { TS_TEXTURES_NAME,     sizeof(TS_TEXTURES_NAME)-1,     TS_TEXTURES },
+        { TS_FLATS_NAME,        sizeof(TS_FLATS_NAME)-1,        TS_FLATS },
+        { TS_SPRITES_NAME,      sizeof(TS_SPRITES_NAME)-1,      TS_SPRITES },
+        { TS_PATCHES_NAME,      sizeof(TS_PATCHES_NAME)-1,      TS_PATCHES },
+        { TS_SYSTEM_NAME,       sizeof(TS_SYSTEM_NAME)-1,       TS_SYSTEM },
+        { TS_DETAILS_NAME,      sizeof(TS_DETAILS_NAME)-1,      TS_DETAILS },
+        { TS_REFLECTIONS_NAME,  sizeof(TS_REFLECTIONS_NAME)-1,  TS_REFLECTIONS },
+        { TS_MASKS_NAME,        sizeof(TS_MASKS_NAME)-1,        TS_MASKS },
+        { TS_MODELSKINS_NAME,   sizeof(TS_MODELSKINS_NAME)-1,   TS_MODELSKINS },
+        { TS_MODELREFLECTIONSKINS_NAME, sizeof(TS_MODELREFLECTIONSKINS_NAME)-1, TS_MODELREFLECTIONSKINS },
+        { TS_LIGHTMAPS_NAME,    sizeof(TS_LIGHTMAPS_NAME)-1,    TS_LIGHTMAPS },
+        { TS_FLAREMAPS_NAME,    sizeof(TS_FLAREMAPS_NAME)-1,    TS_FLAREMAPS },
+        { NULL,                 0,                              TS_INVALID }
     };
 
-    // Special case: zero-length string means "any namespace".
+    // Special case: zero-length string means "any scheme".
     size_t len;
-    if(!str || 0 == (len = strlen(str))) return TN_ANY;
+    if(!str || 0 == (len = strlen(str))) return TS_ANY;
 
     // Stop comparing characters at the first occurance of ':'
     const char* end = strchr(str, ':');
     if(end) len = end - str;
 
-    for(size_t n = 0; namespaces[n].name; ++n)
+    for(size_t n = 0; schemeNameIdMap[n].name; ++n)
     {
-        if(len < namespaces[n].nameLen) continue;
-        if(strnicmp(str, namespaces[n].name, len)) continue;
-        return namespaces[n].id;
+        if(len < schemeNameIdMap[n].nameLen) continue;
+        if(strnicmp(str, schemeNameIdMap[n].name, len)) continue;
+        return schemeNameIdMap[n].id;
     }
 
-    return TN_INVALID; // Unknown.
+    return TS_INVALID; // Unknown.
 }
 
-const Str* Textures_NamespaceName(texturenamespaceid_t id)
+const Str* Textures_SchemeName(textureschemeid_t id)
 {
-    static const de::Str namespaceNames[1+TEXTURENAMESPACE_COUNT] = {
-        /* No namespace name */         "",
-        /* TN_SYSTEM */                 TN_SYSTEM_NAME,
-        /* TN_FLATS */                  TN_FLATS_NAME,
-        /* TN_TEXTURES */               TN_TEXTURES_NAME,
-        /* TN_SPRITES */                TN_SPRITES_NAME,
-        /* TN_PATCHES */                TN_PATCHES_NAME,
-        /* TN_DETAILS */                TN_DETAILS_NAME,
-        /* TN_REFLECTIONS */            TN_REFLECTIONS_NAME,
-        /* TN_MASKS */                  TN_MASKS_NAME,
-        /* TN_MODELSKINS */             TN_MODELSKINS_NAME,
-        /* TN_MODELREFLECTIONSKINS */   TN_MODELREFLECTIONSKINS_NAME,
-        /* TN_LIGHTMAPS */              TN_LIGHTMAPS_NAME,
-        /* TN_FLAREMAPS */              TN_FLAREMAPS_NAME
+    static const de::Str names[1+TEXTURESCHEME_COUNT] = {
+        /* No scheme name */            "",
+        /* TS_SYSTEM */                 TS_SYSTEM_NAME,
+        /* TS_FLATS */                  TS_FLATS_NAME,
+        /* TS_TEXTURES */               TS_TEXTURES_NAME,
+        /* TS_SPRITES */                TS_SPRITES_NAME,
+        /* TS_PATCHES */                TS_PATCHES_NAME,
+        /* TS_DETAILS */                TS_DETAILS_NAME,
+        /* TS_REFLECTIONS */            TS_REFLECTIONS_NAME,
+        /* TS_MASKS */                  TS_MASKS_NAME,
+        /* TS_MODELSKINS */             TS_MODELSKINS_NAME,
+        /* TS_MODELREFLECTIONSKINS */   TS_MODELREFLECTIONSKINS_NAME,
+        /* TS_LIGHTMAPS */              TS_LIGHTMAPS_NAME,
+        /* TS_FLAREMAPS */              TS_FLAREMAPS_NAME
     };
-    if(VALID_TEXTURENAMESPACEID(id))
+    if(VALID_TEXTURESCHEMEID(id))
     {
-        return namespaceNames[1 + (id - TEXTURENAMESPACE_FIRST)];
+        return names[1 + (id - TEXTURESCHEME_FIRST)];
     }
-    return namespaceNames[0];
+    return names[0];
 }
 
 uint Textures_Size(void)
@@ -546,17 +546,17 @@ uint Textures_Size(void)
     return textureIdMapSize;
 }
 
-uint Textures_Count(texturenamespaceid_t namespaceId)
+uint Textures_Count(textureschemeid_t schemeId)
 {
-    if(!VALID_TEXTURENAMESPACEID(namespaceId) || !Textures_Size()) return 0;
-    return getDirectoryForNamespaceId(namespaceId).size();
+    if(!VALID_TEXTURESCHEMEID(schemeId) || !Textures_Size()) return 0;
+    return schemeById(schemeId).size();
 }
 
 void Textures_Clear(void)
 {
     if(!Textures_Size()) return;
 
-    Textures_ClearNamespace(TN_ANY);
+    Textures_ClearScheme(TS_ANY);
     GL_PruneTextureVariantSpecifications();
 }
 
@@ -564,17 +564,17 @@ void Textures_ClearRuntime(void)
 {
     if(!Textures_Size()) return;
 
-    Textures_ClearNamespace(TN_FLATS);
-    Textures_ClearNamespace(TN_TEXTURES);
-    Textures_ClearNamespace(TN_PATCHES);
-    Textures_ClearNamespace(TN_SPRITES);
-    Textures_ClearNamespace(TN_DETAILS);
-    Textures_ClearNamespace(TN_REFLECTIONS);
-    Textures_ClearNamespace(TN_MASKS);
-    Textures_ClearNamespace(TN_MODELSKINS);
-    Textures_ClearNamespace(TN_MODELREFLECTIONSKINS);
-    Textures_ClearNamespace(TN_LIGHTMAPS);
-    Textures_ClearNamespace(TN_FLAREMAPS);
+    Textures_ClearScheme(TS_FLATS);
+    Textures_ClearScheme(TS_TEXTURES);
+    Textures_ClearScheme(TS_PATCHES);
+    Textures_ClearScheme(TS_SPRITES);
+    Textures_ClearScheme(TS_DETAILS);
+    Textures_ClearScheme(TS_REFLECTIONS);
+    Textures_ClearScheme(TS_MASKS);
+    Textures_ClearScheme(TS_MODELSKINS);
+    Textures_ClearScheme(TS_MODELREFLECTIONSKINS);
+    Textures_ClearScheme(TS_LIGHTMAPS);
+    Textures_ClearScheme(TS_FLAREMAPS);
 
     GL_PruneTextureVariantSpecifications();
 }
@@ -583,34 +583,34 @@ void Textures_ClearSystem(void)
 {
     if(!Textures_Size()) return;
 
-    Textures_ClearNamespace(TN_SYSTEM);
+    Textures_ClearScheme(TS_SYSTEM);
     GL_PruneTextureVariantSpecifications();
 }
 
-void Textures_ClearNamespace(texturenamespaceid_t namespaceId)
+void Textures_ClearScheme(textureschemeid_t schemeId)
 {
     if(!Textures_Size()) return;
 
-    texturenamespaceid_t from, to;
-    if(namespaceId == TN_ANY)
+    textureschemeid_t from, to;
+    if(schemeId == TS_ANY)
     {
-        from = TEXTURENAMESPACE_FIRST;
-        to   = TEXTURENAMESPACE_LAST;
+        from = TEXTURESCHEME_FIRST;
+        to   = TEXTURESCHEME_LAST;
     }
-    else if(VALID_TEXTURENAMESPACEID(namespaceId))
+    else if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        from = to = namespaceId;
+        from = to = schemeId;
     }
     else
     {
-        Con_Error("Textures::ClearNamespace: Invalid texture namespace %i.", (int) namespaceId);
+        Con_Error("Textures::ClearScheme: Invalid texture scheme %i.", (int) schemeId);
         exit(1); // Unreachable.
     }
 
     for(uint i = uint(from); i <= uint(to); ++i)
     {
-        texturenamespaceid_t iter = texturenamespaceid_t(i);
-        TextureNamespace* tn = &namespaces[iter - TEXTURENAMESPACE_FIRST];
+        textureschemeid_t iter = textureschemeid_t(i);
+        TextureScheme* tn = &schemes[iter - TEXTURESCHEME_FIRST];
 
         DENG2_FOR_EACH_CONST(TextureRepository::Nodes, nodeIt, tn->directory->leafNodes())
         {
@@ -647,7 +647,7 @@ Texture* Textures_ToTexture(textureid_t id)
     return NULL;
 }
 
-static void findUniqueIdBounds(TextureNamespace* tn, int* minId, int* maxId)
+static void findUniqueIdBounds(TextureScheme* tn, int* minId, int* maxId)
 {
     DENG2_ASSERT(tn);
     if(!minId && !maxId) return;
@@ -672,11 +672,11 @@ static void findUniqueIdBounds(TextureNamespace* tn, int* minId, int* maxId)
     }
 }
 
-static void rebuildUniqueIdMap(texturenamespaceid_t namespaceId)
+static void rebuildUniqueIdMap(textureschemeid_t schemeId)
 {
-    DENG2_ASSERT(VALID_TEXTURENAMESPACEID(namespaceId));
+    DENG2_ASSERT(VALID_TEXTURESCHEMEID(schemeId));
 
-    TextureNamespace* tn = &namespaces[namespaceId - TEXTURENAMESPACE_FIRST];
+    TextureScheme* tn = &schemes[schemeId - TEXTURESCHEME_FIRST];
 
     // Is a rebuild necessary?
     if(!tn->uniqueIdMapDirty) return;
@@ -721,13 +721,13 @@ static void rebuildUniqueIdMap(texturenamespaceid_t namespaceId)
     tn->uniqueIdMapDirty = false;
 }
 
-textureid_t Textures_TextureForUniqueId(texturenamespaceid_t namespaceId, int uniqueId)
+textureid_t Textures_TextureForUniqueId(textureschemeid_t schemeId, int uniqueId)
 {
-    if(VALID_TEXTURENAMESPACEID(namespaceId))
+    if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        TextureNamespace* tn = &namespaces[namespaceId - TEXTURENAMESPACE_FIRST];
+        TextureScheme* tn = &schemes[schemeId - TEXTURESCHEME_FIRST];
 
-        rebuildUniqueIdMap(namespaceId);
+        rebuildUniqueIdMap(schemeId);
         if(tn->uniqueIdMap && uniqueId >= tn->uniqueIdBase &&
            (unsigned)(uniqueId - tn->uniqueIdBase) <= tn->uniqueIdMapSize)
         {
@@ -744,7 +744,7 @@ textureid_t Textures_ResolveUri2(Uri const* _uri, boolean quiet)
     if(!_uri || !Textures_Size()) return NOTEXTUREID;
 
     de::Uri const& uri = reinterpret_cast(*_uri);
-    if(!validateTextureUri(uri, VTUF_ALLOW_NAMESPACE_ANY, true /*quiet please*/))
+    if(!validateTextureUri(uri, VTUF_ALLOW_ANY_SCHEME, true /*quiet please*/))
     {
 #if _DEBUG
         LOG_WARNING("Uri \"%s\" failed validation, returning NOTEXTUREID.") << uri;
@@ -830,8 +830,8 @@ static textureid_t Textures_Declare2(de::Uri& uri, int uniqueId, de::Uri const*
         record->resourcePath = NULL;
         record->uniqueId     = uniqueId;
 
-        texturenamespaceid_t namespaceId = Textures_ParseNamespace(uri.schemeCStr());
-        TextureNamespace* tn = &namespaces[namespaceId - TEXTURENAMESPACE_FIRST];
+        textureschemeid_t schemeId = Textures_ParseSchemeName(uri.schemeCStr());
+        TextureScheme* tn = &schemes[schemeId - TEXTURESCHEME_FIRST];
 
         node = tn->directory->insert(uri);
         node->setUserPointer(record);
@@ -856,8 +856,8 @@ static textureid_t Textures_Declare2(de::Uri& uri, int uniqueId, de::Uri const*
     bool releaseTexture = false;
     if(record->uniqueId != uniqueId)
     {
-        texturenamespaceid_t const namespaceId = namespaceIdForDirectoryNode(*node);
-        TextureNamespace* tn = &namespaces[namespaceId - TEXTURENAMESPACE_FIRST];
+        textureschemeid_t const schemeId = schemeIdForDirectoryNode(*node);
+        TextureScheme* tn = &schemes[schemeId - TEXTURESCHEME_FIRST];
 
         record->uniqueId = uniqueId;
         releaseTexture = true;
@@ -1005,14 +1005,14 @@ textureid_t Textures_Id(Texture* tex)
     return NOTEXTUREID;
 }
 
-texturenamespaceid_t Textures_Namespace(textureid_t id)
+textureschemeid_t Textures_Scheme(textureid_t id)
 {
-    LOG_AS("Textures::namespace");
+    LOG_AS("Textures::scheme");
 
     TextureRepository::Node* node = directoryNodeForBindId(id);
     if(node)
     {
-        return namespaceIdForDirectoryNode(*node);
+        return schemeIdForDirectoryNode(*node);
     }
 #if _DEBUG
     if(id != NOTEXTUREID)
@@ -1020,7 +1020,7 @@ texturenamespaceid_t Textures_Namespace(textureid_t id)
         LOG_WARNING("Attempted with unbound textureId #%u, returning null-object.") << id;
     }
 #endif
-    return TN_ANY;
+    return TS_ANY;
 }
 
 AutoStr* Textures_ComposePath(textureid_t id)
@@ -1067,11 +1067,11 @@ Uri* Textures_ComposeUrn(textureid_t id)
 
     if(record)
     {
-        Str const* namespaceName = Textures_NamespaceName(namespaceIdForDirectoryNode(*node));
+        Str const* schemeName = Textures_SchemeName(schemeIdForDirectoryNode(*node));
         AutoStr* path = AutoStr_NewStd();
 
-        Str_Reserve(path, Str_Length(namespaceName) +1/*delimiter*/ + M_NumDigits(DDMAXINT));
-        Str_Appendf(path, "%s:%i", Str_Text(namespaceName), record->uniqueId);
+        Str_Reserve(path, Str_Length(schemeName) +1/*delimiter*/ + M_NumDigits(DDMAXINT));
+        Str_Appendf(path, "%s:%i", Str_Text(schemeName), record->uniqueId);
 
         uri->setScheme("urn").setPath(Str_Text(path));
 
@@ -1087,25 +1087,25 @@ Uri* Textures_ComposeUrn(textureid_t id)
     return reinterpret_cast(uri);
 }
 
-int Textures_Iterate2(texturenamespaceid_t namespaceId,
+int Textures_Iterate2(textureschemeid_t schemeId,
     int (*callback)(Texture* tex, void* parameters), void* parameters)
 {
     if(!callback) return 0;
 
-    texturenamespaceid_t from, to;
-    if(VALID_TEXTURENAMESPACEID(namespaceId))
+    textureschemeid_t from, to;
+    if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        from = to = namespaceId;
+        from = to = schemeId;
     }
     else
     {
-        from = TEXTURENAMESPACE_FIRST;
-        to   = TEXTURENAMESPACE_LAST;
+        from = TEXTURESCHEME_FIRST;
+        to   = TEXTURESCHEME_LAST;
     }
 
     for(uint i = uint(from); i <= uint(to); ++i)
     {
-        TextureRepository& directory = getDirectoryForNamespaceId(texturenamespaceid_t(i));
+        TextureRepository& directory = schemeById(textureschemeid_t(i));
 
         DENG2_FOR_EACH_CONST(TextureRepository::Nodes, nodeIt, directory.leafNodes())
         {
@@ -1119,31 +1119,31 @@ int Textures_Iterate2(texturenamespaceid_t namespaceId,
     return 0;
 }
 
-int Textures_Iterate(texturenamespaceid_t namespaceId,
+int Textures_Iterate(textureschemeid_t schemeId,
     int (*callback)(Texture* tex, void* parameters))
 {
-    return Textures_Iterate2(namespaceId, callback, NULL/*no parameters*/);
+    return Textures_Iterate2(schemeId, callback, NULL/*no parameters*/);
 }
 
-int Textures_IterateDeclared2(texturenamespaceid_t namespaceId,
+int Textures_IterateDeclared2(textureschemeid_t schemeId,
     int (*callback)(textureid_t textureId, void* parameters), void* parameters)
 {
     if(!callback) return 0;
 
-    texturenamespaceid_t from, to;
-    if(VALID_TEXTURENAMESPACEID(namespaceId))
+    textureschemeid_t from, to;
+    if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        from = to = namespaceId;
+        from = to = schemeId;
     }
     else
     {
-        from = TEXTURENAMESPACE_FIRST;
-        to   = TEXTURENAMESPACE_LAST;
+        from = TEXTURESCHEME_FIRST;
+        to   = TEXTURESCHEME_LAST;
     }
 
     for(uint i = uint(from); i <= uint(to); ++i)
     {
-        TextureRepository& directory = getDirectoryForNamespaceId(texturenamespaceid_t(i));
+        TextureRepository& directory = schemeById(textureschemeid_t(i));
 
         DENG2_FOR_EACH_CONST(TextureRepository::Nodes, nodeIt, directory.leafNodes())
         {
@@ -1170,10 +1170,10 @@ int Textures_IterateDeclared2(texturenamespaceid_t namespaceId,
     return 0;
 }
 
-int Textures_IterateDeclared(texturenamespaceid_t namespaceId,
+int Textures_IterateDeclared(textureschemeid_t schemeId,
     int (*callback)(textureid_t textureId, void* parameters))
 {
-    return Textures_IterateDeclared2(namespaceId, callback, NULL/*no parameters*/);
+    return Textures_IterateDeclared2(schemeId, callback, NULL/*no parameters*/);
 }
 
 static int printVariantInfo(TextureVariant* variant, void* parameters)
@@ -1215,17 +1215,17 @@ static void printTextureInfo(Texture* tex)
     Uri_Delete(uri);
 }
 
-static void printTextureOverview(TextureRepository::Node& node, bool printNamespace)
+static void printTextureOverview(TextureRepository::Node& node, bool printSchemeName)
 {
     TextureRecord* record = reinterpret_cast(node.userPointer());
     textureid_t texId = findBindIdForDirectoryNode(node);
     int numUidDigits = MAX_OF(3/*uid*/, M_NumDigits(Textures_Size()));
     Uri* uri = record->texture? Textures_ComposeUri(texId) : Uri_New();
-    AutoStr* path = printNamespace? Uri_ToString(uri) : Str_PercentDecode(AutoStr_FromTextStd(Str_Text(Uri_Path(uri))));
+    AutoStr* path = printSchemeName? Uri_ToString(uri) : Str_PercentDecode(AutoStr_FromTextStd(Str_Text(Uri_Path(uri))));
     AutoStr* resourcePath = Uri_ToString(Textures_ResourcePath(texId));
 
     Con_FPrintf(!record->texture? CPF_LIGHT : CPF_WHITE,
-                "%-*s %*u %-6s x%u %s\n", printNamespace? 22 : 14, F_PrettyPath(Str_Text(path)),
+                "%-*s %*u %-6s x%u %s\n", printSchemeName? 22 : 14, F_PrettyPath(Str_Text(path)),
                 numUidDigits, texId, !record->texture? "unknown" : Texture_IsCustom(record->texture)? "addon" : "game",
                 Texture_VariantCount(record->texture), resourcePath? F_PrettyPath(Str_Text(resourcePath)) : "N/A");
 
@@ -1238,27 +1238,27 @@ static void printTextureOverview(TextureRepository::Node& node, bool printNamesp
  * However this is only presently used for the texture search/listing console commands
  * so is not hugely important right now.
  */
-static TextureRepository::Node** collectDirectoryNodes(texturenamespaceid_t namespaceId,
+static TextureRepository::Node** collectDirectoryNodes(textureschemeid_t schemeId,
     de::String like, uint* count, TextureRepository::Node** storage)
 {
-    texturenamespaceid_t fromId, toId;
+    textureschemeid_t fromId, toId;
 
-    if(VALID_TEXTURENAMESPACEID(namespaceId))
+    if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        // Only consider textures in this namespace.
-        fromId = toId = namespaceId;
+        // Only consider textures in this scheme.
+        fromId = toId = schemeId;
     }
     else
     {
-        // Consider textures in any namespace.
-        fromId = TEXTURENAMESPACE_FIRST;
-        toId   = TEXTURENAMESPACE_LAST;
+        // Consider textures in any scheme.
+        fromId = TEXTURESCHEME_FIRST;
+        toId   = TEXTURESCHEME_LAST;
     }
 
     int idx = 0;
     for(uint i = uint(fromId); i <= uint(toId); ++i)
     {
-        TextureRepository& directory = getDirectoryForNamespaceId(texturenamespaceid_t(i));
+        TextureRepository& directory = schemeById(textureschemeid_t(i));
 
         DENG2_FOR_EACH_CONST(TextureRepository::Nodes, nodeIt, directory.leafNodes())
         {
@@ -1302,7 +1302,7 @@ static TextureRepository::Node** collectDirectoryNodes(texturenamespaceid_t name
                         de::String("Failed on allocation of %1 bytes for new collection.")
                             .arg((unsigned long) (sizeof* storage * (idx+1)) ));
     }
-    return collectDirectoryNodes(namespaceId, like, count, storage);
+    return collectDirectoryNodes(schemeId, like, count, storage);
 }
 
 static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
@@ -1322,7 +1322,7 @@ static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
  * @ingroup flags
  */
 ///@{
-#define PTF_TRANSFORM_PATH_NO_NAMESPACE     0x1 ///< Do not print the namespace.
+#define PTF_TRANSFORM_PATH_NO_SCHEME        0x1 ///< Do not print the scheme.
 ///@}
 
 #define DEFAULT_PRINTTEXTUREFLAGS           0
@@ -1330,17 +1330,17 @@ static int composeAndCompareDirectoryNodePaths(void const* a, void const* b)
 /**
  * @param flags  @ref printTextureFlags
  */
-static size_t printTextures3(texturenamespaceid_t namespaceId, const char* like, int flags)
+static size_t printTextures3(textureschemeid_t schemeId, const char* like, int flags)
 {
-    const bool printNamespace = !(flags & PTF_TRANSFORM_PATH_NO_NAMESPACE);
+    const bool printSchemeName = !(flags & PTF_TRANSFORM_PATH_NO_SCHEME);
     uint count = 0;
-    TextureRepository::Node** foundTextures = collectDirectoryNodes(namespaceId, like, &count, NULL);
+    TextureRepository::Node** foundTextures = collectDirectoryNodes(schemeId, like, &count, NULL);
 
     if(!foundTextures) return 0;
 
-    if(!printNamespace)
-        Con_FPrintf(CPF_YELLOW, "Known textures in namespace '%s'", Str_Text(Textures_NamespaceName(namespaceId)));
-    else // Any namespace.
+    if(!printSchemeName)
+        Con_FPrintf(CPF_YELLOW, "Known textures in scheme '%s'", Str_Text(Textures_SchemeName(schemeId)));
+    else // Any scheme.
         Con_FPrintf(CPF_YELLOW, "Known textures");
 
     if(like && like[0])
@@ -1352,7 +1352,7 @@ static size_t printTextures3(texturenamespaceid_t namespaceId, const char* like,
     int numUidDigits   = MAX_OF(3/*uid*/, M_NumDigits((int)Textures_Size()));
 
     Con_Printf(" %*s: %-*s %*s origin x# path\n", numFoundDigits, "idx",
-        printNamespace? 22 : 14, printNamespace? "namespace:name" : "name",
+        printSchemeName? 22 : 14, printSchemeName? "scheme:name" : "name",
         numUidDigits, "uid");
     Con_PrintRuler();
 
@@ -1364,34 +1364,34 @@ static size_t printTextures3(texturenamespaceid_t namespaceId, const char* like,
     {
         TextureRepository::Node& node = **iter;
         Con_Printf(" %*u: ", numFoundDigits, idx++);
-        printTextureOverview(node, printNamespace);
+        printTextureOverview(node, printSchemeName);
     }
 
     M_Free(foundTextures);
     return count;
 }
 
-static void printTextures2(texturenamespaceid_t namespaceId, const char* like, int flags)
+static void printTextures2(textureschemeid_t schemeId, const char* like, int flags)
 {
     size_t printTotal = 0;
-    // Do we care which namespace?
-    if(namespaceId == TN_ANY && like && like[0])
+    // Do we care which scheme?
+    if(schemeId == TS_ANY && like && like[0])
     {
-        printTotal = printTextures3(namespaceId, like, flags & ~PTF_TRANSFORM_PATH_NO_NAMESPACE);
+        printTotal = printTextures3(schemeId, like, flags & ~PTF_TRANSFORM_PATH_NO_SCHEME);
         Con_PrintRuler();
     }
-    // Only one namespace to print?
-    else if(VALID_TEXTURENAMESPACEID(namespaceId))
+    // Only one scheme to print?
+    else if(VALID_TEXTURESCHEMEID(schemeId))
     {
-        printTotal = printTextures3(namespaceId, like, flags | PTF_TRANSFORM_PATH_NO_NAMESPACE);
+        printTotal = printTextures3(schemeId, like, flags | PTF_TRANSFORM_PATH_NO_SCHEME);
         Con_PrintRuler();
     }
     else
     {
-        // Collect and sort in each namespace separately.
-        for(int i = TEXTURENAMESPACE_FIRST; i <= TEXTURENAMESPACE_LAST; ++i)
+        // Collect and sort in each scheme separately.
+        for(int i = TEXTURESCHEME_FIRST; i <= TEXTURESCHEME_LAST; ++i)
         {
-            size_t printed = printTextures3((texturenamespaceid_t)i, like, flags | PTF_TRANSFORM_PATH_NO_NAMESPACE);
+            size_t printed = printTextures3((textureschemeid_t)i, like, flags | PTF_TRANSFORM_PATH_NO_SCHEME);
             if(printed != 0)
             {
                 printTotal += printed;
@@ -1402,9 +1402,9 @@ static void printTextures2(texturenamespaceid_t namespaceId, const char* like, i
     Con_Printf("Found %lu %s.\n", (unsigned long) printTotal, printTotal == 1? "Texture" : "Textures");
 }
 
-static void printTextures(texturenamespaceid_t namespaceId, const char* like)
+static void printTextures(textureschemeid_t schemeId, const char* like)
 {
-    printTextures2(namespaceId, like, DEFAULT_PRINTTEXTUREFLAGS);
+    printTextures2(schemeId, like, DEFAULT_PRINTTEXTUREFLAGS);
 }
 
 D_CMD(ListTextures)
@@ -1417,34 +1417,34 @@ D_CMD(ListTextures)
         return true;
     }
 
-    texturenamespaceid_t namespaceId = TN_ANY;
+    textureschemeid_t schemeId = TS_ANY;
     char const* like = 0;
     de::Uri uri;
 
-    // "listtextures [namespace] [name]"
+    // "listtextures [scheme] [path]"
     if(argc > 2)
     {
         uri.setScheme(argv[1]).setPath(argv[2]);
 
-        namespaceId = Textures_ParseNamespace(uri.schemeCStr());
-        if(!VALID_TEXTURENAMESPACEID(namespaceId))
+        schemeId = Textures_ParseSchemeName(uri.schemeCStr());
+        if(!VALID_TEXTURESCHEMEID(schemeId))
         {
-            Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+            Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
             return false;
         }
         like = uri.pathCStr();
     }
-    // "listtextures [namespace:name]" i.e., a partial Uri
+    // "listtextures [scheme:name]" (i.e., a partial URI)
     else if(argc > 1)
     {
         uri = uri.setUri(argv[1], RC_NULL);
 
         if(!uri.scheme().isEmpty())
         {
-            namespaceId = Textures_ParseNamespace(uri.schemeCStr());
-            if(!VALID_TEXTURENAMESPACEID(namespaceId))
+            schemeId = Textures_ParseSchemeName(uri.schemeCStr());
+            if(!VALID_TEXTURESCHEMEID(schemeId))
             {
-                Con_Printf("Invalid namespace \"%s\".\n", uri.schemeCStr());
+                Con_Printf("Invalid scheme \"%s\".\n", uri.schemeCStr());
                 return false;
             }
 
@@ -1453,16 +1453,16 @@ D_CMD(ListTextures)
         }
         else
         {
-            namespaceId = Textures_ParseNamespace(uri.pathCStr());
-            if(!VALID_TEXTURENAMESPACEID(namespaceId))
+            schemeId = Textures_ParseSchemeName(uri.pathCStr());
+            if(!VALID_TEXTURESCHEMEID(schemeId))
             {
-                namespaceId = TN_ANY;
+                schemeId = TS_ANY;
                 like = argv[1];
             }
         }
     }
 
-    printTextures(namespaceId, like);
+    printTextures(schemeId, like);
 
     return true;
 }
@@ -1481,10 +1481,10 @@ D_CMD(InspectTexture)
 
     if(!search.scheme().isEmpty())
     {
-        texturenamespaceid_t namespaceId = Textures_ParseNamespace(search.schemeCStr());
-        if(!VALID_TEXTURENAMESPACEID(namespaceId))
+        textureschemeid_t schemeId = Textures_ParseSchemeName(search.schemeCStr());
+        if(!VALID_TEXTURESCHEMEID(schemeId))
         {
-            Con_Printf("Invalid namespace \"%s\".\n", search.schemeCStr());
+            Con_Printf("Invalid scheme \"%s\".\n", search.schemeCStr());
             return false;
         }
     }
@@ -1517,13 +1517,13 @@ D_CMD(PrintTextureStats)
     }
 
     Con_FPrintf(CPF_YELLOW, "Texture Statistics:\n");
-    for(uint i = uint(TEXTURENAMESPACE_FIRST); i <= uint(TEXTURENAMESPACE_LAST); ++i)
+    for(uint i = uint(TEXTURESCHEME_FIRST); i <= uint(TEXTURESCHEME_LAST); ++i)
     {
-        texturenamespaceid_t namespaceId = texturenamespaceid_t(i);
-        TextureRepository& directory = getDirectoryForNamespaceId(namespaceId);
+        textureschemeid_t schemeId = textureschemeid_t(i);
+        TextureRepository& directory = schemeById(schemeId);
 
         uint size = directory.size();
-        Con_Printf("Namespace: %s (%u %s)\n", Str_Text(Textures_NamespaceName(namespaceId)), size, size==1? "texture":"textures");
+        Con_Printf("Scheme: %s (%u %s)\n", Str_Text(Textures_SchemeName(schemeId)), size, size==1? "texture":"textures");
         TextureRepository::debugPrintHashDistribution(directory);
         TextureRepository::debugPrint(directory);
     }
diff --git a/doomsday/engine/src/resource/zip.cpp b/doomsday/engine/src/resource/zip.cpp
index 1ef784064f..902e4dc095 100644
--- a/doomsday/engine/src/resource/zip.cpp
+++ b/doomsday/engine/src/resource/zip.cpp
@@ -990,8 +990,8 @@ static bool applyGamePathMappings(String& path)
     }
 
     // Key-named directories in the root might be mapped to another location.
-    FS1::Namespaces const& namespaces = App_FileSystem()->namespaces();
-    DENG2_FOR_EACH_CONST(FS1::Namespaces, i, namespaces)
+    FS1::Schemes const& schemes = App_FileSystem()->schemes();
+    DENG2_FOR_EACH_CONST(FS1::Schemes, i, schemes)
     {
         if((*i)->mapPath(path))
         {
diff --git a/doomsday/engine/src/ui/ui2_main.c b/doomsday/engine/src/ui/ui2_main.c
index b22dd8d046..9f6788a713 100644
--- a/doomsday/engine/src/ui/ui2_main.c
+++ b/doomsday/engine/src/ui/ui2_main.c
@@ -1053,9 +1053,9 @@ static void drawPicFrame(fidata_pic_t* p, uint frame, const float _origin[3],
                        ms->size.height + TS_GENERAL(spec)->border*2, 0);
                 TextureVariant_Coords(MST(ms, MTU_PRIMARY), &texScale[VX], &texScale[VY]);
 
-                switch(Textures_Namespace(Textures_Id(MSU_texture(ms, MTU_PRIMARY))))
+                switch(Textures_Scheme(Textures_Id(MSU_texture(ms, MTU_PRIMARY))))
                 {
-                case TN_SPRITES: {
+                case TS_SPRITES: {
                     patchtex_t* sTex = (patchtex_t*)Texture_UserDataPointer(MSU_texture(ms, MTU_PRIMARY));
                     if(sTex)
                     {
@@ -1073,7 +1073,7 @@ static void drawPicFrame(fidata_pic_t* p, uint frame, const float _origin[3],
             break;
           }
         case PFT_PATCH: {
-            Texture* texture = Textures_ToTexture(Textures_TextureForUniqueId(TN_PATCHES, f->texRef.patch));
+            Texture* texture = Textures_ToTexture(Textures_TextureForUniqueId(TS_PATCHES, f->texRef.patch));
             if(texture)
             {
                 TextureVariant* tex = GL_PreparePatchTexture(texture);
diff --git a/doomsday/engine/src/uri.cpp b/doomsday/engine/src/uri.cpp
index 344fcfcf65..ac4b6c7af5 100644
--- a/doomsday/engine/src/uri.cpp
+++ b/doomsday/engine/src/uri.cpp
@@ -249,7 +249,7 @@ struct Uri::Instance
         {
             scheme = path.left(sepPos);
 
-            if(defaultResourceClass == RC_NULL || App_FileSystem()->namespaceByName(scheme))
+            if(defaultResourceClass == RC_NULL || App_FileSystem()->schemeByName(scheme))
             {
                 path = path.mid(sepPos + 1);
                 return;
@@ -271,9 +271,9 @@ struct Uri::Instance
 
         if(VALID_RESOURCECLASSID(defaultResourceClass))
         {
-            FS1::Namespace* fnamespace = App_FileSystem()->namespaceByName(DD_ResourceClassById(defaultResourceClass).defaultNamespace());
-            DENG_ASSERT(fnamespace);
-            scheme = fnamespace->name();
+            FS1::Scheme* fsScheme = App_FileSystem()->schemeByName(DD_ResourceClassById(defaultResourceClass).defaultScheme());
+            DENG_ASSERT(fsScheme);
+            scheme = fsScheme->name();
         }
     }
 
diff --git a/doomsday/plugins/common/src/p_floor.c b/doomsday/plugins/common/src/p_floor.c
index 5f507e8025..c71a6b7b1e 100644
--- a/doomsday/plugins/common/src/p_floor.c
+++ b/doomsday/plugins/common/src/p_floor.c
@@ -458,7 +458,7 @@ int findLineInSectorSmallestBottomMaterial(void *ptr, void *context)
          * present, the height is taken from the very first texture.
          */
         if(!mat)
-            mat = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, 0));
+            mat = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, 0));
 
         if(mat)
         {
@@ -474,7 +474,7 @@ int findLineInSectorSmallestBottomMaterial(void *ptr, void *context)
         side = P_GetPtrp(li, DMU_SIDEDEF1);
         mat = P_GetPtrp(side, DMU_BOTTOM_MATERIAL);
         if(!mat)
-            mat = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, 0));
+            mat = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, 0));
 
         if(mat)
         {
diff --git a/doomsday/plugins/common/src/p_mapsetup.c b/doomsday/plugins/common/src/p_mapsetup.c
index 60f61d40ae..7a034379d6 100644
--- a/doomsday/plugins/common/src/p_mapsetup.c
+++ b/doomsday/plugins/common/src/p_mapsetup.c
@@ -877,7 +877,7 @@ static void P_FinalizeMap(void)
     if(!(gameModeBits & (GM_DOOM2_HACX|GM_DOOM_CHEX)))
     {
         uint i, k;
-        material_t* mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUriCString(MN_TEXTURES_NAME":NUKE24"));
+        material_t* mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUriCString(MS_TEXTURES_NAME":NUKE24"));
         material_t* bottomMat, *midMat;
         float yoff;
         SideDef* sidedef;
diff --git a/doomsday/plugins/common/src/p_saveg.c b/doomsday/plugins/common/src/p_saveg.c
index bf2eba75ce..57e2bb626e 100644
--- a/doomsday/plugins/common/src/p_saveg.c
+++ b/doomsday/plugins/common/src/p_saveg.c
@@ -2499,7 +2499,7 @@ static void SV_ReadSector(Sector* sec)
     if(hdr->version == 1)
     {
         // The flat numbers are absolute lump indices.
-        Uri* uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+        Uri* uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
         Uri_SetPath(uri, Str_Text(W_LumpName(SV_ReadShort())));
         floorMaterial = P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
 
@@ -3235,7 +3235,7 @@ static int SV_ReadFloor(floor_t* floor)
         else
         {
             // Flat number is an absolute lump index.
-            Uri* uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+            Uri* uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
             ddstring_t name;
             Str_Init(&name);
             F_FileName(&name, Str_Text(W_LumpName(SV_ReadShort())));
@@ -3288,7 +3288,7 @@ static int SV_ReadFloor(floor_t* floor)
         floor->state = (int) SV_ReadLong();
         floor->newSpecial = SV_ReadLong();
         // Flat number is an absolute lump index.
-        { Uri* uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+        { Uri* uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
         ddstring_t name;
         Str_Init(&name);
         F_FileName(&name, Str_Text(W_LumpName(SV_ReadShort())));
diff --git a/doomsday/plugins/common/src/p_switch.c b/doomsday/plugins/common/src/p_switch.c
index 3cd90db4e0..393cfa2def 100644
--- a/doomsday/plugins/common/src/p_switch.c
+++ b/doomsday/plugins/common/src/p_switch.c
@@ -152,7 +152,7 @@ void P_InitSwitchList(void)
     int i, index;
     ddstring_t path;
     Uri* uri = Uri_New();
-    Uri_SetScheme(uri, MN_TEXTURES_NAME);
+    Uri_SetScheme(uri, MS_TEXTURES_NAME);
 
     Str_Init(&path);
 
@@ -230,7 +230,7 @@ void P_InitSwitchList(void)
     }
 
     uri = Uri_New();
-    Uri_SetScheme(uri, MN_TEXTURES_NAME);
+    Uri_SetScheme(uri, MS_TEXTURES_NAME);
 
     Str_Init(&path);
     for(index = 0, i = 0; ; ++i)
diff --git a/doomsday/plugins/common/src/p_terraintype.c b/doomsday/plugins/common/src/p_terraintype.c
index b66a96e535..49e40f6605 100644
--- a/doomsday/plugins/common/src/p_terraintype.c
+++ b/doomsday/plugins/common/src/p_terraintype.c
@@ -170,24 +170,24 @@ void P_InitTerrainTypes(void)
         const char* ttName;
     } defs[] = {
 #if __JDOOM__ || __JDOOM64__
-        { MN_FLATS_NAME":FWATER1",  "Water" },
-        { MN_FLATS_NAME":LAVA1",    "Lava" },
-        { MN_FLATS_NAME":BLOOD1",   "Blood" },
-        { MN_FLATS_NAME":NUKAGE1",  "Nukage" },
-        { MN_FLATS_NAME":SLIME01",  "Slime" },
+        { MS_FLATS_NAME":FWATER1",  "Water" },
+        { MS_FLATS_NAME":LAVA1",    "Lava" },
+        { MS_FLATS_NAME":BLOOD1",   "Blood" },
+        { MS_FLATS_NAME":NUKAGE1",  "Nukage" },
+        { MS_FLATS_NAME":SLIME01",  "Slime" },
 #endif
 #if __JHERETIC__
-        { MN_FLATS_NAME":FLTWAWA1", "Water" },
-        { MN_FLATS_NAME":FLTFLWW1", "Water" },
-        { MN_FLATS_NAME":FLTLAVA1", "Lava" },
-        { MN_FLATS_NAME":FLATHUH1", "Lava" },
-        { MN_FLATS_NAME":FLTSLUD1", "Sludge" },
+        { MS_FLATS_NAME":FLTWAWA1", "Water" },
+        { MS_FLATS_NAME":FLTFLWW1", "Water" },
+        { MS_FLATS_NAME":FLTLAVA1", "Lava" },
+        { MS_FLATS_NAME":FLATHUH1", "Lava" },
+        { MS_FLATS_NAME":FLTSLUD1", "Sludge" },
 #endif
 #if __JHEXEN__
-        { MN_FLATS_NAME":X_005",    "Water" },
-        { MN_FLATS_NAME":X_001",    "Lava" },
-        { MN_FLATS_NAME":X_009",    "Sludge" },
-        { MN_FLATS_NAME":F_033",    "Ice" },
+        { MS_FLATS_NAME":X_005",    "Water" },
+        { MS_FLATS_NAME":X_001",    "Lava" },
+        { MS_FLATS_NAME":X_009",    "Sludge" },
+        { MS_FLATS_NAME":F_033",    "Ice" },
 #endif
         { 0, 0 }
     };
diff --git a/doomsday/plugins/common/src/p_xgfile.c b/doomsday/plugins/common/src/p_xgfile.c
index 3cb7420286..7001d4b9e5 100644
--- a/doomsday/plugins/common/src/p_xgfile.c
+++ b/doomsday/plugins/common/src/p_xgfile.c
@@ -384,8 +384,8 @@ void XG_ReadXGLump(lumpnum_t lumpNum)
             li->actChain = ReadShort();
             li->deactChain = ReadShort();
             li->wallSection = ReadByte();
-            li->actMaterial = DD_MaterialForTextureUniqueId(TN_TEXTURES, ReadShort());
-            li->deactMaterial = DD_MaterialForTextureUniqueId(TN_TEXTURES, ReadShort());
+            li->actMaterial = DD_MaterialForTextureUniqueId(TS_TEXTURES, ReadShort());
+            li->deactMaterial = DD_MaterialForTextureUniqueId(TS_TEXTURES, ReadShort());
             ReadString(&li->actMsg);
             ReadString(&li->deactMsg);
             li->materialMoveAngle = ReadFloat();
diff --git a/doomsday/plugins/common/src/p_xgsave.c b/doomsday/plugins/common/src/p_xgsave.c
index 6f1940e322..f069eee9ad 100644
--- a/doomsday/plugins/common/src/p_xgsave.c
+++ b/doomsday/plugins/common/src/p_xgsave.c
@@ -234,7 +234,7 @@ int SV_ReadXGPlaneMover(xgplanemover_t* mov)
     else
     {
         // Flat number is an absolute lump index.
-        Uri* uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+        Uri* uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
         ddstring_t name;
         Str_Init(&name);
         F_FileName(&name, Str_Text(W_LumpName(SV_ReadLong())));
diff --git a/doomsday/plugins/jdoom/src/p_oldsvg.c b/doomsday/plugins/jdoom/src/p_oldsvg.c
index 532ef04f4b..d515cb5356 100644
--- a/doomsday/plugins/jdoom/src/p_oldsvg.c
+++ b/doomsday/plugins/jdoom/src/p_oldsvg.c
@@ -375,8 +375,8 @@ static void P_v19_UnArchiveWorld(void)
 
         P_SetDoublep(sec, DMU_FLOOR_HEIGHT,   (coord_t) Reader_ReadInt16(svReader));
         P_SetDoublep(sec, DMU_CEILING_HEIGHT, (coord_t) Reader_ReadInt16(svReader));
-        P_SetPtrp   (sec, DMU_FLOOR_MATERIAL,   P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader))));
-        P_SetPtrp   (sec, DMU_CEILING_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader))));
+        P_SetPtrp   (sec, DMU_FLOOR_MATERIAL,   P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader))));
+        P_SetPtrp   (sec, DMU_CEILING_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader))));
 
         P_SetFloatp(sec, DMU_LIGHT_LEVEL, (float) (Reader_ReadInt16(svReader)) / 255.0f);
         xsec->special = Reader_ReadInt16(svReader); // needed?
@@ -407,9 +407,9 @@ static void P_v19_UnArchiveWorld(void)
             P_SetFloatpv(sdef, DMU_MIDDLE_MATERIAL_OFFSET_XY, matOffset);
             P_SetFloatpv(sdef, DMU_BOTTOM_MATERIAL_OFFSET_XY, matOffset);
 
-            P_SetPtrp   (sdef, DMU_TOP_MATERIAL,    P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
-            P_SetPtrp   (sdef, DMU_BOTTOM_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
-            P_SetPtrp   (sdef, DMU_MIDDLE_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp   (sdef, DMU_TOP_MATERIAL,    P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp   (sdef, DMU_BOTTOM_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp   (sdef, DMU_MIDDLE_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
         }
     }
 }
@@ -566,7 +566,7 @@ typedef struct {
 
     floor->state = (int) Reader_ReadInt32(svReader);
     floor->newSpecial = Reader_ReadInt32(svReader);
-    floor->material = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader)));
+    floor->material = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader)));
     floor->floorDestHeight = FIX2FLT(Reader_ReadInt32(svReader));
     floor->speed = FIX2FLT(Reader_ReadInt32(svReader));
 
diff --git a/doomsday/plugins/jdoom/src/p_spec.c b/doomsday/plugins/jdoom/src/p_spec.c
index 68574b3b94..9145a903bd 100644
--- a/doomsday/plugins/jdoom/src/p_spec.c
+++ b/doomsday/plugins/jdoom/src/p_spec.c
@@ -164,8 +164,8 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
 
         if(i == 0 || isTexture != lastIsTexture)
         {
-            Uri_SetScheme(startUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
-            Uri_SetScheme(endUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
+            Uri_SetScheme(startUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
+            Uri_SetScheme(endUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
             lastIsTexture = isTexture;
         }
         Str_PercentEncode(Str_StripRight(Str_Set(&startPath, animDefs[i].startname)));
@@ -210,7 +210,7 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
         for(n = startFrame; n <= endFrame; ++n)
         {
             Str_Clear(&framePath);
-            Str_Appendf(&framePath, "%s:%i", isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME, n);
+            Str_Appendf(&framePath, "%s:%i", isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME, n);
             Uri_SetPath(frameUrn, Str_Text(&framePath));
 
             R_AddAnimGroupFrame(groupNum, frameUrn, ticsPerFrame, 0);
diff --git a/doomsday/plugins/jdoom64/src/p_spec.c b/doomsday/plugins/jdoom64/src/p_spec.c
index ec6b691878..89ea073588 100644
--- a/doomsday/plugins/jdoom64/src/p_spec.c
+++ b/doomsday/plugins/jdoom64/src/p_spec.c
@@ -151,8 +151,8 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
 
         if(i == 0 || isTexture != lastIsTexture)
         {
-            Uri_SetScheme(startUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
-            Uri_SetScheme(endUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
+            Uri_SetScheme(startUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
+            Uri_SetScheme(endUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
             lastIsTexture = isTexture;
         }
 
@@ -199,7 +199,7 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
         for(n = startFrame; n <= endFrame; ++n)
         {
             Str_Clear(&framePath);
-            Str_Appendf(&framePath, "%s:%i", isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME, n);
+            Str_Appendf(&framePath, "%s:%i", isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME, n);
             Uri_SetPath(frameUrn, Str_Text(&framePath));
 
             R_AddAnimGroupFrame(groupNum, frameUrn, ticsPerFrame, 0);
diff --git a/doomsday/plugins/jheretic/src/in_lude.c b/doomsday/plugins/jheretic/src/in_lude.c
index 95045ff46c..92553854b3 100644
--- a/doomsday/plugins/jheretic/src/in_lude.c
+++ b/doomsday/plugins/jheretic/src/in_lude.c
@@ -646,7 +646,7 @@ void IN_Drawer(void)
 
 void IN_DrawStatBack(void)
 {
-    DGL_SetMaterialUI(P_ToPtr(DMU_MATERIAL, Materials_ResolveUriCString(MN_FLATS_NAME":FLOOR16")), DGL_REPEAT, DGL_REPEAT);
+    DGL_SetMaterialUI(P_ToPtr(DMU_MATERIAL, Materials_ResolveUriCString(MS_FLATS_NAME":FLOOR16")), DGL_REPEAT, DGL_REPEAT);
     DGL_Enable(DGL_TEXTURE_2D);
 
     DGL_Color4f(1, 1, 1, 1);
diff --git a/doomsday/plugins/jheretic/src/p_oldsvg.c b/doomsday/plugins/jheretic/src/p_oldsvg.c
index 14bec3dffd..1db5b5a8ab 100644
--- a/doomsday/plugins/jheretic/src/p_oldsvg.c
+++ b/doomsday/plugins/jheretic/src/p_oldsvg.c
@@ -391,8 +391,8 @@ static void P_v13_UnArchiveWorld(void)
 
         P_SetDoublep(sec, DMU_FLOOR_HEIGHT,     (coord_t)Reader_ReadInt16(svReader));
         P_SetDoublep(sec, DMU_CEILING_HEIGHT,   (coord_t)Reader_ReadInt16(svReader));
-        P_SetPtrp   (sec, DMU_FLOOR_MATERIAL,   P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader))));
-        P_SetPtrp   (sec, DMU_CEILING_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader))));
+        P_SetPtrp   (sec, DMU_FLOOR_MATERIAL,   P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader))));
+        P_SetPtrp   (sec, DMU_CEILING_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader))));
         P_SetFloatp (sec, DMU_LIGHT_LEVEL,      (float) (Reader_ReadInt16(svReader)) / 255.0f);
         xsec->special = Reader_ReadInt16(svReader); // needed?
         /*xsec->tag = **/Reader_ReadInt16(svReader); // needed?
@@ -423,9 +423,9 @@ static void P_v13_UnArchiveWorld(void)
             P_SetFixedp(sdef, DMU_MIDDLE_MATERIAL_OFFSET_Y, offy);
             P_SetFixedp(sdef, DMU_BOTTOM_MATERIAL_OFFSET_X, offx);
             P_SetFixedp(sdef, DMU_BOTTOM_MATERIAL_OFFSET_Y, offy);
-            P_SetPtrp  (sdef, DMU_TOP_MATERIAL,             P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
-            P_SetPtrp  (sdef, DMU_BOTTOM_MATERIAL,          P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
-            P_SetPtrp  (sdef, DMU_MIDDLE_MATERIAL,          P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp  (sdef, DMU_TOP_MATERIAL,             P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp  (sdef, DMU_BOTTOM_MATERIAL,          P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
+            P_SetPtrp  (sdef, DMU_MIDDLE_MATERIAL,          P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_TEXTURES, Reader_ReadInt16(svReader))));
         }
     }
 }
@@ -583,7 +583,7 @@ typedef struct {
 
     floor->state = (int) Reader_ReadInt32(svReader);
     floor->newSpecial = Reader_ReadInt32(svReader);
-    floor->material = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, Reader_ReadInt16(svReader)));
+    floor->material = P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TS_FLATS, Reader_ReadInt16(svReader)));
     floor->floorDestHeight = FIX2FLT(Reader_ReadInt32(svReader));
     floor->speed = FIX2FLT(Reader_ReadInt32(svReader));
 
diff --git a/doomsday/plugins/jheretic/src/p_spec.c b/doomsday/plugins/jheretic/src/p_spec.c
index 7383a1436a..3a8c9ad3d5 100644
--- a/doomsday/plugins/jheretic/src/p_spec.c
+++ b/doomsday/plugins/jheretic/src/p_spec.c
@@ -301,8 +301,8 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
 
         if(i == 0 || isTexture != lastIsTexture)
         {
-            Uri_SetScheme(startUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
-            Uri_SetScheme(endUri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
+            Uri_SetScheme(startUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
+            Uri_SetScheme(endUri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
             lastIsTexture = isTexture;
         }
         Str_PercentEncode(Str_StripRight(Str_Set(&startPath, animDefs[i].startname)));
@@ -347,7 +347,7 @@ static void loadAnimDefs(animdef_t* animDefs, boolean isCustom)
         for(n = startFrame; n <= endFrame; ++n)
         {
             Str_Clear(&framePath);
-            Str_Appendf(&framePath, "%s:%i", isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME, n);
+            Str_Appendf(&framePath, "%s:%i", isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME, n);
             Uri_SetPath(frameUrn, Str_Text(&framePath));
 
             R_AddAnimGroupFrame(groupNum, frameUrn, ticsPerFrame, 0);
diff --git a/doomsday/plugins/jhexen/src/p_acs.c b/doomsday/plugins/jhexen/src/p_acs.c
index 4a91cfe452..9b58767ded 100644
--- a/doomsday/plugins/jhexen/src/p_acs.c
+++ b/doomsday/plugins/jhexen/src/p_acs.c
@@ -1304,7 +1304,7 @@ static int CmdChangeFloor(void)
 
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, GetACString(Pop())));
-    uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&path));
     Str_Free(&path);
 
@@ -1340,7 +1340,7 @@ static int CmdChangeFloorDirect(void)
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, GetACString(LONG(*PCodePtr++))));
 
-    uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&path));
     mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
     Uri_Delete(uri);
@@ -1372,7 +1372,7 @@ static int CmdChangeCeiling(void)
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, GetACString(Pop())));
 
-    uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&path));
     mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
     Uri_Delete(uri);
@@ -1407,7 +1407,7 @@ static int CmdChangeCeilingDirect(void)
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, GetACString(LONG(*PCodePtr++))));
 
-    uri = Uri_NewWithPath2(MN_FLATS_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_FLATS_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&path));
     mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
     Uri_Delete(uri);
@@ -1761,7 +1761,7 @@ static int CmdSetLineTexture(void)
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, GetACString(Pop())));
 
-    uri = Uri_NewWithPath2(MN_TEXTURES_NAME":", RC_NULL);
+    uri = Uri_NewWithPath2(MS_TEXTURES_NAME":", RC_NULL);
     Uri_SetPath(uri, Str_Text(&path));
     mat = P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
     Uri_Delete(uri);
diff --git a/doomsday/plugins/jhexen/src/p_anim.c b/doomsday/plugins/jhexen/src/p_anim.c
index f0bcd172ba..e6050e8831 100644
--- a/doomsday/plugins/jhexen/src/p_anim.c
+++ b/doomsday/plugins/jhexen/src/p_anim.c
@@ -42,7 +42,7 @@ static void parseAnimGroup(boolean isTexture, boolean isCustom)
     }
 
     uri = Uri_New();
-    Uri_SetScheme(uri, isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME);
+    Uri_SetScheme(uri, isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME);
     Str_Init(&path);
     Str_PercentEncode(Str_Set(&path, sc_String));
     Uri_SetPath(uri, Str_Text(&path));
@@ -92,7 +92,7 @@ static void parseAnimGroup(boolean isTexture, boolean isCustom)
                     ddstring_t framePath;
 
                     Str_Init(&framePath);
-                    Str_Appendf(&framePath, "%s:%i", isTexture? TN_TEXTURES_NAME : TN_FLATS_NAME, texNumBase + picNum - 1);
+                    Str_Appendf(&framePath, "%s:%i", isTexture? TS_TEXTURES_NAME : TS_FLATS_NAME, texNumBase + picNum - 1);
                     Uri_SetPath(frameUrn, Str_Text(&framePath));
 
                     R_AddAnimGroupFrame(groupNumber, frameUrn, min, (max > 0? max - min : 0));
diff --git a/doomsday/plugins/jhexen/src/p_mapinfo.c b/doomsday/plugins/jhexen/src/p_mapinfo.c
index 00b830b2ee..522ee6fb15 100644
--- a/doomsday/plugins/jhexen/src/p_mapinfo.c
+++ b/doomsday/plugins/jhexen/src/p_mapinfo.c
@@ -173,7 +173,7 @@ void P_InitMapInfo(void)
     defMapInfo.warpTrans = 0;
     defMapInfo.nextMap = 0; // Always go to map 0 if not specified.
     defMapInfo.cdTrack = 1;
-    defMapInfo.sky1Material = Materials_ResolveUriCString(gameMode == hexen_demo || gameMode == hexen_betademo? MN_TEXTURES_NAME":SKY2" : MN_TEXTURES_NAME":SKY1");
+    defMapInfo.sky1Material = Materials_ResolveUriCString(gameMode == hexen_demo || gameMode == hexen_betademo? MS_TEXTURES_NAME":SKY2" : MS_TEXTURES_NAME":SKY1");
     defMapInfo.sky2Material = defMapInfo.sky1Material;
     defMapInfo.sky1ScrollDelta = 0;
     defMapInfo.sky2ScrollDelta = 0;
@@ -268,7 +268,7 @@ void P_InitMapInfo(void)
                 Str_Init(&path);
                 Str_PercentEncode(Str_Set(&path, sc_String));
 
-                uri = Uri_NewWithPath2(MN_TEXTURES_NAME":", RC_NULL);
+                uri = Uri_NewWithPath2(MS_TEXTURES_NAME":", RC_NULL);
                 Uri_SetPath(uri, Str_Text(&path));
                 info->sky1Material = Materials_ResolveUri(uri);
                 Uri_Delete(uri);
@@ -286,7 +286,7 @@ void P_InitMapInfo(void)
                 Str_Init(&path);
                 Str_PercentEncode(Str_Set(&path, sc_String));
 
-                uri = Uri_NewWithPath2(MN_TEXTURES_NAME":", RC_NULL);
+                uri = Uri_NewWithPath2(MS_TEXTURES_NAME":", RC_NULL);
                 Uri_SetPath(uri, Str_Text(&path));
                 info->sky2Material = Materials_ResolveUri(uri);
                 Uri_Delete(uri);
diff --git a/doomsday/plugins/wadmapconverter/src/id1map.cpp b/doomsday/plugins/wadmapconverter/src/id1map.cpp
index 5ff76905be..e519e48262 100644
--- a/doomsday/plugins/wadmapconverter/src/id1map.cpp
+++ b/doomsday/plugins/wadmapconverter/src/id1map.cpp
@@ -62,7 +62,7 @@ MaterialDictId Id1Map::addMaterialToDictionary(char const* name, MaterialDictGro
         //char name[9];
         //sprintf(name, "UNK%05i", uniqueId); name[8] = '\0';
 
-        Uri* uri = Materials_ComposeUri(DD_MaterialForTextureUniqueId((group == MG_PLANE? TN_FLATS : TN_TEXTURES), uniqueId));
+        Uri* uri = Materials_ComposeUri(DD_MaterialForTextureUniqueId((group == MG_PLANE? TS_FLATS : TS_TEXTURES), uniqueId));
         uriCString = Uri_Compose(uri);
         Uri_Delete(uri);
     }
@@ -79,7 +79,7 @@ MaterialDictId Id1Map::addMaterialToDictionary(char const* name, MaterialDictGro
         // Material paths must be encoded.
         AutoStr* path = Str_PercentEncode(AutoStr_FromText(name));
         Uri* uri = Uri_NewWithPath2(Str_Text(path), RC_NULL);
-        Uri_SetScheme(uri, group == MG_PLANE? MN_FLATS_NAME : MN_TEXTURES_NAME);
+        Uri_SetScheme(uri, group == MG_PLANE? MS_FLATS_NAME : MS_TEXTURES_NAME);
         uriCString = Uri_Compose(uri);
         Uri_Delete(uri);
     }