Пример #1
0
DECLARE_TEST( uuid, string )
{
	uuid_t uuid, uuidref;
	char* str;

	uuidref = uuid_generate_random();
	EXPECT_FALSE( uuid_is_null( uuidref ) );

	str = string_from_uuid( uuidref );
	EXPECT_NE( str, 0 );

	uuid = string_to_uuid( str );
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuidref ) );

	string_deallocate( str );

	uuid = string_to_uuid( "" );
	EXPECT_EQ_MSGFORMAT( uuid_is_null( uuid ), true, "empty string did not convert to null uuid: %s", string_from_uuid_static( uuid ) );

	uuid = string_to_uuid( "0" );
	EXPECT_EQ_MSGFORMAT( uuid_is_null( uuid ), true, "\"0\" string did not convert to null uuid: %s", string_from_uuid_static( uuid ) );

	uuid = string_to_uuid( string_from_uuid_static( uuid_null() ) );
	EXPECT_EQ_MSGFORMAT( uuid_is_null( uuid ), true, "null uuid reconvert through string did not convert to null uuid: %s", string_from_uuid_static( uuid ) );

	return 0;
}
Пример #2
0
static int
render_import_program(stream_t* stream, const uuid_t uuid) {
	char buffer[1024];
	char pathbuf[BUILD_MAX_PATHLEN];
	resource_source_t source;
	resource_platform_t platformdecl = {-1, -1, -1, -1, -1, -1};
	uint64_t platform;
	tick_t timestamp;
	int ret = 0;

	resource_source_initialize(&source);
	resource_source_read(&source, uuid);

	platform = resource_platform(platformdecl);
	timestamp = time_system();

	while (!stream_eos(stream)) {
		string_const_t type, ref;
		string_const_t fullpath;
		string_const_t uuidstr;
		uuid_t shaderuuid;
		hash_t typehash;
		string_t line = stream_read_line_buffer(stream, buffer, sizeof(buffer), '\n');
		string_split(STRING_ARGS(line), STRING_CONST(" \t"),
		             &type, &ref, false);

		type = string_strip(STRING_ARGS(type), STRING_CONST(STRING_WHITESPACE));
		ref = string_strip(STRING_ARGS(ref), STRING_CONST(STRING_WHITESPACE));
		if (!type.length || !ref.length)
			continue;

		typehash = hash(STRING_ARGS(type));
		if ((typehash != HASH_VERTEXSHADER) && (typehash != HASH_PIXELSHADER)) {
			log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Ignore invalid line: %.*s"),
			          STRING_FORMAT(line));
			continue;
		}

		shaderuuid = string_to_uuid(STRING_ARGS(ref));
		if (uuid_is_null(shaderuuid)) {
			if (path_is_absolute(STRING_ARGS(ref))) {
				fullpath = ref;
			}
			else {
				string_t full;
				string_const_t path = stream_path(stream);
				path = path_directory_name(STRING_ARGS(path));
				full = path_concat(pathbuf, sizeof(pathbuf),
				                   STRING_ARGS(path), STRING_ARGS(ref));
				full = path_absolute(STRING_ARGS(full), sizeof(pathbuf));
				fullpath = string_const(STRING_ARGS(full));
			}

			resource_signature_t sig = resource_import_lookup(STRING_ARGS(fullpath));
			if (uuid_is_null(sig.uuid)) {
				if (!resource_import(STRING_ARGS(fullpath), uuid_null())) {
					log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Unable to import linked shader: %.*s"),
					          STRING_FORMAT(fullpath));
					ret = -1;
					goto finalize;
				}
				sig = resource_import_lookup(STRING_ARGS(fullpath));
				if (uuid_is_null(sig.uuid)) {
					log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS,
					          STRING_CONST("Import linked shader gave no UUID: %.*s"),
					          STRING_FORMAT(fullpath));
					ret = -1;
					goto finalize;
				}
			}
			shaderuuid = sig.uuid;
		}

		if (!uuid_is_null(shaderuuid)) {
			uuidstr = string_from_uuid_static(shaderuuid);
			resource_source_set(&source, timestamp, typehash,
			                    platform, STRING_ARGS(uuidstr));
		}
	}

	resource_source_set(&source, timestamp, HASH_RESOURCE_TYPE,
	                    0, STRING_CONST("program"));

	if (!resource_source_write(&source, uuid, false)) {
		string_const_t uuidstr = string_from_uuid_static(uuid);
		log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Failed writing imported program: %.*s"),
		          STRING_FORMAT(uuidstr));
		ret = -1;
		goto finalize;
	}
	else {
		string_const_t uuidstr = string_from_uuid_static(uuid);
		log_infof(HASH_RESOURCE, STRING_CONST("Wrote imported program: %.*s"),
		          STRING_FORMAT(uuidstr));
	}

finalize:
	resource_source_finalize(&source);

	return ret;
}
Пример #3
0
static int
render_import_shader(stream_t* stream, const uuid_t uuid) {
	char buffer[1024];
	char pathbuf[BUILD_MAX_PATHLEN];
	resource_source_t source;
	resource_platform_t platformdecl = {-1, -1, -1, -1, -1, -1};
	uint64_t platform;
	tick_t timestamp;
	int ret = 0;

	resource_source_initialize(&source);
	resource_source_read(&source, uuid);

	platform = resource_platform(platformdecl);
	timestamp = time_system();

	while (!stream_eos(stream)) {
		uuid_t shaderuuid;
		string_const_t target, ref, fullpath;
		string_t line = stream_read_line_buffer(stream, buffer, sizeof(buffer), '\n');
		string_split(STRING_ARGS(line), STRING_CONST(" \t"),
		             &target, &ref, false);

		ref = string_strip(STRING_ARGS(ref), STRING_CONST(STRING_WHITESPACE));
		shaderuuid = string_to_uuid(STRING_ARGS(ref));
		if (uuid_is_null(shaderuuid)) {
			if (path_is_absolute(STRING_ARGS(ref))) {
				fullpath = ref;
			}
			else {
				string_t full;
				string_const_t path = stream_path(stream);
				path = path_directory_name(STRING_ARGS(path));
				full = path_concat(pathbuf, sizeof(pathbuf),
				                   STRING_ARGS(path), STRING_ARGS(ref));
				full = path_absolute(STRING_ARGS(full), sizeof(pathbuf));
				fullpath = string_const(STRING_ARGS(full));
			}

			resource_signature_t sig = resource_import_lookup(STRING_ARGS(fullpath));
			if (uuid_is_null(sig.uuid)) {
				if (!resource_import(STRING_ARGS(fullpath), uuid_null())) {
					log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS,
					          STRING_CONST("Unable to import linked shader: %.*s"),
					          STRING_FORMAT(fullpath));
					ret = -1;
					goto finalize;
				}
				sig = resource_import_lookup(STRING_ARGS(fullpath));
				if (uuid_is_null(sig.uuid)) {
					log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS,
					          STRING_CONST("Import linked shader gave no UUID: %.*s"),
					          STRING_FORMAT(fullpath));
					ret = -1;
					goto finalize;
				}
			}
			shaderuuid = sig.uuid;
		}

		if (!uuid_is_null(shaderuuid)) {
			resource_platform_t targetplatformdecl =
			    render_import_parse_target(STRING_ARGS(target), platformdecl);
			uint64_t targetplatform = resource_platform(targetplatformdecl);

			if (resource_autoimport_need_update(shaderuuid, targetplatform))
				resource_autoimport(shaderuuid);

			const string_const_t uuidstr = string_from_uuid_static(shaderuuid);
			resource_source_set(&source, timestamp, HASH_SHADER,
			                    targetplatform, STRING_ARGS(uuidstr));
			resource_source_set_dependencies(uuid, targetplatform, &shaderuuid, 1);
		}
	}

	resource_source_set(&source, timestamp, HASH_RESOURCE_TYPE,
	                    0, STRING_CONST("shader"));

	if (!resource_source_write(&source, uuid, false)) {
		string_const_t uuidstr = string_from_uuid_static(uuid);
		log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Failed writing imported shader: %.*s"),
		          STRING_FORMAT(uuidstr));
		ret = -1;
		goto finalize;
	}
	else {
		string_const_t uuidstr = string_from_uuid_static(uuid);
		log_infof(HASH_RESOURCE, STRING_CONST("Wrote imported shader: %.*s"),
		          STRING_FORMAT(uuidstr));
	}

finalize:
	resource_source_finalize(&source);

	return 0;
}
Пример #4
0
DECLARE_TEST( uuid, generate )
{
	int iloop;
	uuid_t uuid, uuid_ref;
	char name_str[] = "com.rampantpixels.foundation.uuid.000000";

	uuid = uuid_null();
	uuid_ref = uuid_null();

	EXPECT_TRUE( uuid_is_null( uuid ) );
	EXPECT_TRUE( uuid_is_null( uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) );

	//Random based
	uuid = uuid_generate_random();
	uuid_ref = uuid_null();
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_TRUE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_generate_random();
	uuid_ref = uuid_generate_random();

	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_ref;
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	for( iloop = 0; iloop < 64000; ++iloop )
	{
		uuid_ref = uuid;
		uuid = uuid_generate_random();
	
		EXPECT_FALSE( uuid_is_null( uuid ) );
		EXPECT_FALSE( uuid_is_null( uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );
	}
	
	//Time based
	uuid = uuid_generate_time();
	uuid_ref = uuid_null();
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_TRUE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_generate_time();
	uuid_ref = uuid_generate_time();

	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_ref;
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	for( iloop = 0; iloop < 64000; ++iloop )
	{
		uuid_ref = uuid;
		uuid = uuid_generate_time();
	
		EXPECT_FALSE( uuid_is_null( uuid ) );
		EXPECT_FALSE( uuid_is_null( uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );
	}
	
	//Name based
	uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid" );
	uuid_ref = uuid_null();
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_TRUE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.1" );
	uuid_ref = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.2" );

	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.2" );
	
	EXPECT_FALSE( uuid_is_null( uuid ) );
	EXPECT_FALSE( uuid_is_null( uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid, uuid ) );
	EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );

	for( iloop = 0; iloop < 10000; ++iloop )
	{
		string_format_buffer( name_str, 40, "com.rampantpixels.foundation.uuid.%05u", iloop );
		
		uuid_ref = uuid;
		uuid = uuid_generate_name( UUID_DNS, name_str );
	
		EXPECT_FALSE( uuid_is_null( uuid ) );
		EXPECT_FALSE( uuid_is_null( uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) );
		EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid, uuid ) );
		EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) );
	}
	
	return 0;
}
Пример #5
0
uuid_t
render_vertexbuffer_uuid(object_t id) {
	render_vertexbuffer_t* buffer = GET_BUFFER(id);
	return buffer ? buffer->uuid : uuid_null();
}