下面列出了android.graphics.Camera#save ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* 根据角度绘制图标的类
* @param canvas 画布
* @param fraction 完成时间百分比
* @param icon 图标
* @param width view宽度
* @param height view高度
*/
private void drawIconOne(Canvas canvas, float fraction, Bitmap icon, int width, int height) {
Camera camera = new Camera();
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
canvas.save();
int centerX = width / 2;
int centerY = height / 2 - 200;
int x = centerX - icon.getWidth()/2;
int y = centerY - icon.getHeight()/2;
Matrix matrix = new Matrix();
matrix.postScale(1.7f, 1.7f, centerX, centerY);
canvas.concat(matrix);
canvas.clipRect(x, y, x + icon.getWidth() * fraction * 0.5f, y + icon.getHeight() * fraction * 0.5f);
canvas.translate(centerX, centerY);
camera.save();
camera.rotateX(180);
camera.rotateY(-180);
camera.applyToCanvas(canvas);
camera.restore();
canvas.translate(-centerX, -centerY);
canvas.drawBitmap(icon, x, y, paint);
canvas.restore();
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final int derection = mTurnUp ? 1 : -1;
final Matrix matrix = t.getMatrix();
camera.save();
if (mTurnIn) {
camera.translate(0.0f, derection * mCenterY * (interpolatedTime - 1.0f), 0.0f);
} else {
camera.translate(0.0f, derection * mCenterY * (interpolatedTime), 0.0f);
}
camera.rotateX(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
protected final void applyTransformation(float paramFloat, Transformation transformation) {
float f1 = 0.0F - 360.0F * paramFloat;
float f2 = mWidth;
float f3 = mHeight;
final Camera camera = mCamera;
Matrix matrix = transformation.getMatrix();
camera.save();
if ((0x1 & mRotationFlags) == 1)
camera.rotateX(f1);
if ((0x2 & mRotationFlags) == 2)
camera.rotateY(f1);
if ((0x4 & mRotationFlags) == 4)
camera.rotateZ(f1);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-f2, -f3);
matrix.postTranslate(f2, f3);
}
/**
* 执行顺序 matrix.preTranslate() --> camera.rotateY(degrees) --> matrix.postTranslate() --> matrix.postScale()
* @param interpolatedTime
* @param t
*/
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
float degrees = mReverse ? mToDegrees + (mFromDegrees - mToDegrees) * interpolatedTime : mFromDegrees + (mToDegrees - mFromDegrees) * interpolatedTime;
final Matrix matrix = t.getMatrix();
final Camera camera = mCamera;
camera.save();
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
// matrix.preTranslate(-mPivotXValue, 0); //在进行rotateY之前需要移动物体，让物体左边与Y轴对齐
// matrix.postTranslate(mPivotXValue, 0); //还原物体位置
if (mReverse) {
matrix.postScale(1 + (scaleTimes - 1) * (1.0f - interpolatedTime), 1 + (scaleTimes - 1) * (1.0f - interpolatedTime), mPivotX - mPivotXValue , mPivotY - mPivotYValue);
} else {
// matrix.postScale(1 + (scaleTimes - 1) * interpolatedTime, 1 + (scaleTimes - 1) * interpolatedTime, mPivotX, mPivotY);
matrix.postScale(1 + (scaleTimes - 1) * interpolatedTime, 1 + (scaleTimes - 1) * interpolatedTime, mPivotX - mPivotXValue , mPivotY - mPivotYValue );
}
}
private void transformMatrix(Matrix m, View view) {
final float w = view.getWidth();
final float h = view.getHeight();
final boolean hasPivot = mHasPivot;
final float pX = hasPivot ? mPivotX : w / 2f;
final float pY = hasPivot ? mPivotY : h / 2f;
final float rX = mRotationX;
final float rY = mRotationY;
final float rZ = mRotationZ;
if ((rX != 0) || (rY != 0) || (rZ != 0)) {
final Camera camera = mCamera;
camera.save();
camera.rotateX(rX);
camera.rotateY(rY);
camera.rotateZ(-rZ);
camera.getMatrix(m);
camera.restore();
m.preTranslate(-pX, -pY);
m.postTranslate(pX, pY);
}
final float sX = mScaleX;
final float sY = mScaleY;
if ((sX != 1.0f) || (sY != 1.0f)) {
m.postScale(sX, sY);
final float sPX = -(pX / w) * ((sX * w) - w);
final float sPY = -(pY / h) * ((sY * h) - h);
m.postTranslate(sPX, sPY);
}
m.postTranslate(mTranslationX, mTranslationY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees
+ ((mToDegrees - fromDegrees) * interpolatedTime);
final float fromZ = mFromZ;
float z = fromZ + ((mToZ - fromZ)*interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
camera.translate(0, 0, z);
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
/**
* 根据角度绘制图标的类
* @param canvas 画布
* @param degree 角度
* @param icon 图标
* @param width view宽度
* @param height view高度
*/
private void drawIconThree(Canvas canvas, int degree, Bitmap icon, int width, int height) {
Camera camera = new Camera();
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
int centerX = width / 2;
int centerY = height / 2 - 200;
int x = centerX - icon.getWidth()/2;
int y = centerY - icon.getHeight()/2;
Matrix matrix = new Matrix();
matrix.postScale(1.7f, 1.7f, centerX, centerY);
//绘制上半部分
canvas.save();
canvas.concat(matrix);
canvas.clipRect(x, y, x + icon.getWidth(), y + icon.getHeight() / 2);
canvas.drawBitmap(icon, x, y, paint);
canvas.restore();
//绘制下半部分
canvas.save();
canvas.concat(matrix);
if (degree <= 90)
canvas.clipRect(x, y, x + icon.getWidth(), y + icon.getHeight() / 2);
else
canvas.clipRect(x, y + icon.getHeight() / 2, x + icon.getWidth(), y + icon.getHeight());
canvas.translate(centerX, centerY);
camera.save();
camera.rotateX(180 - degree);
camera.applyToCanvas(canvas);
camera.restore();
canvas.translate(-centerX, -centerY);
canvas.drawBitmap(icon, x, y, paint);
canvas.restore();
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
// 根据时间和起始终止的角度值，插值算出当前的角度：degrees
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees
+ ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
}
else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
//pre:
matrix.preTranslate(-centerX, -centerY);
//post:
matrix.postTranslate(centerX, centerY);
}
private void transformMatrix(Matrix m, View view) {
final float w = view.getWidth();
final float h = view.getHeight();
final boolean hasPivot = mHasPivot;
final float pX = hasPivot ? mPivotX : w / 2f;
final float pY = hasPivot ? mPivotY : h / 2f;
final float rX = mRotationX;
final float rY = mRotationY;
final float rZ = mRotationZ;
if ((rX != 0) || (rY != 0) || (rZ != 0)) {
final Camera camera = mCamera;
camera.save();
camera.rotateX(rX);
camera.rotateY(rY);
camera.rotateZ(-rZ);
camera.getMatrix(m);
camera.restore();
m.preTranslate(-pX, -pY);
m.postTranslate(pX, pY);
}
final float sX = mScaleX;
final float sY = mScaleY;
if ((sX != 1.0f) || (sY != 1.0f)) {
m.postScale(sX, sY);
final float sPX = -(pX / w) * ((sX * w) - w);
final float sPY = -(pY / h) * ((sY * h) - h);
m.postTranslate(sPX, sPY);
}
m.postTranslate(mTranslationX, mTranslationY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
// 生成中间角度
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
// 取得变换后的矩阵
camera.getMatrix(matrix);
camera.restore();
float[] mValues = {0, 0, 0, 0, 0, 0, 0, 0, 0};
matrix.getValues(mValues); //获取数值
mValues[6] = mValues[6] / scale; //数值修正
matrix.setValues(mValues); //重新赋值
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
if (mRotateType == TYPEX) {
camera.rotateX(degrees);
} else if (mRotateType == TYPEY) {
camera.rotateY(degrees);
} else if (mRotateType == TYPEZ) {
camera.rotateZ(degrees);
}
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
private void transformMatrix(Matrix m, View view) {
final float w = view.getWidth();
final float h = view.getHeight();
final boolean hasPivot = mHasPivot;
final float pX = hasPivot ? mPivotX : w / 2f;
final float pY = hasPivot ? mPivotY : h / 2f;
final float rX = mRotationX;
final float rY = mRotationY;
final float rZ = mRotationZ;
if ((rX != 0) || (rY != 0) || (rZ != 0)) {
final Camera camera = mCamera;
camera.save();
camera.rotateX(rX);
camera.rotateY(rY);
camera.rotateZ(-rZ);
camera.getMatrix(m);
camera.restore();
m.preTranslate(-pX, -pY);
m.postTranslate(pX, pY);
}
final float sX = mScaleX;
final float sY = mScaleY;
if ((sX != 1.0f) || (sY != 1.0f)) {
m.postScale(sX, sY);
final float sPX = -(pX / w) * ((sX * w) - w);
final float sPY = -(pY / h) * ((sY * h) - h);
m.postTranslate(sPX, sPY);
}
m.postTranslate(mTranslationX, mTranslationY);
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
// 生成中间角度
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
// 取得变换后的矩阵
camera.getMatrix(matrix);
camera.restore();
//----------------------------------------------------------------------------
/**
* 修复打脸问题 (￣ε(#￣)☆╰╮(￣▽￣///)
* 简要介绍：
* 原来的3D翻转会由于屏幕像素密度问题而出现效果相差很大
* 例如在屏幕像素比为1,5的手机上显示效果基本正常，
* 而在像素比3,0的手机上面感觉翻转感觉要超出屏幕边缘，
* 有种迎面打脸的感觉、
*
* 解决方案
* 利用屏幕像素密度对变换矩阵进行校正，
* 保证了在所有清晰度的手机上显示的效果基本相同。
*
*/
float[] mValues = {0,0,0,0,0,0,0,0,0};
matrix.getValues(mValues); //获取数值
mValues[6] = mValues[6]/scale; //数值修正
matrix.setValues(mValues); //重新赋值
// Log.e("TAG", "mValues["+0+"]="+mValues[0]+"------------\t"+"mValues["+6+"]="+mValues[6]);
//----------------------------------------------------------------------------
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
/**
* 根据角度绘制图标的类
* @param canvas 画布
* @param degree 角度
* @param icon 图标
* @param width view宽度
* @param height view高度
*/
private void drawIconTwo(Canvas canvas, int degree, Bitmap icon, int width, int height) {
Camera camera = new Camera();
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
int centerX = width / 2;
int centerY = height / 2 - 200;
int x = centerX - icon.getWidth()/2;
int y = centerY - icon.getHeight()/2;
Matrix matrix = new Matrix();
matrix.postScale(1.7f, 1.7f, centerX, centerY);
//绘制左半部分
canvas.save();
canvas.concat(matrix);
canvas.clipRect(x, y, x + icon.getWidth() / 2, y + icon.getHeight() / 2);
canvas.translate(centerX, centerY);
camera.save();
camera.rotateX(180);
camera.applyToCanvas(canvas);
camera.restore();
canvas.translate(-centerX, -centerY);
canvas.drawBitmap(icon, x, y, paint);
canvas.restore();
//绘制右半部分
canvas.save();
canvas.concat(matrix);
if (degree <= 90)
canvas.clipRect(x , y , x + icon.getWidth() / 2, y + icon.getHeight() / 2);
else
canvas.clipRect(x + icon.getWidth() / 2, y, x + icon.getWidth(), y + icon.getHeight() / 2);
canvas.translate(centerX, centerY);
camera.save();
camera.rotateX(180);
camera.rotateY(180 - degree);
camera.applyToCanvas(canvas);
camera.restore();
canvas.translate(-centerX, -centerY);
canvas.drawBitmap(icon, x, y, paint);
canvas.restore();
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
final float fromDegrees = mFromDegrees;
// 生成中间角度
float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);
final float centerX = mCenterX;
final float centerY = mCenterY;
final Camera camera = mCamera;
final Matrix matrix = t.getMatrix();
camera.save();
if (mReverse) {
camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);
} else {
camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));
}
camera.rotateY(degrees);
// 取得变换后的矩阵
camera.getMatrix(matrix);
camera.restore();
//----------------------------------------------------------------------------
/**
* 修复打脸问题 (￣ε(#￣)☆╰╮(￣▽￣///)
* 简要介绍：
* 原来的3D翻转会由于屏幕像素密度问题而出现效果相差很大
* 例如在屏幕像素比为1,5的手机上显示效果基本正常，
* 而在像素比3,0的手机上面感觉翻转感觉要超出屏幕边缘，
* 有种迎面打脸的感觉、
*
* 解决方案
* 利用屏幕像素密度对变换矩阵进行校正，
* 保证了在所有清晰度的手机上显示的效果基本相同。
*
*/
float[] mValues = {0,0,0,0,0,0,0,0,0};
matrix.getValues(mValues); //获取数值
mValues[6] = mValues[6]/scale; //数值修正
matrix.setValues(mValues); //重新赋值
// Log.e("TAG", "mValues["+0+"]="+mValues[0]+"------------\t"+"mValues["+6+"]="+mValues[6]);
//----------------------------------------------------------------------------
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
protected boolean getChildStaticTransformation(View child, Transformation t) {
Camera camera = new Camera();
int leftCenterView = this.mWidthCenter - this.mChildrenWidthMiddle;
float offset = (-child.getLeft() + leftCenterView) /
this.mSpaceBetweenViews;
if (offset != 0.0F) {
float absOffset = Math.abs(offset);
float scale = (float) Math.pow(0.8999999761581421D, absOffset);
t.clear();
t.setTransformationType(Transformation.TYPE_MATRIX);
t.setAlpha(this.mSetInactiveViewTransparency);
Matrix m = t.getMatrix();
m.setScale(scale, scale);
if (this.mTranslatateEnbabled) {
m.setTranslate(0.0F, this.mTranslate * absOffset);
}
if (offset > 0.0F) {
camera.save();
camera.translate(0.0F, 0.0F, this.mViewZoomOutFactor * offset);
camera.rotateY(this.mCoverflowRotation);
camera.getMatrix(m);
camera.restore();
m.preTranslate(-this.mChildrenWidthMiddle, -this.mChildrenHeight);
m.postTranslate(this.mChildrenWidthMiddle, this.mChildrenHeight);
} else {
camera.save();
camera.translate(0.0F, 0.0F, -(this.mViewZoomOutFactor * offset));
camera.rotateY(-this.mCoverflowRotation);
camera.getMatrix(m);
camera.restore();
m.preTranslate(-this.mChildrenWidthMiddle, -this.mChildrenHeight);
m.postTranslate(this.mChildrenWidthMiddle, this.mChildrenHeight);
}
this.mMatrix.reset();
if (this.mRotationEnabled) {
this.mMatrix.setRotate(this.mRotation * offset);
}
this.mMatrix.preTranslate(-this.mChildrenWidthMiddle, -this.mChildrenHeightMiddle);
this.mMatrix.postTranslate(this.mChildrenWidthMiddle, this.mChildrenHeightMiddle);
m.setConcat(m, this.mMatrix);
}
return true;
}