resource: better names for DATA_COMPILER_* macros

src/resource/compile_options.inl

@@ -11,39 +11,39 @@
 #include "core/filesystem/reader_writer.inl"
 #include "resource/compile_options.h"
 
-#define DATA_COMPILER_ASSERT(condition, opts, msg, ...) \
-	do                                                  \
-	{                                                   \
-		if (!(condition))                               \
-		{                                               \
-			opts.error(msg, ## __VA_ARGS__);            \
-			return -1;                                  \
-		}                                               \
+#define RETURN_IF_FALSE(condition, opts, msg, ...) \
+	do                                             \
+	{                                              \
+		if (!(condition))                          \
+		{                                          \
+			opts.error(msg, ## __VA_ARGS__);       \
+			return -1;                             \
+		}                                          \
 	} while (0)
 
-#define DATA_COMPILER_ENSURE(condition, opts)             \
-	DATA_COMPILER_ASSERT(condition                        \
-		, opts                                            \
-		, "DATA_COMPILER_ENSURE(" # condition ") failed." \
+#define ENSURE_OR_RETURN(condition, opts) \
+	RETURN_IF_FALSE(condition             \
+		, opts                            \
+		, # condition " failed."          \
 		)
 
-#define DATA_COMPILER_ASSERT_RESOURCE_EXISTS(type, name, opts) \
-	DATA_COMPILER_ASSERT(opts.resource_exists(type, name)      \
-		, opts                                                 \
-		, opts._server                                         \
-		? "Resource not found: " RESOURCE_ID_FMT_STR_PAIR      \
-		: "Resource not found: %s.%s"                          \
-		, name                                                 \
-		, type                                                 \
+#define RETURN_IF_RESOURCE_MISSING(type, name, opts)      \
+	RETURN_IF_FALSE(opts.resource_exists(type, name)      \
+		, opts                                            \
+		, opts._server                                    \
+		? "Resource not found: " RESOURCE_ID_FMT_STR_PAIR \
+		: "Resource not found: %s.%s"                     \
+		, name                                            \
+		, type                                            \
 		)
 
-#define DATA_COMPILER_ASSERT_FILE_EXISTS(name, opts) \
-	DATA_COMPILER_ASSERT(opts.file_exists(name)      \
-		, opts                                       \
-		, opts._server                               \
-		? "File not found: #FILE(%s)"                \
-		: "File not found: %s"                       \
-		, name                                       \
+#define RETURN_IF_FILE_MISSING(name, opts) \
+	RETURN_IF_FALSE(opts.file_exists(name) \
+		, opts                             \
+		, opts._server                     \
+		? "File not found: #FILE(%s)"      \
+		: "File not found: %s"             \
+		, name                             \
 		)
 
 #define RETURN_IF_ERROR(sjson_func, opts) \

src/resource/config_resource.cpp

@@ -48,15 +48,15 @@ namespace config_resource_internal
 
 		const char *boot_script_json  = boot["boot_script"];
 		const char *boot_package_json = boot["boot_package"];
-		DATA_COMPILER_ASSERT(boot_script_json != NULL, opts, "'boot_script' must be specified.");
-		DATA_COMPILER_ASSERT(boot_package_json != NULL, opts, "'boot_package' must be specified.");
+		RETURN_IF_FALSE(boot_script_json != NULL, opts, "'boot_script' must be specified.");
+		RETURN_IF_FALSE(boot_package_json != NULL, opts, "'boot_package' must be specified.");
 
 		DynamicString boot_script(ta);
 		DynamicString boot_package(ta);
 		RETURN_IF_ERROR(sjson::parse_string(boot_script, boot_script_json), opts);
 		RETURN_IF_ERROR(sjson::parse_string(boot_package, boot_package_json), opts);
-		DATA_COMPILER_ASSERT_RESOURCE_EXISTS("lua", boot_script.c_str(), opts);
-		DATA_COMPILER_ASSERT_RESOURCE_EXISTS("package", boot_package.c_str(), opts);
+		RETURN_IF_RESOURCE_MISSING("lua", boot_script.c_str(), opts);
+		RETURN_IF_RESOURCE_MISSING("package", boot_package.c_str(), opts);
 
 		if (opts._bundle) {
 			TempAllocator256 ta;

src/resource/font_resource.cpp

@@ -87,7 +87,7 @@ namespace font_resource_internal
 
 		const u32 texture_size = RETURN_IF_ERROR(sjson::parse_int(obj["size"]), opts);
 		const u32 font_size    = RETURN_IF_ERROR(sjson::parse_int(obj["font_size"]), opts);
-		DATA_COMPILER_ASSERT(font_size > 0
+		RETURN_IF_FALSE(font_size > 0
 			, opts
 			, "Font size must be > 0"
 			);
@@ -95,7 +95,7 @@ namespace font_resource_internal
 		s32 err = 0;
 		Array<GlyphInfo> _glyphs(default_allocator());
 		err = parse_glyphs(_glyphs, glyphs, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		std::sort(array::begin(_glyphs), array::end(_glyphs));
 
 		opts.write(RESOURCE_HEADER(RESOURCE_VERSION_FONT));

src/resource/level_resource.cpp

@@ -65,7 +65,7 @@ namespace level_resource_internal
 
 				DynamicString sound_name(ta);
 				RETURN_IF_ERROR(sjson::parse_string(sound_name, sound["name"]), opts);
-				DATA_COMPILER_ASSERT_RESOURCE_EXISTS("sound"
+				RETURN_IF_RESOURCE_MISSING("sound"
 					, sound_name.c_str()
 					, opts
 					);
@@ -84,11 +84,11 @@ namespace level_resource_internal
 
 		UnitCompiler uc(default_allocator(), opts);
 		s32 err = unit_compiler::parse_unit_array_from_json(uc, obj["units"]);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		Buffer units_blob(default_allocator());
 		err = unit_compiler::blob(units_blob, uc);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		// Write
 		LevelResource lr;

src/resource/lua_resource.cpp

@@ -134,7 +134,7 @@ namespace lua_resource_internal
 		Process pr;
 		s32 sc;
 		sc = pr.spawn(argv, CROWN_PROCESS_STDOUT_PIPE | CROWN_PROCESS_STDERR_MERGE);
-		DATA_COMPILER_ASSERT(sc == 0
+		RETURN_IF_FALSE(sc == 0
 			, opts
 			, "Failed to spawn `%s`"
 			, argv[0]
@@ -159,7 +159,7 @@ namespace lua_resource_internal
 		StringStream output(ta);
 		opts.read_output(output, pr);
 		s32 ec = pr.wait();
-		DATA_COMPILER_ASSERT(ec == 0
+		RETURN_IF_FALSE(ec == 0
 			, opts
 			, "Failed to compile lua:\n%s"
 			, string_stream::c_str(output)

src/resource/material_resource.cpp

@@ -160,7 +160,7 @@ namespace material_resource_internal
 
 			DynamicString texture(ta);
 			RETURN_IF_ERROR(sjson::parse_string(texture, value), opts);
-			DATA_COMPILER_ASSERT_RESOURCE_EXISTS("texture", texture.c_str(), opts);
+			RETURN_IF_RESOURCE_MISSING("texture", texture.c_str(), opts);
 			opts.add_requirement("texture", texture.c_str());
 
 			TextureHandle th;
@@ -208,7 +208,7 @@ namespace material_resource_internal
 			RETURN_IF_ERROR(sjson::parse_string(type, uniform["type"]), opts);
 
 			const UniformType::Enum ut = name_to_uniform_type(type.c_str());
-			DATA_COMPILER_ASSERT(ut != UniformType::COUNT
+			RETURN_IF_FALSE(ut != UniformType::COUNT
 				, opts
 				, "Unknown uniform type: '%s'"
 				, type.c_str()
@@ -298,11 +298,11 @@ namespace material_resource_internal
 
 		if (json_object::has(obj, "textures")) {
 			s32 err = parse_textures(texdata, names, dynblob, obj["textures"], opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 		if (json_object::has(obj, "uniforms")) {
 			s32 err = parse_uniforms(unidata, names, dynblob, obj["uniforms"], opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 
 		MaterialResource mr;

src/resource/mesh_resource.cpp

@@ -225,7 +225,7 @@ namespace mesh
 
 		if (json_object::has(obj, "children")) {
 			s32 err = mesh::parse_nodes(*mesh, obj["children"], opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 
 		if (json_object::has(obj, "geometry")) {
@@ -263,15 +263,15 @@ namespace mesh
 		RETURN_IF_ERROR(sjson::parse(obj, sjson), opts);
 
 		s32 err = parse_float_array(g._positions, obj["position"], opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		if (json_object::has(obj, "normal")) {
 			err = parse_float_array(g._normals, obj["normal"], opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 		if (json_object::has(obj, "texcoord")) {
 			err = parse_float_array(g._uvs, obj["texcoord"], opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 
 		return parse_indices(g, obj["indices"], opts);
@@ -290,11 +290,11 @@ namespace mesh
 
 			Geometry geo(default_allocator());
 			s32 err = mesh::parse_geometry(geo, cur->second, opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 
 			DynamicString geometry_name(ta);
 			geometry_name = cur->first;
-			DATA_COMPILER_ASSERT(!hash_map::has(m._geometries, geometry_name)
+			RETURN_IF_FALSE(!hash_map::has(m._geometries, geometry_name)
 				, opts
 				, "Geometry redefined: '%s'"
 				, geometry_name.c_str()
@@ -318,11 +318,11 @@ namespace mesh
 
 			Node node(default_allocator());
 			s32 err = mesh::parse_node(node, cur->second, &m, opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 
 			DynamicString node_name(ta);
 			node_name = cur->first;
-			DATA_COMPILER_ASSERT(!hash_map::has(m._nodes, node_name)
+			RETURN_IF_FALSE(!hash_map::has(m._nodes, node_name)
 				, opts
 				, "Node redefined: '%s'"
 				, node_name.c_str()
@@ -334,7 +334,7 @@ namespace mesh
 			if (node._geometry == "")
 				node._geometry = node_name;
 
-			DATA_COMPILER_ASSERT(hash_map::has(m._geometries, node._geometry)
+			RETURN_IF_FALSE(hash_map::has(m._geometries, node._geometry)
 				, opts
 				, "Node '%s' references unexisting geometry '%s'"
 				, node_name.c_str()
@@ -354,7 +354,7 @@ namespace mesh
 		RETURN_IF_ERROR(sjson::parse(obj, buf), opts);
 
 		s32 err = mesh::parse_geometries(m, obj["geometries"], opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		return mesh::parse_nodes(m, obj["nodes"], opts);
 	}
@@ -372,7 +372,7 @@ namespace mesh_resource_internal
 	{
 		Mesh mesh(default_allocator());
 		s32 err = mesh::parse(mesh, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		return mesh::write(mesh, opts);
 	}
 

src/resource/package_resource.cpp

@@ -99,7 +99,7 @@ namespace package_resource_internal
 			TempAllocator256 ta;
 			DynamicString name(ta);
 			RETURN_IF_ERROR(sjson::parse_string(name, names[i]), opts);
-			DATA_COMPILER_ASSERT_RESOURCE_EXISTS(type, name.c_str(), opts);
+			RETURN_IF_RESOURCE_MISSING(type, name.c_str(), opts);
 			name += ".";
 			name += type;
 			opts.fake_read(name.c_str());
@@ -182,29 +182,29 @@ namespace package_resource_internal
 
 		s32 err = 0;
 		err = compile_resources(resources_set, "texture", texture, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "lua", script, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "sound", sound, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "mesh", mesh, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "unit", unit, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "sprite", sprite, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "material", material, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "font", font, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "level", level, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "physics_config", phyconf, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "shader", shader, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		err = compile_resources(resources_set, "sprite_animation", sprite_animation, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		// Generate resource list
 		auto cur = hash_set::begin(resources_set);
@@ -224,7 +224,7 @@ namespace package_resource_internal
 					resources[j].online_order = online_order++;
 			}
 		}
-		DATA_COMPILER_ENSURE(online_order == array::size(resources), opts);
+		ENSURE_OR_RETURN(online_order == array::size(resources), opts);
 
 		// Write
 		opts.write(RESOURCE_HEADER(RESOURCE_VERSION_PACKAGE));

src/resource/physics_resource.cpp

@@ -166,7 +166,7 @@ namespace physics_resource_internal
 		RETURN_IF_ERROR(sjson::parse_string(type, obj["shape"]), opts);
 
 		ColliderType::Enum st = shape_type_to_enum(type.c_str());
-		DATA_COMPILER_ASSERT(st != ColliderType::COUNT
+		RETURN_IF_FALSE(st != ColliderType::COUNT
 			, opts
 			, "Unknown shape type: '%s'"
 			, type.c_str()
@@ -197,11 +197,11 @@ namespace physics_resource_internal
 			// Parse mesh resource.
 			Mesh mesh(default_allocator());
 			s32 err = mesh::parse(mesh, opts, scene.c_str());
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 
 			Node deffault_node(default_allocator());
 			Node &node = hash_map::get(mesh._nodes, name, deffault_node);
-			DATA_COMPILER_ASSERT(&node != &deffault_node
+			RETURN_IF_FALSE(&node != &deffault_node
 				, opts
 				, "Node '%s' does not exist"
 				, name.c_str()
@@ -209,7 +209,7 @@ namespace physics_resource_internal
 
 			Geometry deffault_geometry(default_allocator());
 			Geometry &geometry = hash_map::get(mesh._geometries, node._geometry, deffault_geometry);
-			DATA_COMPILER_ASSERT(&geometry != &deffault_geometry
+			RETURN_IF_FALSE(&geometry != &deffault_geometry
 				, opts
 				, "Geometry '%s' does not exist"
 				, node._geometry.c_str()
@@ -232,16 +232,16 @@ namespace physics_resource_internal
 			case ColliderType::CONVEX_HULL: break;
 			case ColliderType::MESH:        break;
 			case ColliderType::HEIGHTFIELD:
-				DATA_COMPILER_ASSERT(false, opts, "Not implemented yet");
+				RETURN_IF_FALSE(false, opts, "Not implemented yet");
 				break;
 			default:
-				DATA_COMPILER_ASSERT(false, opts, "Invalid collider type");
+				RETURN_IF_FALSE(false, opts, "Invalid collider type");
 				break;
 			}
 		} else {
 			JsonObject collider_data(ta);
 			JsonArray org(ta);
-			DATA_COMPILER_ASSERT(json_object::has(obj, "collider_data")
+			RETURN_IF_FALSE(json_object::has(obj, "collider_data")
 				, opts
 				, "No collider_data found"
 				);
@@ -259,7 +259,7 @@ namespace physics_resource_internal
 				cd.capsule.radius = RETURN_IF_ERROR(sjson::parse_float(collider_data["radius"]), opts);
 				cd.capsule.height = RETURN_IF_ERROR(sjson::parse_float(collider_data["height"]), opts);
 			} else {
-				DATA_COMPILER_ASSERT(false, opts, "Invalid collider type");
+				RETURN_IF_FALSE(false, opts, "Invalid collider type");
 			}
 		}
 
@@ -359,7 +359,7 @@ namespace physics_resource_internal
 		RETURN_IF_ERROR(sjson::parse_string(type, obj["type"]), opts);
 
 		JointType::Enum jt = joint_type_to_enum(type.c_str());
-		DATA_COMPILER_ASSERT(jt != JointType::COUNT
+		RETURN_IF_FALSE(jt != JointType::COUNT
 			, opts
 			, "Unknown joint type: '%s'"
 			, type.c_str()
@@ -557,7 +557,7 @@ namespace physics_config_resource_internal
 
 		u32 new_filter_mask()
 		{
-			DATA_COMPILER_ASSERT(_filter != 0x80000000u
+			RETURN_IF_FALSE(_filter != 0x80000000u
 				, _opts
 				, "Too many collision filters"
 				);
@@ -569,7 +569,7 @@ namespace physics_config_resource_internal
 
 		u32 filter_to_mask(StringId32 filter)
 		{
-			DATA_COMPILER_ASSERT(hash_map::has(_filter_map, filter)
+			RETURN_IF_FALSE(hash_map::has(_filter_map, filter)
 				, _opts
 				, "Filter not found"
 				);
@@ -593,15 +593,15 @@ namespace physics_config_resource_internal
 		s32 err = 0;
 		if (json_object::has(obj, "collision_filters")) {
 			err = cfc.parse(obj["collision_filters"]);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 		if (json_object::has(obj, "materials")) {
 			err = parse_materials(obj["materials"], materials, opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 		if (json_object::has(obj, "actors")) {
 			err = parse_actors(obj["actors"], actors, opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 
 		// Setup struct for writing

src/resource/shader_resource.cpp

@@ -837,27 +837,27 @@ namespace shader_resource_internal
 
 			if (json_object::has(obj, "render_states")) {
 				s32 err = parse_render_states(obj["render_states"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			if (json_object::has(obj, "sampler_states")) {
 				s32 err = parse_sampler_states(obj["sampler_states"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			if (json_object::has(obj, "bgfx_shaders")) {
 				s32 err = parse_bgfx_shaders(obj["bgfx_shaders"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			if (json_object::has(obj, "shaders")) {
 				s32 err = parse_shaders(obj["shaders"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			if (json_object::has(obj, "static_compile")) {
 				s32 err = parse_static_compile(obj["static_compile"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			return 0;
@@ -911,7 +911,7 @@ namespace shader_resource_internal
 				DynamicString depth_func(ta);
 				RETURN_IF_ERROR(sjson::parse_string(depth_func, obj["depth_func"]), _opts);
 				state._depth_func.set_value(name_to_depth_func(depth_func.c_str()));
-				DATA_COMPILER_ASSERT(state._depth_func.value() != DepthFunction::COUNT
+				RETURN_IF_FALSE(state._depth_func.value() != DepthFunction::COUNT
 					, _opts
 					, "Unknown depth test: '%s'"
 					, depth_func.c_str()
@@ -923,7 +923,7 @@ namespace shader_resource_internal
 				DynamicString blend_src(ta);
 				RETURN_IF_ERROR(sjson::parse_string(blend_src, obj["blend_src"]), _opts);
 				state._blend_src.set_value(name_to_blend_function(blend_src.c_str()));
-				DATA_COMPILER_ASSERT(state._blend_src.value() != BlendFunction::COUNT
+				RETURN_IF_FALSE(state._blend_src.value() != BlendFunction::COUNT
 					, _opts
 					, "Unknown blend function: '%s'"
 					, blend_src.c_str()
@@ -935,7 +935,7 @@ namespace shader_resource_internal
 				DynamicString blend_dst(ta);
 				RETURN_IF_ERROR(sjson::parse_string(blend_dst, obj["blend_dst"]), _opts);
 				state._blend_dst.set_value(name_to_blend_function(blend_dst.c_str()));
-				DATA_COMPILER_ASSERT(state._blend_dst.value() != BlendFunction::COUNT
+				RETURN_IF_FALSE(state._blend_dst.value() != BlendFunction::COUNT
 					, _opts
 					, "Unknown blend function: '%s'"
 					, blend_dst.c_str()
@@ -947,7 +947,7 @@ namespace shader_resource_internal
 				DynamicString blend_equation(ta);
 				RETURN_IF_ERROR(sjson::parse_string(blend_equation, obj["blend_equation"]), _opts);
 				state._blend_equation.set_value(name_to_blend_equation(blend_equation.c_str()));
-				DATA_COMPILER_ASSERT(state._blend_equation.value() != BlendEquation::COUNT
+				RETURN_IF_FALSE(state._blend_equation.value() != BlendEquation::COUNT
 					, _opts
 					, "Unknown blend equation: '%s'"
 					, blend_equation.c_str()
@@ -959,7 +959,7 @@ namespace shader_resource_internal
 				DynamicString cull_mode(ta);
 				RETURN_IF_ERROR(sjson::parse_string(cull_mode, obj["cull_mode"]), _opts);
 				state._cull_mode.set_value(name_to_cull_mode(cull_mode.c_str()));
-				DATA_COMPILER_ASSERT(state._cull_mode.value() != CullMode::COUNT
+				RETURN_IF_FALSE(state._cull_mode.value() != CullMode::COUNT
 					, _opts
 					, "Unknown cull mode: '%s'"
 					, cull_mode.c_str()
@@ -971,7 +971,7 @@ namespace shader_resource_internal
 				DynamicString primitive_type(ta);
 				RETURN_IF_ERROR(sjson::parse_string(primitive_type, obj["primitive_type"]), _opts);
 				state._primitive_type.set_value(name_to_primitive_type(primitive_type.c_str()));
-				DATA_COMPILER_ASSERT(state._primitive_type.value() != PrimitiveType::COUNT
+				RETURN_IF_FALSE(state._primitive_type.value() != PrimitiveType::COUNT
 					, _opts
 					, "Unknown primitive type: '%s'"
 					, primitive_type.c_str()
@@ -1023,7 +1023,7 @@ namespace shader_resource_internal
 					DynamicString depth_func(ta);
 					RETURN_IF_ERROR(sjson::parse_string(depth_func, states["depth_func"]), _opts);
 					state._depth_func.set_value(name_to_depth_func(depth_func.c_str()));
-					DATA_COMPILER_ASSERT(state._depth_func.value() != DepthFunction::COUNT
+					RETURN_IF_FALSE(state._depth_func.value() != DepthFunction::COUNT
 						, _opts
 						, "Unknown depth test: '%s'"
 						, depth_func.c_str()
@@ -1032,7 +1032,7 @@ namespace shader_resource_internal
 					DynamicString blend_src(ta);
 					RETURN_IF_ERROR(sjson::parse_string(blend_src, states["blend_src"]), _opts);
 					state._blend_src.set_value(name_to_blend_function(blend_src.c_str()));
-					DATA_COMPILER_ASSERT(state._blend_src.value() != BlendFunction::COUNT
+					RETURN_IF_FALSE(state._blend_src.value() != BlendFunction::COUNT
 						, _opts
 						, "Unknown blend function: '%s'"
 						, blend_src.c_str()
@@ -1041,7 +1041,7 @@ namespace shader_resource_internal
 					DynamicString blend_dst(ta);
 					RETURN_IF_ERROR(sjson::parse_string(blend_dst, states["blend_dst"]), _opts);
 					state._blend_dst.set_value(name_to_blend_function(blend_dst.c_str()));
-					DATA_COMPILER_ASSERT(state._blend_dst.value() != BlendFunction::COUNT
+					RETURN_IF_FALSE(state._blend_dst.value() != BlendFunction::COUNT
 						, _opts
 						, "Unknown blend function: '%s'"
 						, blend_dst.c_str()
@@ -1050,7 +1050,7 @@ namespace shader_resource_internal
 					DynamicString blend_equation(ta);
 					RETURN_IF_ERROR(sjson::parse_string(blend_equation, states["blend_equation"]), _opts);
 					state._blend_equation.set_value(name_to_blend_equation(blend_equation.c_str()));
-					DATA_COMPILER_ASSERT(state._blend_equation.value() != BlendEquation::COUNT
+					RETURN_IF_FALSE(state._blend_equation.value() != BlendEquation::COUNT
 						, _opts
 						, "Unknown blend equation: '%s'"
 						, blend_equation.c_str()
@@ -1059,7 +1059,7 @@ namespace shader_resource_internal
 					DynamicString cull_mode(ta);
 					RETURN_IF_ERROR(sjson::parse_string(cull_mode, states["cull_mode"]), _opts);
 					state._cull_mode.set_value(name_to_cull_mode(cull_mode.c_str()));
-					DATA_COMPILER_ASSERT(state._cull_mode.value() != CullMode::COUNT
+					RETURN_IF_FALSE(state._cull_mode.value() != CullMode::COUNT
 						, _opts
 						, "Unknown cull mode: '%s'"
 						, cull_mode.c_str()
@@ -1068,7 +1068,7 @@ namespace shader_resource_internal
 					DynamicString primitive_type(ta);
 					RETURN_IF_ERROR(sjson::parse_string(primitive_type, states["primitive_type"]), _opts);
 					state._primitive_type.set_value(name_to_primitive_type(primitive_type.c_str()));
-					DATA_COMPILER_ASSERT(state._primitive_type.value() != PrimitiveType::COUNT
+					RETURN_IF_FALSE(state._primitive_type.value() != PrimitiveType::COUNT
 						, _opts
 						, "Unknown primitive type: '%s'"
 						, primitive_type.c_str()
@@ -1076,7 +1076,7 @@ namespace shader_resource_internal
 				} else {
 					// Skip conditionals state objects, error out on anything else.
 					if (sjson::type(cur->second) != JsonValueType::OBJECT) {
-						DATA_COMPILER_ASSERT(false
+						RETURN_IF_FALSE(false
 							, _opts
 							, "Unknown state property: '%.*s'"
 							, cur->first.length()
@@ -1116,7 +1116,7 @@ namespace shader_resource_internal
 					// It must be a conditional expression: "expr()" = { ... }
 					RenderState::State states;
 					s32 err = parse_states(states, cur->second);
-					DATA_COMPILER_ENSURE(err == 0, _opts);
+					ENSURE_OR_RETURN(err == 0, _opts);
 
 					DynamicString expr(default_allocator());
 					expr = cur->first;
@@ -1153,14 +1153,14 @@ namespace shader_resource_internal
 			// Read states from render state object itself; for backwards compatibility.
 			RenderState::State states_compat;
 			err = parse_states_compat(states_compat, obj);
-			DATA_COMPILER_ENSURE(err == 0, _opts);
+			ENSURE_OR_RETURN(err == 0, _opts);
 			rs.push_back_states("1", states_compat, 0u); // Always applied.
 
 			// Read states from new, dedicated "states" object.
 			if (json_object::has(obj, "states")) {
 				RenderState::State states;
 				err = parse_states(states, obj["states"]);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 				rs.push_back_states("1", states, 1u); // Always applied.
 
 				err = parse_conditional_states(rs, obj["states"]);
@@ -1185,12 +1185,12 @@ namespace shader_resource_internal
 
 				RenderState rs(default_allocator());
 				s32 err = parse_render_state(rs, cur->second);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 
 				DynamicString key(ta);
 				key = cur->first;
 
-				DATA_COMPILER_ASSERT(!hash_map::has(_render_states, key)
+				RETURN_IF_FALSE(!hash_map::has(_render_states, key)
 					, _opts
 					, "Render state redefined: '%s'"
 					, key.c_str()
@@ -1233,7 +1233,7 @@ namespace shader_resource_internal
 				if (has_filter_min) {
 					RETURN_IF_ERROR(sjson::parse_string(filter_min, obj["filter_min"]), _opts);
 					ss._filter_min = name_to_sampler_filter(filter_min.c_str());
-					DATA_COMPILER_ASSERT(ss._filter_min != SamplerFilter::COUNT
+					RETURN_IF_FALSE(ss._filter_min != SamplerFilter::COUNT
 						, _opts
 						, "Unknown sampler filter: '%s'"
 						, filter_min.c_str()
@@ -1243,7 +1243,7 @@ namespace shader_resource_internal
 				if (has_filter_mag) {
 					RETURN_IF_ERROR(sjson::parse_string(filter_mag, obj["filter_mag"]), _opts);
 					ss._filter_mag = name_to_sampler_filter(filter_mag.c_str());
-					DATA_COMPILER_ASSERT(ss._filter_mag != SamplerFilter::COUNT
+					RETURN_IF_FALSE(ss._filter_mag != SamplerFilter::COUNT
 						, _opts
 						, "Unknown sampler filter: '%s'"
 						, filter_mag.c_str()
@@ -1253,7 +1253,7 @@ namespace shader_resource_internal
 				if (has_wrap_u) {
 					RETURN_IF_ERROR(sjson::parse_string(wrap_u, obj["wrap_u"]), _opts);
 					ss._wrap_u = name_to_sampler_wrap(wrap_u.c_str());
-					DATA_COMPILER_ASSERT(ss._wrap_u != SamplerWrap::COUNT
+					RETURN_IF_FALSE(ss._wrap_u != SamplerWrap::COUNT
 						, _opts
 						, "Unknown wrap mode: '%s'"
 						, wrap_u.c_str()
@@ -1263,7 +1263,7 @@ namespace shader_resource_internal
 				if (has_wrap_v) {
 					RETURN_IF_ERROR(sjson::parse_string(wrap_v, obj["wrap_v"]), _opts);
 					ss._wrap_v = name_to_sampler_wrap(wrap_v.c_str());
-					DATA_COMPILER_ASSERT(ss._wrap_v != SamplerWrap::COUNT
+					RETURN_IF_FALSE(ss._wrap_v != SamplerWrap::COUNT
 						, _opts
 						, "Unknown wrap mode: '%s'"
 						, wrap_v.c_str()
@@ -1273,7 +1273,7 @@ namespace shader_resource_internal
 				if (has_wrap_w) {
 					RETURN_IF_ERROR(sjson::parse_string(wrap_w, obj["wrap_w"]), _opts);
 					ss._wrap_w = name_to_sampler_wrap(wrap_w.c_str());
-					DATA_COMPILER_ASSERT(ss._wrap_w != SamplerWrap::COUNT
+					RETURN_IF_FALSE(ss._wrap_w != SamplerWrap::COUNT
 						, _opts
 						, "Unknown wrap mode: '%s'"
 						, wrap_w.c_str()
@@ -1283,7 +1283,7 @@ namespace shader_resource_internal
 				DynamicString key(ta);
 				key = cur->first;
 
-				DATA_COMPILER_ASSERT(!hash_map::has(_sampler_states, key)
+				RETURN_IF_FALSE(!hash_map::has(_sampler_states, key)
 					, _opts
 					, "Sampler state redefined: '%s'"
 					, key.c_str()
@@ -1332,13 +1332,13 @@ namespace shader_resource_internal
 				}
 				if (json_object::has(shader, "samplers")) {
 					s32 err = parse_bgfx_samplers(bgfxshader, shader["samplers"]);
-					DATA_COMPILER_ENSURE(err == 0, _opts);
+					ENSURE_OR_RETURN(err == 0, _opts);
 				}
 
 				DynamicString key(ta);
 				key = cur->first;
 
-				DATA_COMPILER_ASSERT(!hash_map::has(_bgfx_shaders, key)
+				RETURN_IF_FALSE(!hash_map::has(_bgfx_shaders, key)
 					, _opts
 					, "Bgfx shader redefined: '%s'"
 					, key.c_str()
@@ -1366,7 +1366,7 @@ namespace shader_resource_internal
 				DynamicString sampler_state(ta);
 				RETURN_IF_ERROR(sjson::parse_string(sampler_state, sampler["sampler_state"]), _opts);
 
-				DATA_COMPILER_ASSERT(hash_map::has(_sampler_states, sampler_state)
+				RETURN_IF_FALSE(hash_map::has(_sampler_states, sampler_state)
 					, _opts
 					, "Unknown sampler state: '%s'"
 					, sampler_state.c_str()
@@ -1375,7 +1375,7 @@ namespace shader_resource_internal
 				DynamicString key(ta);
 				key = cur->first;
 
-				DATA_COMPILER_ASSERT(!hash_map::has(bgfxshader._samplers, key)
+				RETURN_IF_FALSE(!hash_map::has(bgfxshader._samplers, key)
 					, _opts
 					, "Bgfx sampler redefined: '%s'"
 					, key.c_str()
@@ -1407,7 +1407,7 @@ namespace shader_resource_internal
 				DynamicString key(ta);
 				key = cur->first;
 
-				DATA_COMPILER_ASSERT(!hash_map::has(_shaders, key)
+				RETURN_IF_FALSE(!hash_map::has(_shaders, key)
 					, _opts
 					, "Shader redefined: '%s'"
 					, key.c_str()
@@ -1473,7 +1473,7 @@ namespace shader_resource_internal
 				}
 				const StringId32 shader_name(str.c_str());
 
-				DATA_COMPILER_ASSERT(hash_map::has(_shaders, sc._shader)
+				RETURN_IF_FALSE(hash_map::has(_shaders, sc._shader)
 					, _opts
 					, "Unknown shader: '%s'"
 					, shader.c_str()
@@ -1483,12 +1483,12 @@ namespace shader_resource_internal
 				const DynamicString &bgfx_shader  = sp._bgfx_shader;
 				const DynamicString &render_state = sp._render_state;
 
-				DATA_COMPILER_ASSERT(hash_map::has(_bgfx_shaders, sp._bgfx_shader)
+				RETURN_IF_FALSE(hash_map::has(_bgfx_shaders, sp._bgfx_shader)
 					, _opts
 					, "Unknown bgfx shader: '%s'"
 					, bgfx_shader.c_str()
 					);
-				DATA_COMPILER_ASSERT(hash_map::has(_render_states, sp._render_state)
+				RETURN_IF_FALSE(hash_map::has(_render_states, sp._render_state)
 					, _opts
 					, "Unknown render state: '%s'"
 					, render_state.c_str()
@@ -1497,13 +1497,13 @@ namespace shader_resource_internal
 				s32 err = 0;
 				RenderState::State state;
 				err = compile_render_state(state, render_state.c_str(), defines);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 
 				_opts.write(shader_name._id);                            // Shader name
 				_opts.write(state.encode());                             // Render state
 				compile_sampler_states(bgfx_shader.c_str());             // Sampler states
 				err = compile_bgfx_shader(bgfx_shader.c_str(), defines); // Shader code
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			return 0;
@@ -1571,7 +1571,7 @@ namespace shader_resource_internal
 			_opts.write_temporary(_varying_path.c_str(), shader._varying.c_str(), shader._varying.length());
 
 			const char *shaderc = _opts.exe_path(shaderc_paths, countof(shaderc_paths));
-			DATA_COMPILER_ASSERT(shaderc != NULL, _opts, "shaderc not found");
+			RETURN_IF_FALSE(shaderc != NULL, _opts, "shaderc not found");
 
 			// Invoke shaderc
 			Process pr_vert;
@@ -1588,7 +1588,7 @@ namespace shader_resource_internal
 				);
 			if (sc != 0) {
 				delete_temp_files();
-				DATA_COMPILER_ASSERT(sc == 0
+				RETURN_IF_FALSE(sc == 0
 					, _opts
 					, "Failed to spawn `%s`"
 					, shaderc
@@ -1605,7 +1605,7 @@ namespace shader_resource_internal
 				);
 			if (sc != 0) {
 				delete_temp_files();
-				DATA_COMPILER_ASSERT(sc == 0
+				RETURN_IF_FALSE(sc == 0
 					, _opts
 					, "Failed to spawn `%s`"
 					, shaderc
@@ -1623,7 +1623,7 @@ namespace shader_resource_internal
 			if (ec != 0) {
 				pr_frag.wait();
 				delete_temp_files();
-				DATA_COMPILER_ASSERT(false
+				RETURN_IF_FALSE(false
 					, _opts
 					, "Failed to compile vertex shader `%s`:\n%s"
 					, bgfx_shader
@@ -1635,7 +1635,7 @@ namespace shader_resource_internal
 			ec = pr_frag.wait();
 			if (ec != 0) {
 				delete_temp_files();
-				DATA_COMPILER_ASSERT(false
+				RETURN_IF_FALSE(false
 					, _opts
 					, "Failed to compile fragment shader `%s`:\n%s"
 					, bgfx_shader
@@ -1701,10 +1701,10 @@ namespace shader_resource_internal
 				, byte_code
 				, countof(byte_code)
 				);
-			DATA_COMPILER_ENSURE(num <= countof(byte_code), opts);
+			ENSURE_OR_RETURN(num <= countof(byte_code), opts);
 
 			bool ok = expression_language::run(byte_code, variables, stack);
-			DATA_COMPILER_ASSERT(ok && stack.size > 0
+			RETURN_IF_FALSE(ok && stack.size > 0
 				, opts
 				, "Failed to evaluate expression: '%s'"
 				, expr
@@ -1722,14 +1722,14 @@ namespace shader_resource_internal
 
 			// Compile inherited state if any.
 			if (!(rs._inherit == "")) {
-				DATA_COMPILER_ASSERT(hash_map::has(_render_states, rs._inherit)
+				RETURN_IF_FALSE(hash_map::has(_render_states, rs._inherit)
 					, _opts
 					, "Unknown inherit render state: '%s'"
 					, rs._inherit.c_str()
 					);
 
 				s32 err = compile_render_state(state, rs._inherit.c_str(), defines);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 			}
 
 			// Evaluate expressions and apply states.
@@ -1772,7 +1772,7 @@ namespace shader_resource_internal
 	{
 		ShaderCompiler sc(opts);
 		s32 err = sc.parse(opts.source_path());
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		return sc.compile();
 	}

src/resource/sprite_resource.cpp

@@ -92,7 +92,7 @@ namespace sprite_resource_internal
 		// Parse frames.
 		Array<SpriteFrame> sprite_frames(default_allocator());
 		s32 err = parse_frames(sprite_frames, frames, opts);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		// Fill verices.
 		Array<f32> vertices(default_allocator());

src/resource/state_machine_resource.cpp

@@ -246,7 +246,7 @@ namespace state_machine_internal
 
 				DynamicString animation_resource(ta);
 				RETURN_IF_ERROR(sjson::parse_string(animation_resource, animation["name"]), _opts);
-				DATA_COMPILER_ASSERT_RESOURCE_EXISTS("sprite_animation"
+				RETURN_IF_RESOURCE_MISSING("sprite_animation"
 					, animation_resource.c_str()
 					, _opts
 					);
@@ -272,7 +272,7 @@ namespace state_machine_internal
 				DynamicString mode_str(ta);
 				RETURN_IF_ERROR(sjson::parse_string(mode_str, transition["mode"]), _opts);
 				const u32 mode = name_to_transition_mode(mode_str.c_str());
-				DATA_COMPILER_ASSERT(mode != TransitionMode::COUNT
+				RETURN_IF_FALSE(mode != TransitionMode::COUNT
 					, _opts
 					, "Unknown transition mode: '%s'"
 					, mode_str.c_str()
@@ -307,9 +307,9 @@ namespace state_machine_internal
 
 				s32 err = 0;
 				err = parse_transitions(si, transitions);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 				err = parse_animations(si, animations);
-				DATA_COMPILER_ENSURE(err == 0, _opts);
+				ENSURE_OR_RETURN(err == 0, _opts);
 
 				Guid guid;
 				if (json_object::has(state, "id")) {
@@ -318,7 +318,7 @@ namespace state_machine_internal
 					guid = RETURN_IF_ERROR(sjson::parse_guid(state["_guid"]), _opts);
 				}
 
-				DATA_COMPILER_ASSERT(!hash_map::has(_states, guid)
+				RETURN_IF_FALSE(!hash_map::has(_states, guid)
 					, _opts
 					, "State GUID duplicated"
 					);
@@ -429,23 +429,23 @@ namespace state_machine_internal
 
 			s32 err = 0;
 			err = parse_states(states);
-			DATA_COMPILER_ENSURE(err == 0, _opts);
-			DATA_COMPILER_ASSERT(hash_map::size(_states) > 0
+			ENSURE_OR_RETURN(err == 0, _opts);
+			RETURN_IF_FALSE(hash_map::size(_states) > 0
 				, _opts
 				, "States cannot be empty"
 				);
 
 			_initial_state = RETURN_IF_ERROR(sjson::parse_guid(obj["initial_state"]), _opts);
-			DATA_COMPILER_ASSERT(hash_map::has(_states, _initial_state)
+			RETURN_IF_FALSE(hash_map::has(_states, _initial_state)
 				, _opts
 				, "Initial state references non-existing state"
 				);
 
 			err = parse_variables(variables);
-			DATA_COMPILER_ENSURE(err == 0, _opts);
+			ENSURE_OR_RETURN(err == 0, _opts);
 
 			err = compute_state_offsets();
-			DATA_COMPILER_ENSURE(err == 0, _opts);
+			ENSURE_OR_RETURN(err == 0, _opts);
 
 			return 0;
 		}
@@ -532,7 +532,7 @@ namespace state_machine_internal
 		StateMachineCompiler smc(opts);
 		s32 err = 0;
 		err = smc.parse(buf);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 
 		return smc.write();
 	}

src/resource/texture_resource.cpp

@@ -153,7 +153,7 @@ namespace texture_resource_internal
 			if (json_object::has(obj, "format")) {
 				RETURN_IF_ERROR(sjson::parse_string(format, obj["format"]), opts);
 				os.format = texture_format_to_enum(format.c_str());
-				DATA_COMPILER_ASSERT(os.format != TextureFormat::COUNT
+				RETURN_IF_FALSE(os.format != TextureFormat::COUNT
 					, opts
 					, "Unknown texture format: '%s'"
 					, format.c_str()
@@ -183,7 +183,7 @@ namespace texture_resource_internal
 
 		DynamicString name(ta);
 		RETURN_IF_ERROR(sjson::parse_string(name, obj["source"]), opts);
-		DATA_COMPILER_ASSERT_FILE_EXISTS(name.c_str(), opts);
+		RETURN_IF_FILE_MISSING(name.c_str(), opts);
 		opts.fake_read(name.c_str());
 
 		OutputSettings os;
@@ -199,7 +199,7 @@ namespace texture_resource_internal
 		if (json_object::has(obj, "output")) {
 			RETURN_IF_ERROR(sjson::parse_object(output, obj["output"]), opts);
 			s32 err = parse_output(os, output, opts);
-			DATA_COMPILER_ENSURE(err == 0, opts);
+			ENSURE_OR_RETURN(err == 0, opts);
 		}
 
 		DynamicString tex_src(ta);
@@ -208,7 +208,7 @@ namespace texture_resource_internal
 		opts.temporary_path(tex_out, "ktx");
 
 		const char *texturec = opts.exe_path(texturec_paths, countof(texturec_paths));
-		DATA_COMPILER_ASSERT(texturec != NULL
+		RETURN_IF_FALSE(texturec != NULL
 			, opts
 			, "texturec not found"
 			);
@@ -233,7 +233,7 @@ namespace texture_resource_internal
 		};
 		Process pr;
 		s32 sc = pr.spawn(argv, CROWN_PROCESS_STDOUT_PIPE | CROWN_PROCESS_STDERR_MERGE);
-		DATA_COMPILER_ASSERT(sc == 0
+		RETURN_IF_FALSE(sc == 0
 			, opts
 			, "Failed to spawn `%s`"
 			, argv[0]
@@ -241,7 +241,7 @@ namespace texture_resource_internal
 		StringStream texturec_output(ta);
 		opts.read_output(texturec_output, pr);
 		s32 ec = pr.wait();
-		DATA_COMPILER_ASSERT(ec == 0
+		RETURN_IF_FALSE(ec == 0
 			, opts
 			, "Failed to compile texture:\n%s"
 			, string_stream::c_str(texturec_output)

src/resource/unit_compiler.cpp

@@ -102,7 +102,7 @@ static s32 compile_camera(Buffer &output, const char *json, CompileOptions &opts
 	RETURN_IF_ERROR(sjson::parse_string(type, obj["projection"]), opts);
 
 	ProjectionType::Enum pt = projection_name_to_enum(type.c_str());
-	DATA_COMPILER_ASSERT(pt != ProjectionType::COUNT
+	RETURN_IF_FALSE(pt != ProjectionType::COUNT
 		, opts
 		, "Unknown projection type: '%s'"
 		, type.c_str()
@@ -132,7 +132,7 @@ static s32 compile_mesh_renderer(Buffer &output, const char *json, CompileOption
 	DynamicString mesh_resource(ta);
 	RETURN_IF_ERROR(sjson::parse_string(mesh_resource, obj["mesh_resource"]), opts);
 
-	DATA_COMPILER_ENSURE(opts.resource_exists("mesh", mesh_resource.c_str())
+	ENSURE_OR_RETURN(opts.resource_exists("mesh", mesh_resource.c_str())
 		|| opts.file_exists(mesh_resource.c_str())
 		, opts
 		);
@@ -146,7 +146,7 @@ static s32 compile_mesh_renderer(Buffer &output, const char *json, CompileOption
 
 	DynamicString material(ta);
 	RETURN_IF_ERROR(sjson::parse_string(material, obj["material"]), opts);
-	DATA_COMPILER_ASSERT_RESOURCE_EXISTS("material"
+	RETURN_IF_RESOURCE_MISSING("material"
 		, material.c_str()
 		, opts
 		);
@@ -181,7 +181,7 @@ static s32 compile_sprite_renderer(Buffer &output, const char *json, CompileOpti
 
 	DynamicString sprite_resource(ta);
 	RETURN_IF_ERROR(sjson::parse_string(sprite_resource, obj["sprite_resource"]), opts);
-	DATA_COMPILER_ASSERT_RESOURCE_EXISTS("sprite"
+	RETURN_IF_RESOURCE_MISSING("sprite"
 		, sprite_resource.c_str()
 		, opts
 		);
@@ -189,7 +189,7 @@ static s32 compile_sprite_renderer(Buffer &output, const char *json, CompileOpti
 
 	DynamicString material(ta);
 	RETURN_IF_ERROR(sjson::parse_string(material, obj["material"]), opts);
-	DATA_COMPILER_ASSERT_RESOURCE_EXISTS("material"
+	RETURN_IF_RESOURCE_MISSING("material"
 		, material.c_str()
 		, opts
 		);
@@ -236,7 +236,7 @@ static s32 compile_light(Buffer &output, const char *json, CompileOptions &opts)
 	RETURN_IF_ERROR(sjson::parse_string(type, obj["type"]), opts);
 
 	LightType::Enum lt = light_name_to_enum(type.c_str());
-	DATA_COMPILER_ASSERT(lt != LightType::COUNT
+	RETURN_IF_FALSE(lt != LightType::COUNT
 		, opts
 		, "Unknown light type: '%s'"
 		, type.c_str()
@@ -267,7 +267,7 @@ static s32 compile_script(Buffer &output, const char *json, CompileOptions &opts
 
 	DynamicString script_resource(ta);
 	RETURN_IF_ERROR(sjson::parse_string(script_resource, obj["script_resource"]), opts);
-	DATA_COMPILER_ASSERT_RESOURCE_EXISTS("lua"
+	RETURN_IF_RESOURCE_MISSING("lua"
 		, script_resource.c_str()
 		, opts
 		);
@@ -290,7 +290,7 @@ static s32 compile_animation_state_machine(Buffer &output, const char *json, Com
 
 	DynamicString state_machine_resource(ta);
 	RETURN_IF_ERROR(sjson::parse_string(state_machine_resource, obj["state_machine_resource"]), opts);
-	DATA_COMPILER_ASSERT_RESOURCE_EXISTS("state_machine"
+	RETURN_IF_RESOURCE_MISSING("state_machine"
 		, state_machine_resource.c_str()
 		, opts
 		);
@@ -343,7 +343,7 @@ namespace unit_compiler
 
 			for (u32 i = 0; i < array::size(children); ++i) {
 				s32 err = collect_prefabs(c, unit_name, children[i], false);
-				DATA_COMPILER_ENSURE(err == 0, c._opts);
+				ENSURE_OR_RETURN(err == 0, c._opts);
 			}
 		}
 
@@ -351,7 +351,7 @@ namespace unit_compiler
 			TempAllocator512 ta;
 			DynamicString path(ta);
 			RETURN_IF_ERROR(sjson::parse_string(path, prefab["prefab"]), c._opts);
-			DATA_COMPILER_ASSERT_RESOURCE_EXISTS("unit"
+			RETURN_IF_RESOURCE_MISSING("unit"
 				, path.c_str()
 				, c._opts
 				);
@@ -360,7 +360,7 @@ namespace unit_compiler
 
 			Buffer buf = read_unit(c, path.c_str());
 			s32 err = collect_prefabs(c, name, array::begin(buf), true);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 		}
 
 		if (append_data) {
@@ -486,7 +486,7 @@ namespace unit_compiler
 					array::pop_back(unit->_merged_components_data);
 				} else {
 					char buf[GUID_BUF_LEN];
-					DATA_COMPILER_ASSERT(false
+					RETURN_IF_FALSE(false
 						, c._opts
 						, "Deletion of unexisting component ID: %s"
 						, guid::to_string(buf, sizeof(buf), component_id)
@@ -523,7 +523,7 @@ namespace unit_compiler
 					unit->_merged_components_data[comp_idx] = modified_component["data"];
 				} else {
 					char buf[GUID_BUF_LEN];
-					DATA_COMPILER_ASSERT(false
+					RETURN_IF_FALSE(false
 						, c._opts
 						, "Modification of unexisting component ID: %s"
 						, guid::to_string(buf, sizeof(buf), component_id)
@@ -566,7 +566,7 @@ namespace unit_compiler
 			DynamicString prefab(ta);
 			RETURN_IF_ERROR(sjson::parse_string(prefab, obj["prefab"]), c._opts);
 			const char *prefab_json_data = prefab_json(c, prefab.c_str());
-			DATA_COMPILER_ASSERT(prefab_json_data != NULL
+			RETURN_IF_FALSE(prefab_json_data != NULL
 				, c._opts
 				, "Unknown prefab: '%s'"
 				, prefab.c_str()
@@ -577,11 +577,11 @@ namespace unit_compiler
 				, unit
 				, NULL
 				);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 		}
 
 		s32 err = modify_unit_components(c, unit, unit_json);
-		DATA_COMPILER_ENSURE(err == 0, c._opts);
+		ENSURE_OR_RETURN(err == 0, c._opts);
 
 		if (json_object::has(obj, "children")) {
 			JsonArray children(ta);
@@ -593,7 +593,7 @@ namespace unit_compiler
 					, NULL
 					, unit
 					);
-				DATA_COMPILER_ENSURE(err == 0, c._opts);
+				ENSURE_OR_RETURN(err == 0, c._opts);
 			}
 		}
 
@@ -610,7 +610,7 @@ namespace unit_compiler
 				Unit *child = find_children(unit, id);
 
 				char buf[GUID_BUF_LEN];
-				DATA_COMPILER_ASSERT(child != NULL
+				RETURN_IF_FALSE(child != NULL
 					, c._opts
 					, "Deletion of unexisting child ID: %s"
 					, guid::to_string(buf, sizeof(buf), id)
@@ -634,14 +634,14 @@ namespace unit_compiler
 				Unit *child = find_children(unit, id);
 
 				char buf[GUID_BUF_LEN];
-				DATA_COMPILER_ASSERT(child != NULL
+				RETURN_IF_FALSE(child != NULL
 					, c._opts
 					, "Modification of unexisting child ID: %s"
 					, guid::to_string(buf, sizeof(buf), id)
 					);
 
 				s32 err = modify_unit_components(c, child, modified_children[ii]);
-				DATA_COMPILER_ENSURE(err == 0, c._opts);
+				ENSURE_OR_RETURN(err == 0, c._opts);
 			}
 		}
 
@@ -661,7 +661,7 @@ namespace unit_compiler
 	s32 parse_unit_from_json(UnitCompiler &c, const char *unit_json)
 	{
 		s32 err = collect_prefabs(c, StringId64(), unit_json, true);
-		DATA_COMPILER_ENSURE(err == 0, c._opts);
+		ENSURE_OR_RETURN(err == 0, c._opts);
 
 		u32 original_unit = c._prefab_offsets[array::size(c._prefab_offsets) - 1];
 		return parse_unit_internal(c, &c._prefab_data[original_unit], NULL, NULL);
@@ -682,14 +682,14 @@ namespace unit_compiler
 
 		for (u32 i = 0; i < array::size(units); ++i) {
 			s32 err = collect_prefabs(c, StringId64(), units[i], true);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 			u32 original_unit = c._prefab_offsets[array::size(c._prefab_offsets) - 1];
 			array::push_back(original_units, original_unit);
 		}
 
 		for (u32 i = 0; i < array::size(units); ++i) {
 			s32 err = parse_unit_internal(c, &c._prefab_data[original_units[i]], NULL, NULL);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 		}
 
 		return 0;
@@ -722,19 +722,19 @@ namespace unit_compiler
 			// Append data to the component data for the given type.
 			ComponentTypeData ctd_deffault(default_allocator());
 			ComponentTypeData &ctd = const_cast<ComponentTypeData &>(hash_map::get(c._component_data, comp_type, ctd_deffault));
-			DATA_COMPILER_ASSERT(&ctd != &ctd_deffault, c._opts, "Unknown component type");
+			RETURN_IF_FALSE(&ctd != &ctd_deffault, c._opts, "Unknown component type");
 
 			// Compile component.
 			Buffer comp_data(default_allocator());
 			s32 err = ctd._compiler(comp_data, unit->_merged_components_data[cc], c._opts);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 
 			// One component per unit max.
 			auto cur = array::begin(ctd._unit_index);
 			auto end = array::end(ctd._unit_index);
 			if (std::find(cur, end, unit_index) != end) {
 				char buf[STRING_ID32_BUF_LEN];
-				DATA_COMPILER_ASSERT(false
+				RETURN_IF_FALSE(false
 					, c._opts
 					, "Unit already has a component of type: %s"
 					, comp_type.to_string(buf, sizeof(buf))
@@ -756,12 +756,12 @@ namespace unit_compiler
 		for (; cur != end; ++cur) {
 			HASH_MAP_SKIP_HOLE(unit->_children, cur);
 
-			DATA_COMPILER_ASSERT(unit_has_transform
+			RETURN_IF_FALSE(unit_has_transform
 				, c._opts
 				, "Units with children must have 'transform' component"
 				);
 			s32 err = flatten_unit(c, cur->second, unit_index);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 		}
 
 		return 0;
@@ -795,7 +795,7 @@ namespace unit_compiler
 			HASH_MAP_SKIP_HOLE(c._units, cur);
 
 			s32 err = flatten_unit(c, cur->second, UINT32_MAX);
-			DATA_COMPILER_ENSURE(err == 0, c._opts);
+			ENSURE_OR_RETURN(err == 0, c._opts);
 		}
 
 		return 0;
@@ -807,7 +807,7 @@ namespace unit_compiler
 		BinaryWriter bw(fb);
 
 		s32 err = flatten(c);
-		DATA_COMPILER_ENSURE(err == 0, c._opts);
+		ENSURE_OR_RETURN(err == 0, c._opts);
 
 		// Count component types.
 		u32 num_component_types = 0;

src/resource/unit_resource.cpp

@@ -20,10 +20,10 @@ namespace unit_resource_internal
 	{
 		UnitCompiler uc(default_allocator(), opts);
 		s32 err = unit_compiler::parse_unit(uc, opts.source_path());
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		Buffer blob(default_allocator());
 		err = unit_compiler::blob(blob, uc);
-		DATA_COMPILER_ENSURE(err == 0, opts);
+		ENSURE_OR_RETURN(err == 0, opts);
 		opts.write(blob);
 		return 0;
 	}