[Java] [Android] 用Canvas画出3D矩形

额

想模仿OpenGL

提示

虽说是模仿，但不彻底，因为不是每个像素渲染过去的，所以光照、纹理通通不能用
然后它的旋转貌似有点问题，不知道为什么

代码

package com.Diamond.canvas;

import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.renderscript.Float2;
import android.opengl.Matrix;
import android.renderscript.Float3;
import android.graphics.Paint;
import android.renderscript.Float4;
import android.view.MotionEvent;
import android.graphics.Path;

public class MySurfaceView extends SurfaceView {
    public class MyCallback implements SurfaceHolder.Callback {
        public boolean isSurfaceAvailable = false;
        public Float3[] vertices;
        public float[] matrix;
        public Paint paint;
        public Float2 rotate;
        public Path path;
        
        @Override
        public void surfaceCreated(SurfaceHolder p1) {
            isSurfaceAvailable = true;
            
            vertices = new Float3[]{
                new Float3(-0.5f,0.5f,0.0f),
                new Float3(0.5f,0.5f,0.0f),
                new Float3(0.5f,-0.5f,0.0f),
                new Float3(-0.5f,-0.5f,0.0f),
            };
            
            rotate = new Float2(0,0);
            update();
            
            paint = new Paint();
            paint.setColor(Color.BLUE);
            
            m_thread = new DrawThread();
            m_thread.start();
        }

        @Override
        public void surfaceChanged(SurfaceHolder p1, int p2, int p3, int p4) {
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder p1) {
            isSurfaceAvailable = false;
            
            m_thread.stop();
            m_thread.destroy();
        }

        public void drawFrame(Canvas canvas) {
            canvas.drawColor(Color.WHITE);
            canvas.drawPath(path,paint);
        }
        
        public void update() {
            if(rotate.x >= 360) rotate.x -= 360;
            else if(rotate.x <= -360) rotate.x += 360;
            if(rotate.y >= 360) rotate.y -= 360;
            else if(rotate.y <= -360) rotate.y += 360;
            
            //加载模型矩阵
            matrix = new float[16];
            Matrix.setIdentityM(matrix,0);
            Matrix.rotateM(matrix,0,rotate.x,1,0,0);
            Matrix.rotateM(matrix,0,rotate.y,0,1,0);
            
            //对每个顶点乘上模型矩阵
            for (int i = 0; i < vertices.length; i++) {
                vertices[i] = multMatrix(vertices[i],matrix);
            }
            
            //更新Path
            path = new Path();
            Float2 v = toScreen(vertices[0]);
            path.moveTo(v.x,v.y);
            for (int i = 1; i < vertices.length; i++) {
                v = toScreen(vertices[i]);
                path.lineTo(v.x,v.y);
            }
            path.close();
        }
    }

    public class DrawThread extends Thread {

        @Override
        public void run() {
            while (true) {
                if (m_callback.isSurfaceAvailable) {
                    Canvas canvas = m_holder.lockCanvas();
                    m_callback.drawFrame(canvas);
                    m_holder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }

    public SurfaceHolder m_holder;
    public MyCallback m_callback;
    public DrawThread m_thread;
    public Float2 last;
    public MySurfaceView(Context context) {
        super(context);
        
        setClickable(true);

        m_holder = getHolder();
        m_callback = new MyCallback();
        m_holder.addCallback(m_callback);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if(event.getAction() == MotionEvent.ACTION_DOWN) {
            last = getPosition(event);
        } else if(event.getAction() == MotionEvent.ACTION_MOVE) {
            Float2 current = getPosition(event);
            Float2 delta = sub(current,last);
            last = current;
            
            //旋转
            final float speed = 0.001f;
            m_callback.rotate.x += delta.x * speed;
            m_callback.rotate.y += delta.y * speed;
            m_callback.update();
        }
        return super.onTouchEvent(event);
    }
    
    public Float2 getPosition(MotionEvent event) {
        return new Float2(event.getX(),event.getY());
    }
    
    public Float2 sub(Float2 a,Float2 b) {
        return new Float2(a.x - b.x,a.y - b.y);
    }
    
    public Float2 toScreen(Float3 position) {
        //转换为屏幕坐标
        Float2 result = new Float2();
        result.x = (position.x + 1.0f) / 2.0f * (float)getWidth();
        result.y = (1.0f - ((position.y + 1.0f) / 2.0f)) * (float)getHeight();
        return result;
    }
    
    public Float3 multMatrix(Float3 vertex,float[] matrix) {
        Float4 v = new Float4(vertex.x,vertex.y,vertex.z,1.0f);
        float[] m = matrix;
        
        //感觉两个没啥区别，可能是不够明显
        float x = m[0] * v.x + m[1] * v.y + m[2] * v.z + m[3] * v.w;
        float y = m[4] * v.x + m[5] * v.y + m[6] * v.z + m[7] * v.w;
        float z = m[8] * v.x + m[9] * v.y + m[10] * v.z + m[11] * v.w;
        float w = m[12] * v.x + m[13] * v.y + m[14] * v.z + m[15] * v.w;
        
        /*float x = m[0] * v.x + m[4] * v.y + m[8] * v.z + m[12] * v.w;
        float y = m[1] * v.x + m[5] * v.y + m[9] * v.z + m[13] * v.w;
        float z = m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14] * v.w;
        float w = m[3] * v.x + m[7] * v.y + m[11] * v.z + m[15] * v.w;*/
        
        vertex = new Float3(x,y,z);
        return vertex;
    }
}

运行结果