import org.oscim.utils.FastMath; //导入依赖的package包/类
@Override
public void update(GLViewport v) {
    if (!mInitialized) {
        init();
        mInitialized = true;
    }

    if (!isEnabled()) {
        setReady(false);
        return;
    }

    if (!v.changed() && !mReanimated && !isReady())
        return;

    setReady(true);

    // clamp location to a position that can be
    // safely translated to screen coordinates
    v.getBBox(mBBox, 0);

    mLocationIsVisible = mBBox.contains(mLocation);
    mIndicatorPosition.x = FastMath.clamp(mLocation.x, mBBox.xmin, mBBox.xmax);
    mIndicatorPosition.y = FastMath.clamp(mLocation.y, mBBox.ymin, mBBox.ymax);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
/**
 * Scale map by scale width center at pivot in pixel relative to
 * screen center. Map scale is clamp to MIN_SCALE and MAX_SCALE.
 * 
 * @param scale
 * @param pivotX
 * @param pivotY
 * @return true if scale was changed
 */
public synchronized boolean scaleMap(float scale, float pivotX, float pivotY) {
	// just sanitize input
	//scale = FastMath.clamp(scale, 0.5f, 2);
	if (scale < 0.000001)
		return false;

	double newScale = mPos.scale * scale;

	newScale = FastMath.clamp(newScale, MIN_SCALE, MAX_SCALE);

	if (newScale == mPos.scale)
		return false;

	scale = (float) (newScale / mPos.scale);

	mPos.scale = newScale;

	if (pivotX != 0 || pivotY != 0)
		moveMap(pivotX * (1.0f - scale),
		        pivotY * (1.0f - scale));

	return true;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
/**
 * Get the current MapPosition.
 * 
 * @param pos MapPosition to be updated.
 * 
 * @return true iff current position is different from
 *         passed position.
 */
public synchronized boolean getMapPosition(MapPosition pos) {

	boolean changed = (pos.scale != mPos.scale
	        || pos.x != mPos.x
	        || pos.y != mPos.y
	        || pos.bearing != mPos.bearing
	        || pos.tilt != mPos.tilt);

	pos.bearing = mPos.bearing;
	pos.tilt = mPos.tilt;

	pos.x = mPos.x;
	pos.y = mPos.y;
	pos.scale = mPos.scale;
	pos.zoomLevel = FastMath.log2((int) mPos.scale);

	return changed;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
/**
 * Get the current MapPosition
 *
 * @param pos MapPosition object to be updated
 * @return true if current position is different from 'pos'.
 */
public synchronized boolean getMapPosition(MapPosition pos) {

	boolean changed = (pos.x != mAbsX || pos.y != mAbsY
			|| pos.scale != mAbsScale
			|| pos.angle != mRotation
			|| pos.tilt != mTilt);

	if (!changed)
		return false;

	int z = FastMath.log2((int) mAbsScale);

	pos.angle = mRotation;
	pos.tilt = mTilt;

	pos.x = mAbsX;
	pos.y = mAbsY;
	pos.scale = mAbsScale;

	pos.zoomLevel = z;

	return true;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
private synchronized void moveAbs(double x, double y) {
	double f = Tile.SIZE << ABS_ZOOMLEVEL;

	mAbsX = x / f;
	mAbsY = y / f;

	// clamp latitude
	mAbsY = FastMath.clamp(mAbsY, 0, 1);

	// wrap longitude
	while (mAbsX > 1)
		mAbsX -= 1;
	while (mAbsX < 0)
		mAbsX += 1;

	updatePosition();
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public synchronized void animateFling(int velocityX, int velocityY,
		int minX, int maxX, int minY, int maxY) {

	if (velocityX * velocityX + velocityY * velocityY < 4096)
		return;

	mScrollX = 0;
	mScrollY = 0;

	float duration = 500;

	// pi times thumb..
	float flingFactor = (duration / 2500);
	mVelocityX = velocityX * flingFactor;
	mVelocityY = velocityY * flingFactor;
	FastMath.clamp(mVelocityX, minX, maxX);
	FastMath.clamp(mVelocityY, minY, maxY);

	mAnimFling = true;
	mAnimMove = false;
	mAnimScale = false;
	animStart(duration);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
void moveTo(double x, double y) {
	mPos.x = x;
	mPos.y = y;

	/* clamp latitude */
	mPos.y = FastMath.clamp(mPos.y, 0, 1);

	/* wrap longitude */
	while (mPos.x > 1)
		mPos.x -= 1;
	while (mPos.x < 0)
		mPos.x += 1;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public synchronized boolean setTilt(float tilt) {
	tilt = FastMath.clamp(tilt, 0, MAX_TILT);
	if (tilt == mPos.tilt)
		return false;
	mPos.tilt = tilt;
	updateMatrices();
	return true;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public synchronized void setMapPosition(MapPosition mapPosition) {
	mPos.scale = FastMath.clamp(mapPosition.scale, MIN_SCALE, MAX_SCALE);
	mPos.x = mapPosition.x;
	mPos.y = mapPosition.y;
	mPos.tilt = mapPosition.tilt;
	mPos.bearing = mapPosition.bearing;
	updateMatrices();
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
@Override
public void onMapEvent(Event event, MapPosition pos) {
	super.onMapEvent(event, pos);

	if (event != Map.POSITION_EVENT)
		return;

	FadeStep[] fade = mTileSource.getFadeSteps();

	if (fade == null) {
		//mRenderLayer.setBitmapAlpha(1);
		return;
	}

	float alpha = 0;
	for (FadeStep f : fade) {
		if (pos.scale < f.scaleStart || pos.scale > f.scaleEnd)
			continue;

		if (f.alphaStart == f.alphaEnd) {
			alpha = f.alphaStart;
			break;
		}
		double range = f.scaleEnd / f.scaleStart;
		float a = (float) ((range - (pos.scale / f.scaleStart)) / range);
		a = FastMath.clamp(a, 0, 1);
		// interpolate alpha between start and end
		alpha = a * f.alphaStart + (1 - a) * f.alphaEnd;
		break;
	}

	tileRenderer().setBitmapAlpha(alpha);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public float getFade(double scale) {
	if (fadeScale < 0)
		return 1;

	float f = (float) (scale / (1 << fadeScale)) - 1;
	return FastMath.clamp(f, FADE_START, 1);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public float getBlend(double scale) {
	if (blendScale < 0)
		return 0;

	float f = (float) (scale / (1 << blendScale)) - 1;
	return FastMath.clamp(f, 0, 1);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public static int fadePremul(int color, double alpha) {
	alpha = FastMath.clamp(alpha, 0, 1);

	alpha *= (color >>> 24) & 0xff;
	int c = (((int) alpha) & 0xff) << 24;

	alpha /= 255;

	c |= ((int) (alpha * ((color >>> 16) & 0xff))) << 16;
	c |= ((int) (alpha * ((color >>> 8) & 0xff))) << 8;
	c |= ((int) (alpha * (color & 0xff)));

	return c;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public static int fade(int color, double alpha) {
	alpha = FastMath.clamp(alpha, 0, 1);

	alpha *= (color >>> 24) & 0xff;
	int c = (((int) alpha) & 0xff) << 24;

	return c | (color & 0x00ffffff);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
/**
 * @param lat
 *            the latitude in degrees, will be limited to the possible
 *            latitude range.
 * @param lon
 *            the longitude in degrees, will be limited to the possible
 *            longitude range.
 */
public GeoPoint(double lat, double lon) {
	lat = FastMath.clamp(lat,
	                     MercatorProjection.LATITUDE_MIN,
	                     MercatorProjection.LATITUDE_MAX);
	this.latitudeE6 = (int) (lat * CONVERSION_FACTOR);
	lon = FastMath.clamp(lon,
	                     MercatorProjection.LONGITUDE_MIN,
	                     MercatorProjection.LONGITUDE_MAX);
	this.longitudeE6 = (int) (lon * CONVERSION_FACTOR);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public void set(double x, double y, double scale, float bearing, float tilt) {
	this.x = x;
	this.y = y;
	this.scale = scale;

	while (bearing > 180)
		bearing -= 360;
	while (bearing < -180)
		bearing += 360;
	this.bearing = bearing;

	this.tilt = tilt;
	this.zoomLevel = FastMath.log2((int) scale);
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
private synchronized void move(double mx, double my) {
	mAbsX = (mCurX - mx) / mCurScale;
	mAbsY = (mCurY - my) / mCurScale;

	// clamp latitude
	mAbsY = FastMath.clamp(mAbsY, 0, 1);

	// wrap longitude
	while (mAbsX > 1)
		mAbsX -= 1;
	while (mAbsX < 0)
		mAbsX += 1;

	updatePosition();
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
/**
 * @param scale map by this factor
 * @param pivotX ...
 * @param pivotY ...
 * @return true if scale was changed
 */
public synchronized boolean scaleMap(float scale, float pivotX, float pivotY) {
	// stop animation
	animCancel();

	// just sanitize input
	scale = FastMath.clamp(scale, 0.5f, 2);

	double newScale = mAbsScale * scale;

	newScale = FastMath.clamp(newScale, MIN_SCALE, MAX_SCALE);

	if (newScale == mAbsScale)
		return false;

	scale = (float) (newScale / mAbsScale);

	mAbsScale = newScale;

	if (pivotX != 0 || pivotY != 0)
		moveMap(pivotX * (1.0f - scale),
				pivotY * (1.0f - scale));
	else
		updatePosition();

	return true;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public synchronized boolean setTilt(float tilt) {
	tilt = FastMath.clamp(tilt, 0, MAX_TILT);
	if (tilt == mTilt)
		return false;
	mTilt = tilt;
	updateMatrix();
	return true;
}
 

import org.oscim.utils.FastMath; //导入依赖的package包/类
public synchronized void setMapPosition(MapPosition mapPosition) {
	mAbsScale = FastMath.clamp(mapPosition.scale, MIN_SCALE, MAX_SCALE);
	mAbsX = mapPosition.x;
	mAbsY = mapPosition.y;
	mTilt = mapPosition.tilt;
	mRotation = mapPosition.angle;
	updatePosition();
	updateMatrix();
}