DisplayDevicePtr DisplayDevice::factory(const std::string& type)
	{
		ASSERT_LOG(!get_display_registry().empty(), "No display device drivers registered.");
		auto it = get_display_registry().find(type);
		if(it == get_display_registry().end()) {			
			LOG_WARN("Requested display driver '" << type << "' not found, using default: " << get_display_registry().begin()->first);
			current_display_device() = get_display_registry().begin()->second();
			return get_display_registry().begin()->second();
		}
		current_display_device() = it->second();
		return it->second();
	}

		float convert_numeric(const variant& node)
		{
			if(node.is_int()) {
				return clamp<int>(node.as_int32(), 0, 255) / 255.0f;
			} else if(node.is_float()) {
				return clamp<float>(node.as_float(), 0.0f, 1.0f);
			} else if(node.is_string()) {
				return convert_string_to_number(node.as_string());
			}
			ASSERT_LOG(false, "attribute of Color value was expected to be numeric type.");
			return 1.0f;
		}

	double as3_value::to_number()
	{
		switch(type_) {
			case UNDEFINED:		return std::numeric_limits<double>::infinity();
			case BOOLEAN:		return b_ ? 1 : 0;
			case NUMERIC:		return d_;
			case OBJECT:		return o_ == NULL ? 0 : o_->to_number();
			case PROPERTY: {
				ASSERT_LOG(false, "XXX todo PROPERTY::to_number");
			}
		}
		ASSERT_LOG(type_ != STRING, "FATAL: unknown type_ value: " << type_);
		// String case -- we do thing the lazy way, not the compliant way.
		double num = std::numeric_limits<double>::infinity();
		try {
			num = boost::lexical_cast<double>(s_);
		} catch(boost::bad_lexical_cast&) {
			std::cerr << "Caught a bad floating point cast from " << s_ << " assuming infinity" << std::endl;
		}
		return num;
	}

const SDL_Color& get_color_from_name(std::string name)
{
	if(get_color_cache().empty()) {
		color_cache_init();
	}
	std::map<std::string,boost::function<const SDL_Color&()> >::iterator it = get_color_cache().find(name);
	if(it != get_color_cache().end()) {
		return it->second();
	}
	ASSERT_LOG(false, "Color \"" << name << "\" not known!");
	return color_black();
}

			rect quick_draw(int x, 
				int y,
				const std::string& str, 
				const std::string& font, 
				int size, 
				const color& c)
			{
				SDL_Color bg = {0, 0, 0, 255};
				surface_ptr surf = surface_ptr(new surface(TTF_RenderUTF8_Shaded(font::get_font(font, size).get(), str.c_str(), c.as_sdl_color(), bg)));
				ASSERT_LOG(surf != NULL, "Couldn't render text into texture");
				blit_2d_texture(texture::get(surf), static_cast<float>(x), static_cast<float>(y), static_cast<float>(surf->width()), static_cast<float>(surf->height()));
				return rect(x, y, surf->width(), surf->height());
			}

void write_file(const std::string& fname, const std::string& data)
{
	bool absolute_path = fname[0] == '/' ? true : false;
	//Try to ensure that the dir the file is in exists.
	std::vector<std::string> components;
	boost::split(components, fname, std::bind2nd(std::equal_to<char>(), '/'));
	boost::filesystem::path p(fname);
	ASSERT_LOG(get_dir(p.parent_path().string()) != "", "Couldn't create directory: " << p.parent_path().string());

	//Write the file.
	std::ofstream file(fname.c_str(),std::ios_base::binary);
	file << data;
}

bool File::readBuffer(uint8_t* _pBuffer, int iBufferSize)
{
	ASSERT_LOG(m_pHandle != NULL, "File handle is invalid");
	ASSERT_LOG(_pBuffer != NULL, "Buffer is invalid");
	
	if (-1 == iBufferSize)
	{
		iBufferSize	= getLength();
	}

	if (0 == iBufferSize)
	{
		return	false;
	}

	if (static_cast<int>(fread(_pBuffer, 1, iBufferSize, (FILE*)m_pHandle)) != iBufferSize)
	{
		return	false;
	}
	
	return	true;
}

		void text::quick_draw(render& render_obj, 
			GLfloat x, 
			GLfloat y, 
			const std::string& str, 
			const std::string& font, 
			int size, 
			const color& c)
		{
			SDL_Color bg = {0, 0, 0, 255};
			surface_ptr surf = surface_ptr(TTF_RenderUTF8_Shaded(font::get_font(font, size).get(), str.c_str(), c.as_sdl_color(), bg), SDL_FreeSurface);
			ASSERT_LOG(surf != NULL, "Couldn't render text into texture");
			render_obj.blit_2d_texture(texture::get(surf), x, y);
		}

	SurfacePtr Surface::create(int width, 
		int height, 
		int bpp, 
		uint32_t rmask, 
		uint32_t gmask, 
		uint32_t bmask, 
		uint32_t amask)
	{
		// XXX no caching as default?
		ASSERT_LOG(get_surface_creator().empty() == false, "No resources registered to create surfaces from masks.");
		auto create_fn_tuple = get_surface_creator().begin()->second;
		return std::get<2>(create_fn_tuple)(width, height, bpp, rmask, gmask, bmask, amask);
	}

	Surface::BlendMode SurfaceSDL::getBlendMode() const 
	{
		SDL_BlendMode sdl_bm;
		SDL_GetSurfaceBlendMode(surface_, &sdl_bm);
		switch(sdl_bm) {
		case SDL_BLENDMODE_NONE:	return BLEND_MODE_NONE;
		case SDL_BLENDMODE_BLEND:	return BLEND_MODE_BLEND;
		case SDL_BLENDMODE_ADD:		return BLEND_MODE_ADD;
		case SDL_BLENDMODE_MOD:		return BLEND_MODE_MODULATE;
		}
		ASSERT_LOG(false, "Unrecognised SDL blend mode: " << sdl_bm);
		return BLEND_MODE_NONE;
	}

	void Material::init(const variant& node)
	{
		blend_.set(BlendModeConstants::BM_SRC_ALPHA, BlendModeConstants::BM_ONE_MINUS_SRC_ALPHA);

		if(node.is_string()) {
			name_ = node.as_string();
			tex_.emplace_back(DisplayDevice::createTexture(name_));
		} else if(node.is_map()) {
			name_ = node["name"].as_string();
		
			// XXX: technically a material could have multiple technique's and passes -- ignoring for now.
			ASSERT_LOG(node.has_key("technique"), "PSYSTEM2: 'material' must have 'technique' attribute.");
			ASSERT_LOG(node["technique"].has_key("pass"), "PSYSTEM2: 'material' must have 'pass' attribute.");
			const variant& pass = node["technique"]["pass"];
			use_lighting_ = pass["lighting"].as_bool(false);
			use_fog_ = pass["fog_override"].as_bool(false);
			do_depth_write_ = pass["depth_write"].as_bool(true);
			do_depth_check_ = pass["depth_check"].as_bool(true);
			if(pass.has_key("scene_blend")) {
				blend_.set(pass["scene_blend"]);
			}
			if(pass.has_key("texture_unit")) {
				if(pass["texture_unit"].is_map()) {
					tex_.emplace_back(createTexture(pass["texture_unit"]));
				} else if(pass["texture_unit"].is_list()) {
					for(size_t n = 0; n != pass["texture_unit"].num_elements(); ++n) {
						tex_.emplace_back(createTexture(pass["texture_unit"][n]));
					}
				} else {
					ASSERT_LOG(false, "'texture_unit' attribute must be map or list ");
				}
			}
			if(pass.has_key("rect")) {
				draw_rect_ = rectf(pass["rect"]);
			}
		} else {
			ASSERT_LOG(false, "Materials(Textures) must be either a single string filename or a map.");
		}
	}

/* Handle a response to a given request. if this is a quorum setting, choose the
 * right response. Then make sure all the requests are satisfied in a fragmented
 * request scenario and then use the post coalesce logic to cook up a combined
 * response
 */
static rstatus_t
client_handle_response(struct conn *conn, msgid_t reqid, struct msg *rsp)
{
    ASSERT_LOG(!rsp->peer, "response %lu:%lu has peer set",
               rsp->id, rsp->parent_id);

    // now the handler owns the response.
    ASSERT(conn->type == CONN_CLIENT);
    // Fetch the original request
    struct msg *req = dictFetchValue(conn->outstanding_msgs_dict, &reqid);
    if (!req) {
        log_notice("looks like we already cleanedup the request for %d", reqid);
        rsp_put(rsp);
        return DN_OK;
    }
    // we have to submit the response irrespective of the unref status.
    rstatus_t status = msg_handle_response(req, rsp);
    if (conn->waiting_to_unref) {
        // dont care about the status.
        if (req->awaiting_rsps)
            return DN_OK;
        // all responses received
        dictDelete(conn->outstanding_msgs_dict, &reqid);
        log_info("Putting req %d", req->id);
        req_put(req);
        client_unref_internal_try_put(conn);
        return DN_OK;
    }
    if (status == DN_NOOPS) {
        // by now the response is dropped
        if (!req->awaiting_rsps) {
            // if we have sent the response for this request or the connection
            // is closed and we are just waiting to drain off the messages.
            if (req->rsp_sent) {
                dictDelete(conn->outstanding_msgs_dict, &reqid);
                log_info("Putting req %d", req->id);
                req_put(req);
            }
        }
    } else if (status == DN_OK) {
        g_pre_coalesce(req->selected_rsp);
        if (req_done(conn, req)) {
            struct context *ctx = conn_to_ctx(conn);
            status = event_add_out(ctx->evb, conn);
            if (status != DN_OK) {
                conn->err = errno;
            }
        }
    }
    return status;
}

std::vector<char> compress(const std::vector<char>& data, int compression_level) {
	z_stream strm;
	int ret;
	int pos_in = 0;
	int pos_out = 0;
	int flush;
	std::vector<char> in(data); // <-- annoying work around for old versions of zlib that don't define z_stream.in as const, by defining ZLIB_CONST
	std::vector<char> out;

	ASSERT_LOG(compression_level >= -1 && compression_level <= 9, "Compression level must be between -1(default) and 9.");
	memset(&strm, 0, sizeof(z_stream));
    if(deflateInit(&strm, compression_level) != Z_OK) {
		CompressionException e = {"Unable to initialise deflation routines."};
        throw CompressionException(e);
	}
	do {
		strm.avail_in = (in.size() - pos_in) > CHUNK ? CHUNK : in.size() - pos_in;
        flush = (strm.avail_in + pos_in) == in.size() ? Z_FINISH : Z_NO_FLUSH;
		if(in.size()) {
			strm.next_in = reinterpret_cast<Bytef*>(&in[pos_in]);
		} else {
			strm.next_in = 0;
		}
		do {
			out.resize(pos_out - out.size() + CHUNK);
			strm.avail_out = CHUNK;
			strm.next_out = reinterpret_cast<Bytef*>(&out[pos_out]);
            ret = deflate(&strm, flush);    // no bad return value
			ASSERT_LOG(ret != Z_STREAM_ERROR, "Error in the compression stream");
            pos_out += CHUNK - strm.avail_out;
		} while (strm.avail_out == 0);
		ASSERT_LOG(strm.avail_in == 0, "zip::compress(): All input used");     // all input will be used
	} while(flush != Z_FINISH);
	ASSERT_LOG(ret == Z_STREAM_END, "zip::compress(): stream will be complete");
	deflateEnd(&strm);
	out.resize(pos_out);
	return out;
}

float node::as_float() const
{
	switch(type()) {
	case NODE_TYPE_INTEGER:
		return float(i_);
	case NODE_TYPE_FLOAT:
		return f_;
	case NODE_TYPE_BOOL:
		return b_ ? 1.0f : 0.0f;
	default: break;
	}
	ASSERT_LOG(false, "as_float() type conversion error from " << type_as_string() << " to float");
	return 0;
}

tile::tile(int x, int y, const std::string& data)
  : loc_(x, y)
{
	std::vector<std::string> v = util::split(data, ' ');
	ASSERT_GE(v.size(), 1);

	terrain_ = terrain::get(v.front());
	ASSERT_LOG(terrain_, "Could not find terrain " << v.front());
	if(v.size() > 1) {
		productivity_ = atoi(v[1].c_str());
	} else {
		productivity_ = terrain_->calculate_production_value();
	}
}

void run_utility(const std::string& utility_name, const std::vector<std::string>& arg)
{
    UtilityProgram util = get_utility_map()[utility_name];
    if(!util) {
        std::string known;
        for(UtilityMap::const_iterator i = get_utility_map().begin(); i != get_utility_map().end(); ++i) {
            if(i->second) {
                known += i->first + " ";
            }
        }
        ASSERT_LOG(false, "Unknown utility: '" << utility_name << "'; known utilities: " << known);
    }
    util(arg);
}

	void generate_color_wheel(int num_points, std::vector<glm::u8vec4>* color_array, const Color& centre, float start_hue, float end_hue)
	{
		ASSERT_LOG(num_points > 0, "Must be more than one point in call to generate_color_wheel()");
		color_array->emplace_back(centre.ri(), centre.gi(), centre.bi(), centre.ai()); // center color.
		float hue = start_hue;
		const float sat = 1.0f;
		const float value = 1.0f;
		for(int n = 0; n != num_points; n++) {
			auto c = Color::from_hsv(hue, sat, value);
			color_array->emplace_back(c.ri(), c.gi(), c.bi(), c.ai());
			hue += (end_hue - start_hue)/static_cast<float>(num_points);
		}
		color_array->emplace_back((*color_array)[1]);
	}

void graphical_font_label::set_value(const std::string& key, const variant& v)
{
	if(key == "text") {
		set_text(v.as_string());
	} else if(key == "font") {
		font_ = graphical_font::get(v.as_string());
		ASSERT_LOG(font_.get(), "UNKNOWN FONT: " << v.as_string());
		reset_text_dimensions();
	} else if(key == "size") {
		size_ = v.as_int();
		reset_text_dimensions();
	}
	//widget::set_value(key);
}

	void program_object::set_uniform(const_actives_map_iterator it, const GLfloat* value)
	{
		const actives& u = it->second;
		ASSERT_LOG(value != NULL, "set_uniform(): value is NULL");
		switch(u.type) {
		case GL_FLOAT: {
			glUniform1f(u.location, *value);
			break;
		}
		case GL_FLOAT_VEC2: {
			glUniform2fv(u.location, u.num_elements, value);
			break;
		}
		case GL_FLOAT_VEC3: {
			glUniform3fv(u.location, u.num_elements, value);
			break;
		}
		case GL_FLOAT_VEC4: {
			glUniform4fv(u.location, u.num_elements, value);
			break;
		}
		case GL_FLOAT_MAT2:	{
			glUniformMatrix2fv(u.location, u.num_elements, GL_FALSE, value);
			break;
		}
		case GL_FLOAT_MAT3: {
			glUniformMatrix3fv(u.location, u.num_elements, GL_FALSE, value);
			break;
		}
		case GL_FLOAT_MAT4: {
			glUniformMatrix4fv(u.location, u.num_elements, GL_FALSE, value);
			break;
		}
		default:
			ASSERT_LOG(false, "Unhandled uniform type: " << it->second.type);
		}	
	}

	bool lua_context::execute(const variant& value, game_logic::formula_callable* callable)
	{
		bool res = false;
		if(callable) {
			set_self_callable(*callable);
		}
		if(value.is_string()) {
			res = dostring("", value.as_string());
		} else {
			lua_compiled_ptr compiled = value.try_convert<lua_compiled>();
			ASSERT_LOG(compiled != NULL, "FATAL: object given couldn't be converted to type 'lua_compiled'");
			res = compiled->run(context_ptr());
		}
		return res;
	}