怎么實現Android的3D效果

本篇內容介紹了“怎么實現Android的3D效果”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

目錄

• 一、先看看聊天（需求）

• 二、實現效果

• 三、實現

• 1.通過getSystemService獲得SensorManager實例對象

• 2.通過SensorManager實例對象獲得想要的傳感器對象:參數決定獲取哪個傳感器

• 3.在獲得焦點時注冊傳感器并讓本類實現SensorEventListener接口

• 4.必須重寫的兩個方法

• 5.在失去焦點時注銷傳感器(為Activity提供調用)

• 6.draw方法中的方發詳解

• 四、需求中的青黃色參數

• 五、源碼

文章最后將會貼出源碼(照顧新手附加注釋)

一、先看看聊天（需求）

二、實現效果

三、實現

前五步傳感器內容。

1.通過getSystemService獲得SensorManager實例對象

mSensorManager = (SensorManager)context.getSystemService(SENSOR_SERVICE);

2.通過SensorManager實例對象獲得想要的傳感器對象:參數決定獲取哪個傳感器

 mRotationVectorSensor = mSensorManager.getDefaultSensor(
                Sensor.TYPE_ROTATION_VECTOR);

3.在獲得焦點時注冊傳感器并讓本類實現SensorEventListener接口

 mSensorManager.registerListener(this, mRotationVectorSensor, 10000);

• 第一個參數：SensorEventListener接口的實例對象

• 第二個參數：需要注冊的傳感器實例

• 第三個參數：傳感器獲取傳感器事件event值頻率：

SensorManager.SENSOR_DELAY_FASTEST = 0：對應0微秒的更新間隔，最快，1微秒 = 1 % 1000000秒
SensorManager.SENSOR_DELAY_GAME = 1：對應20000微秒的更新間隔，游戲中常用
SensorManager.SENSOR_DELAY_UI = 2：對應60000微秒的更新間隔
SensorManager.SENSOR_DELAY_NORMAL = 3：對應200000微秒的更新間隔
鍵入自定義的int值x時：對應x微秒的更新間隔

4.必須重寫的兩個方法

onAccuracyChanged和onSensorChanged

onSensorChanged: 傳感器事件值改變時的回調接口：執行此方法的頻率與注冊傳感器時的頻率有關.

onAccuracyChanged:傳感器精度發生改變的回調接口

5.在失去焦點時注銷傳感器(為Activity提供調用)

public void stop() {
        mSensorManager.unregisterListener(this);
    }

6.draw方法中的方發詳解

本案例（opengl坐標系中采用的是3維坐標）

• glEnable：啟用服務器端GL功能。

• glFrontFace：定義多邊形的正面和背面。多邊形正面的方向。GL_CW和GL_CCW被允許，初始值為GL_CCW。

• glShadeModel：選擇恒定或光滑著色模式。GL圖元可以采用恒定或者光滑著色模式，默認值為光滑著色模式。當圖元進行光柵化的時候，將引起插入頂點顏色計算，不同顏色將被均勻分布到各個像素片段。允許的值有GL_FLAT 和GL_SMOOTH，初始值為GL_SMOOTH。

• glVertexPointer：定義一個頂點坐標矩陣。（后續源碼中會貼上各個參數以及需要注意的地方）。

• glColorPointer：定義一個顏色矩陣。size指明每個顏色的元素數量，必須為4。type指明每個顏色元素的數據類型，stride指明從一個顏色到下一個允許的頂點的字節增幅，并且屬性值被擠入簡單矩陣或存儲在單獨的矩陣中（簡單矩陣存儲可能在一些版本中更有效率）。

• glDrawElements：由矩陣數據渲染圖元

更多建議參考Android官方文檔。

四、需求中的青黃色參數

final float colors[] = {
                      0,  1,  1,  1,  1,  1,  1,  1,
                      1,  1,  0,  1,  1,  1,  1,  1,
                      1,  1,  1,  1,  0,  1,  1,  1,
                      1,  1,  1,  1,  1,  1,  0,  1,
            };

五、源碼

TdRenderer.java

public class TdRenderer implements GLSurfaceView.Renderer, SensorEventListener {
    //傳感器
    private SensorManager mSensorManager;
    private Sensor mRotationVectorSensor;
    private Cube mCube;

    private final float[] mRotationMatrix = new float[16];

    public TdRenderer(Context context) {
        //第一步：通過getSystemService獲得SensorManager實例對象
        mSensorManager = (SensorManager)context.getSystemService(SENSOR_SERVICE);
        //第二步：通過SensorManager實例對象獲得想要的傳感器對象:參數決定獲取哪個傳感器
        mRotationVectorSensor = mSensorManager.getDefaultSensor(
                Sensor.TYPE_ROTATION_VECTOR);

        mCube = new Cube();
        mRotationMatrix[ 0] = 1;
        mRotationMatrix[ 4] = 1;
        mRotationMatrix[ 8] = 1;
        mRotationMatrix[12] = 1;
    }
   // 第三步：在獲得焦點時注冊傳感器并讓本類實現SensorEventListener接口
    public void start() {
        /*
         *第一個參數：SensorEventListener接口的實例對象
         *第二個參數：需要注冊的傳感器實例
         *第三個參數：傳感器獲取傳感器事件event值頻率：
         *    SensorManager.SENSOR_DELAY_FASTEST = 0：對應0微秒的更新間隔，最快，1微秒 = 1 % 1000000秒
         *    SensorManager.SENSOR_DELAY_GAME = 1：對應20000微秒的更新間隔，游戲中常用
         *    SensorManager.SENSOR_DELAY_UI = 2：對應60000微秒的更新間隔
         *    SensorManager.SENSOR_DELAY_NORMAL = 3：對應200000微秒的更新間隔
         *    鍵入自定義的int值x時：對應x微秒的更新間隔
         *
         */
        mSensorManager.registerListener(this, mRotationVectorSensor, 10000);
    }
    //第四步：必須重寫的兩個方法：onAccuracyChanged，onSensorChanged
    //第五步：在失去焦點時注銷傳感器(為Activity提供調用)
    public void stop() {
        mSensorManager.unregisterListener(this);
    }
    //傳感器事件值改變時的回調接口：執行此方法的頻率與注冊傳感器時的頻率有關
    public void onSensorChanged(SensorEvent event) {
        // 大部分傳感器會返回三個軸方向x,y,x的event值
        //float x = event.values[0];
        //float y = event.values[1];
        //float z = event.values[2];
        if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
            SensorManager.getRotationMatrixFromVector(
                    mRotationMatrix , event.values);
        }
    }

    public void onDrawFrame(GL10 gl) {
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();
        gl.glTranslatef(0, 0, -3.0f);
        gl.glMultMatrixf(mRotationMatrix, 0);
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

        mCube.draw(gl);
    }

    public void onSurfaceChanged(GL10 gl, int width, int height) {
        gl.glViewport(0, 0, width, height);
        float ratio = (float) width / height;
        gl.glMatrixMode(GL10.GL_PROJECTION);
        gl.glLoadIdentity();
        gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
    }

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        gl.glDisable(GL10.GL_DITHER);
        //指定顏色緩沖區的清理值
        gl.glClearColor(1,1,1,1);
    }

    public class Cube {
        //opengl坐標系中采用的是3維坐標:
        private FloatBuffer mVertexBuffer;
        private FloatBuffer mColorBuffer;
        private ByteBuffer mIndexBuffer;

        public Cube() {
            final float vertices[] = {
                    -1, -1, -1,		 1, -1, -1,
                    1,  1, -1,	    -1,  1, -1,
                    -1, -1,  1,      1, -1,  1,
                    1,  1,  1,     -1,  1,  1,
            };

            final float colors[] = {
                      0,  1,  1,  1,  1,  1,  1,  1,
                      1,  1,  0,  1,  1,  1,  1,  1,
                      1,  1,  1,  1,  0,  1,  1,  1,
                      1,  1,  1,  1,  1,  1,  0,  1,
            };

            final byte indices[] = {
                    0, 4, 5,    0, 5, 1,
                    1, 5, 6,    1, 6, 2,
                    2, 6, 7,    2, 7, 3,
                    3, 7, 4,    3, 4, 0,
                    4, 7, 6,    4, 6, 5,
                    3, 0, 1,    3, 1, 2
            };

            ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4);
            vbb.order(ByteOrder.nativeOrder());
            mVertexBuffer = vbb.asFloatBuffer();
            mVertexBuffer.put(vertices);
            mVertexBuffer.position(0);

            ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4);
            cbb.order(ByteOrder.nativeOrder());
            mColorBuffer = cbb.asFloatBuffer();
            mColorBuffer.put(colors);
            mColorBuffer.position(0);

            mIndexBuffer = ByteBuffer.allocateDirect(indices.length);
            mIndexBuffer.put(indices);
            mIndexBuffer.position(0);
        }

        public void draw(GL10 gl) {
            //啟用服務器端GL功能。
            gl.glEnable(GL10.GL_CULL_FACE);
            //定義多邊形的正面和背面。
            //參數:
            //mode——多邊形正面的方向。GL_CW和GL_CCW被允許，初始值為GL_CCW。
            gl.glFrontFace(GL10.GL_CW);
            //選擇恒定或光滑著色模式。
            //GL圖元可以采用恒定或者光滑著色模式，默認值為光滑著色模式。當圖元進行光柵化的時候，將引起插入頂點顏色計算，不同顏色將被均勻分布到各個像素片段。
            //參數：
            //mode——指明一個符號常量來代表要使用的著色技術。允許的值有GL_FLAT 和GL_SMOOTH，初始值為GL_SMOOTH。
            gl.glShadeModel(GL10.GL_SMOOTH);
            //定義一個頂點坐標矩陣。
            //參數：
            //
            //size——每個頂點的坐標維數，必須是2, 3或者4，初始值是4。
            //
            //type——指明每個頂點坐標的數據類型，允許的符號常量有GL_BYTE, GL_SHORT, GL_FIXED和GL_FLOAT，初始值為GL_FLOAT。
            //
            //stride——指明連續頂點間的位偏移，如果為0，頂點被認為是緊密壓入矩陣，初始值為0。
            //
            //pointer——指明頂點坐標的緩沖區，如果為null，則沒有設置緩沖區。
            gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);
            //定義一個顏色矩陣。
            //size指明每個顏色的元素數量，必須為4。type指明每個顏色元素的數據類型，stride指明從一個顏色到下一個允許的頂點的字節增幅，并且屬性值被擠入簡單矩陣或存儲在單獨的矩陣中（簡單矩陣存儲可能在一些版本中更有效率）。
            gl.glColorPointer(4, GL10.GL_FLOAT, 0, mColorBuffer);
            //由矩陣數據渲染圖元
            //可以事先指明獨立的頂點、法線、顏色和紋理坐標矩陣并且可以通過調用glDrawElements方法來使用它們創建序列圖元。
            gl.glDrawElements(GL10.GL_TRIANGLES, 36, GL10.GL_UNSIGNED_BYTE, mIndexBuffer);
        }
    }
    //傳感器精度發生改變的回調接口
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        //在傳感器精度發生改變時做些操作，accuracy為當前傳感器精度
    }
}

ThreeDimensionsRotation,java(Activity記得注冊)

public class ThreeDimensionsRotation extends Activity {
    private GLSurfaceView mGLSurfaceView;
    private TdRenderer tdRenderer;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        tdRenderer=new TdRenderer(this);
        // 創建預覽視圖，并將其設置為Activity的內容
        mGLSurfaceView = new GLSurfaceView(this);
        mGLSurfaceView.setRenderer(tdRenderer);
        setContentView(mGLSurfaceView);
    }

    @Override
    protected void onResume() {
        super.onResume();
        tdRenderer.start();
        mGLSurfaceView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        tdRenderer.stop();
        mGLSurfaceView.onPause();
    }

}

“怎么實現Android的3D效果”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！