Java Code Examples for android.graphics.Matrix#preTranslate()

/**
 * 旋转Bitmap为一定的角度并四周暗化处理.
 *
 * @param bitmap the bitmap
 * @param degrees the degrees
 * @return the bitmap
 */
public static Bitmap rotateBitmapTranslate(Bitmap bitmap, float degrees) {
    Bitmap mBitmap = null;
    int width;
    int height;
    try {
        Matrix matrix = new Matrix();
        if ((degrees / 90) % 2 != 0) {
            width = bitmap.getWidth();
            height = bitmap.getHeight();
        }
        else {
            width = bitmap.getHeight();
            height = bitmap.getWidth();
        }
        int cx = width / 2;
        int cy = height / 2;
        matrix.preTranslate(-cx, -cy);
        matrix.postRotate(degrees);
        matrix.postTranslate(cx, cy);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return mBitmap;
}
 

/**
 * Sets a matrix such that given a rotation, it transforms that rotation's logical coordinates
 * to physical coordinates.
 *
 * @param rotation the rotation to which the matrix should transform
 * @param out      the matrix to be set
 */
public static void transformLogicalToPhysicalCoordinates(@Rotation int rotation,
        @Dimension int physicalWidth, @Dimension int physicalHeight, Matrix out) {
    switch (rotation) {
        case ROTATION_0:
            out.reset();
            break;
        case ROTATION_90:
            out.setRotate(90);
            out.preTranslate(0, -physicalWidth);
            break;
        case ROTATION_180:
            out.setRotate(180);
            out.preTranslate(-physicalWidth, -physicalHeight);
            break;
        case ROTATION_270:
            out.setRotate(270);
            out.preTranslate(-physicalHeight, 0);
            break;
        default:
            throw new IllegalArgumentException("Unknown rotation: " + rotation);
    }
}
 

@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);
}
 

public static Bitmap rotate(Bitmap original, final int angle) {
    if ((angle % 360) == 0) {
        return original;
    }

    final boolean dimensionsChanged = angle == 90 || angle == 270;
    final int oldWidth = original.getWidth();
    final int oldHeight = original.getHeight();
    final int newWidth = dimensionsChanged ? oldHeight : oldWidth;
    final int newHeight = dimensionsChanged ? oldWidth : oldHeight;

    Bitmap bitmap = Bitmap.createBitmap(newWidth, newHeight, original.getConfig());
    Canvas canvas = new Canvas(bitmap);

    Matrix matrix = new Matrix();
    matrix.preTranslate((newWidth - oldWidth) / 2f, (newHeight - oldHeight) / 2f);
    matrix.postRotate(angle, bitmap.getWidth() / 2f, bitmap.getHeight() / 2);
    canvas.drawBitmap(original, matrix, null);

    original.recycle();

    return bitmap;
}
 

static void offsetDescendantMatrix(ViewParent target, View view, Matrix m) {
    final ViewParent parent = view.getParent();
    if (parent instanceof View && parent != target) {
        final View vp = (View) parent;
        offsetDescendantMatrix(target, vp, m);
        m.preTranslate(-vp.getScrollX(), -vp.getScrollY());
    }

    m.preTranslate(view.getLeft(), view.getTop());

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        if (!view.getMatrix().isIdentity()) {
            m.preConcat(view.getMatrix());
        }
    }
}
 

@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
	// Angle around the y-axis of the rotation at the given time
	// calculated both in radians and degrees.
	final double radians = Math.PI * interpolatedTime;
	float degrees = (float) (180.0 * radians / Math.PI);

	// Once we reach the midpoint in the animation, we need to hide the
	// source view and show the destination view. We also need to change
	// the angle by 180 degrees so that the destination does not come in
	// flipped around
	if (interpolatedTime >= 0.5f) {
		degrees -= 180.f;
		fromView.setVisibility(View.GONE);
		toView.setVisibility(View.VISIBLE);
	}

	if (forward)
		degrees = -degrees; // determines direction of rotation when
							// flip begins

	final Matrix matrix = t.getMatrix();
	camera.save();
	camera.rotateY(degrees);
	camera.getMatrix(matrix);
	camera.restore();
	matrix.preTranslate(-centerX, -centerY);
	matrix.postTranslate(centerX, centerY);
}
 

@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
    super.applyTransformation(interpolatedTime, t);
    Matrix matrix = t.getMatrix();
    Camera camera = new Camera();
    camera.save();
    camera.rotateY(-180 * interpolatedTime);
    camera.getMatrix(matrix);
    camera.restore();
    matrix.preTranslate(-mcenterX,-mcenterY);
    matrix.postTranslate(mcenterX,mcenterY);
}
 

private void testGetMatrix(Canvas canvas) {

        Path path = new Path();

        path.addCircle(0, 0, 200, Path.Direction.CW);  // 添加大矩形


        PathMeasure measure = new PathMeasure(path, false);
        Matrix matrix = new Matrix();
        measure.getMatrix(measure.getLength() * currentValue, matrix, PathMeasure.TANGENT_MATRIX_FLAG | PathMeasure.POSITION_MATRIX_FLAG);
        //考虑的时候 把角度先放到0度在考虑； 图片默认在左上角移动到该点 应该在该点之下；
        matrix.preTranslate(-arraw.getWidth(), -arraw.getHeight() / 2);
        canvas.drawBitmap(arraw, matrix, null);

        canvas.drawPath(path, mDeafultPaint);                    // 绘制 Path
    }
 

public Matrix getRotateMatrix() {
    // By default this is an identity matrix.
    Matrix matrix = new Matrix();
    if (mRotation != 0) {
        // We want to do the rotation at origin, but since the bounding
        // rectangle will be changed after rotation, so the delta values
        // are based on old & new width/height respectively.
        int cx = mBitmap.getWidth() / 2;
        int cy = mBitmap.getHeight() / 2;
        matrix.preTranslate(-cx, -cy);
        matrix.postRotate(mRotation);
        matrix.postTranslate(getWidth() / 2, getHeight() / 2);
    }
    return matrix;
}
 

public Matrix getRotateMatrix() {
    // By default this is an identity matrix.
    Matrix matrix = new Matrix();
    if (mRotation != 0) {
        // We want to do the rotation at origin, but since the bounding
        // rectangle will be changed after rotation, so the delta values
        // are based on old & new width/height respectively.
        int cx = mBitmap.getWidth() / 2;
        int cy = mBitmap.getHeight() / 2;
        matrix.preTranslate(-cx, -cy);
        matrix.postRotate(mRotation);
        matrix.postTranslate(getWidth() / 2, getHeight() / 2);
    }
    return matrix;
}
 

public Matrix getRotateMatrix() {
    // By default this is an identity matrix.
    Matrix matrix = new Matrix();
    if (mRotation != 0) {
        // We want to do the rotation at origin, but since the bounding
        // rectangle will be changed after rotation, so the delta values
        // are based on old & new width/height respectively.
        int cx = mBitmap.getWidth() / 2;
        int cy = mBitmap.getHeight() / 2;
        matrix.preTranslate(-cx, -cy);
        matrix.postRotate(mRotation);
        matrix.postTranslate(getWidth() / 2, getHeight() / 2);
    }
    return matrix;
}
 

static void offsetDescendantMatrix(ViewParent target, View view, Matrix m) {
    final ViewParent parent = view.getParent();
    if (parent instanceof View && parent != target) {
        final View vp = (View) parent;
        offsetDescendantMatrix(target, vp, m);
        m.preTranslate(-vp.getScrollX(), -vp.getScrollY());
    }

    m.preTranslate(view.getLeft(), view.getTop());

    if (!view.getMatrix().isIdentity()) {
        m.preConcat(view.getMatrix());
    }
}
 

@Override
protected boolean getChildStaticTransformation(View child, Transformation t) {

	int topCenterView = mHeightCenter - mChildrenHeightMiddle;
	int childTop      = Math.max(0,child.getTop());
	float offset      = (-childTop + topCenterView)/ (float) mSpaceBetweenViews;
	final Matrix matrix = t.getMatrix();
	if (offset != 0) {
		float absOffset = Math.abs(offset);
		t.clear();
		t.setTransformationType(Transformation.TYPE_MATRIX);

		float px = child.getLeft() + (child.getWidth()) / 2;
		float py = child.getTop() + (child.getHeight()) / 2; 

		if (mTranslatateEnbabled){
			matrix.setTranslate(mTranslate * absOffset, 0);
		}

		if (offset > 0) {
			matrix.preTranslate(-px,0);
			matrix.postTranslate(px,0);
		} else {
			matrix.preTranslate(-px, -py);
			matrix.postTranslate(px, py);
		}
	}
	return true;
}
 

@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();

    camera.rotateY(degrees);

    camera.getMatrix(matrix);
    camera.restore();

    matrix.preTranslate(-centerX, -centerY);
    matrix.postTranslate(centerX, centerY);

}
 

public static void setRectToRect(Matrix matrix, RectF src, RectF dst, int rotation, Matrix.ScaleToFit align)
{
    float tx, sx;
    float ty, sy;
    if (rotation == 90 || rotation == 270)
    {
        sx = dst.height() / src.width();
        sy = dst.width() / src.height();
    }
    else
    {
        sx = dst.width() / src.width();
        sy = dst.height() / src.height();
    }
    if (align != Matrix.ScaleToFit.FILL)
    {
        if (sx > sy)
        {
            sx = sy;
        }
        else
        {
            sy = sx;
        }
    }
    tx = -src.left * sx;
    ty = -src.top * sy;

    matrix.setTranslate(dst.left, dst.top);
    if (rotation == 90)
    {
        matrix.preRotate(90);
        matrix.preTranslate(0, -dst.width());
    }
    else if (rotation == 180)
    {
        matrix.preRotate(180);
        matrix.preTranslate(-dst.width(), -dst.height());
    }
    else if (rotation == 270)
    {
        matrix.preRotate(270);
        matrix.preTranslate(-dst.height(), 0);
    }

    matrix.preScale(sx, sy);
    matrix.preTranslate(tx, ty);
}
 

public PaintingData getPaintingData(RectF rect, boolean undo) {
    int minX = (int) rect.left;
    int minY = (int) rect.top;
    int width = (int) rect.width();
    int height = (int) rect.height();

    GLES20.glGenFramebuffers(1, buffers, 0);
    int framebuffer = buffers[0];
    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, framebuffer);

    GLES20.glGenTextures(1, buffers, 0);
    int texture = buffers[0];

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
    GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);

    GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, texture, 0);

    GLES20.glViewport(0, 0, (int) size.width, (int) size.height);

    if (shaders == null) {
        return null;
    }
    Shader shader = shaders.get(undo ? "nonPremultipliedBlit" : "blit");
    if (shader == null) {
        return null;
    }
    GLES20.glUseProgram(shader.program);

    Matrix translate = new Matrix();
    translate.preTranslate(-minX, -minY);
    float effective[] = GLMatrix.LoadGraphicsMatrix(translate);
    float finalProjection[] = GLMatrix.MultiplyMat4f(projection, effective);

    GLES20.glUniformMatrix4fv(shader.getUniform("mvpMatrix"), 1, false, FloatBuffer.wrap(finalProjection));

    if (undo) {
        GLES20.glUniform1i(shader.getUniform("texture"), 0);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, getTexture());
    } else {
        GLES20.glUniform1i(shader.getUniform("texture"), 0);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, bitmapTexture.texture());

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, getTexture());
    }
    GLES20.glClearColor(0, 0, 0, 0);
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA);

    GLES20.glVertexAttribPointer(0, 2, GLES20.GL_FLOAT, false, 8, vertexBuffer);
    GLES20.glEnableVertexAttribArray(0);
    GLES20.glVertexAttribPointer(1, 2, GLES20.GL_FLOAT, false, 8, textureBuffer);
    GLES20.glEnableVertexAttribArray(1);

    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

    dataBuffer.limit(width * height * 4);
    GLES20.glReadPixels(0, 0, width, height, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, dataBuffer);

    PaintingData data;
    if (undo) {
        data = new PaintingData(null, dataBuffer);
    } else {
        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        bitmap.copyPixelsFromBuffer(dataBuffer);

        data = new PaintingData(bitmap, null);
    }

    buffers[0] = framebuffer;
    GLES20.glDeleteFramebuffers(1, buffers, 0);

    buffers[0] = texture;
    GLES20.glDeleteTextures(1, buffers, 0);

    return data;
}
 

public PaintingData getPaintingData(RectF rect, boolean undo) {
    int minX = (int) rect.left;
    int minY = (int) rect.top;
    int width = (int) rect.width();
    int height = (int) rect.height();

    GLES20.glGenFramebuffers(1, buffers, 0);
    int framebuffer = buffers[0];
    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, framebuffer);

    GLES20.glGenTextures(1, buffers, 0);
    int texture = buffers[0];

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
    GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_NEAREST);
    GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);

    GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, texture, 0);

    GLES20.glViewport(0, 0, (int) size.width, (int) size.height);

    if (shaders == null) {
        return null;
    }
    Shader shader = shaders.get(undo ? "nonPremultipliedBlit" : "blit");
    if (shader == null) {
        return null;
    }
    GLES20.glUseProgram(shader.program);

    Matrix translate = new Matrix();
    translate.preTranslate(-minX, -minY);
    float[] effective = GLMatrix.LoadGraphicsMatrix(translate);
    float[] finalProjection = GLMatrix.MultiplyMat4f(projection, effective);

    GLES20.glUniformMatrix4fv(shader.getUniform("mvpMatrix"), 1, false, FloatBuffer.wrap(finalProjection));

    GLES20.glUniform1i(shader.getUniform("texture"), 0);

    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, getTexture());

    GLES20.glClearColor(0, 0, 0, 0);
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ZERO);

    GLES20.glVertexAttribPointer(0, 2, GLES20.GL_FLOAT, false, 8, vertexBuffer);
    GLES20.glEnableVertexAttribArray(0);
    GLES20.glVertexAttribPointer(1, 2, GLES20.GL_FLOAT, false, 8, textureBuffer);
    GLES20.glEnableVertexAttribArray(1);

    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

    dataBuffer.limit(width * height * 4);
    GLES20.glReadPixels(0, 0, width, height, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, dataBuffer);

    PaintingData data;
    if (undo) {
        data = new PaintingData(null, dataBuffer);
    } else {
        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        bitmap.copyPixelsFromBuffer(dataBuffer);

        data = new PaintingData(bitmap, null);
    }

    buffers[0] = framebuffer;
    GLES20.glDeleteFramebuffers(1, buffers, 0);

    buffers[0] = texture;
    GLES20.glDeleteTextures(1, buffers, 0);

    return data;
}
 

@Override
protected boolean getChildStaticTransformation(View child, Transformation t) {
    // We can cast here because FancyCoverFlowAdapter only creates wrappers.
    FancyCoverFlowItemWrapper item = (FancyCoverFlowItemWrapper) child;

    // Since Jelly Bean childs won't get invalidated automatically, needs to be added for the smooth coverflow animation
    if (android.os.Build.VERSION.SDK_INT >= 16) {
        item.invalidate();
    }

    final int coverFlowWidth = this.getWidth();
    final int coverFlowCenter = coverFlowWidth / 2;
    final int childWidth = item.getWidth();
    final int childHeight = item.getHeight();
    final int childCenter = item.getLeft() + childWidth / 2;

    // Use coverflow width when its defined as automatic.
    final int actionDistance = (this.actionDistance == ACTION_DISTANCE_AUTO) ? (int) ((coverFlowWidth + childWidth) / 2.0f) : this.actionDistance;

    // Calculate the abstract amount for all effects.
    final float effectsAmount = Math.min(1.0f, Math.max(-1.0f, (1.0f / actionDistance) * (childCenter - coverFlowCenter)));

    // Clear previous transformations and set transformation type (matrix + alpha).
    t.clear();
    t.setTransformationType(Transformation.TYPE_BOTH);

    // Alpha
    if (this.unselectedAlpha != 1) {
        final float alphaAmount = (this.unselectedAlpha - 1) * Math.abs(effectsAmount) + 1;
        t.setAlpha(alphaAmount);
    }

    // Saturation
    if (this.unselectedSaturation != 1) {
        // Pass over saturation to the wrapper.
        final float saturationAmount = (this.unselectedSaturation - 1) * Math.abs(effectsAmount) + 1;
        item.setSaturation(saturationAmount);
    }

    final Matrix imageMatrix = t.getMatrix();

    // Apply rotation.
    if (this.maxRotation != 0) {
        final int rotationAngle = (int) (-effectsAmount * this.maxRotation);
        this.transformationCamera.save();
        this.transformationCamera.rotateY(rotationAngle);
        this.transformationCamera.getMatrix(imageMatrix);
        this.transformationCamera.restore();
    }

    // Zoom.
    if (this.unselectedScale != 1) {
        final float zoomAmount = (this.unselectedScale - 1) * Math.abs(effectsAmount) + 1;
        // Calculate the scale anchor (y anchor can be altered)
        final float translateX = childWidth / 2.0f;
        final float translateY = childHeight * this.scaleDownGravity;
        imageMatrix.preTranslate(-translateX, -translateY);
        imageMatrix.postScale(zoomAmount, zoomAmount);
        imageMatrix.postTranslate(translateX, translateY);
    }

    return true;
}
 

private void drawSun(Canvas canvas) {
    Matrix matrix = mMatrix;
    matrix.reset();

    float dragPercent = mPercent;
    if (dragPercent > 1.0f) { // Slow down if pulling over set height
        dragPercent = (dragPercent + 9.0f) / 10;
    }

    float sunRadius = (float) mSunSize / 2.0f;
    float sunRotateGrowth = SUN_INITIAL_ROTATE_GROWTH;

    float offsetX = mSunLeftOffset;
    float offsetY = mSunTopOffset + (mParent.getTotalDragDistance() / 2) * (1.0f - dragPercent)
            // Move the sun up
            - mTop; // Depending on Canvas position

    float scalePercentDelta = dragPercent - SCALE_START_PERCENT;
    if (scalePercentDelta > 0) {
        float scalePercent = scalePercentDelta / (1.0f - SCALE_START_PERCENT);
        float sunScale = 1.0f - (1.0f - SUN_FINAL_SCALE) * scalePercent;
        sunRotateGrowth += (SUN_FINAL_ROTATE_GROWTH - SUN_INITIAL_ROTATE_GROWTH) * scalePercent;

        matrix.preTranslate(offsetX + (sunRadius - sunRadius * sunScale),
                offsetY * (2.0f - sunScale));
        matrix.preScale(sunScale, sunScale);

        offsetX += sunRadius;
        offsetY = offsetY * (2.0f - sunScale) + sunRadius * sunScale;
    } else {
        matrix.postTranslate(offsetX, offsetY);

        offsetX += sunRadius;
        offsetY += sunRadius;
    }

    matrix.postRotate((isRefreshing ? -360 : 360) * mRotate * (isRefreshing ? 1 : sunRotateGrowth),
            offsetX, offsetY);

    canvas.drawBitmap(mSun, matrix, null);
}
 

private void a(Matrix matrix, View view)
{
    float f1 = view.getWidth();
    float f2 = view.getHeight();
    boolean flag = d;
    float f3;
    float f4;
    float f5;
    float f6;
    float f7;
    float f8;
    float f9;
    if (flag)
    {
        f3 = f;
    } else
    {
        f3 = f1 / 2.0F;
    }
    if (flag)
    {
        f4 = g;
    } else
    {
        f4 = f2 / 2.0F;
    }
    f5 = h;
    f6 = i;
    f7 = j;
    if (f5 != 0.0F || f6 != 0.0F || f7 != 0.0F)
    {
        Camera camera = c;
        camera.save();
        camera.rotateX(f5);
        camera.rotateY(f6);
        camera.rotateZ(-f7);
        camera.getMatrix(matrix);
        camera.restore();
        matrix.preTranslate(-f3, -f4);
        matrix.postTranslate(f3, f4);
    }
    f8 = k;
    f9 = l;
    if (f8 != 1.0F || f9 != 1.0F)
    {
        matrix.postScale(f8, f9);
        matrix.postTranslate(-(f3 / f1) * (f8 * f1 - f1), -(f4 / f2) * (f9 * f2 - f2));
    }
    matrix.postTranslate(m, n);
}