GOOGLE VR SDK开发VR游戏，VR播放器之二

最新推荐文章于 2020-05-12 19:57:49 发布
最新推荐文章于 2020-05-12 19:57:49 发布
阅读量4.1k 收藏 10
点赞数 5
分类专栏： android应用开发 文章标签： VR游戏 VR播放器 google VR SDK AR OPENGL ES
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnbloger/article/details/50970900
版权

之前简单说了CardBoardView的使用，这里写CardboardView.StereoRenderer的，使用上十分简单，和编写glsurface的Renderer一样导出有关的接口，使用OPGENGL实现就行了。代码使用OPGENGL ES2书写。

public class MySr implements CardboardView.StereoRenderer {
    private static final String TAG = "MainActivity";

    private static final float Z_NEAR = 0.1f;
    private static final float Z_FAR = 100.0f;

    private static final float CAMERA_Z = 0.01f;
    private static final float TIME_DELTA = 0.3f;

    private static final float YAW_LIMIT = 0.12f;
    private static final float PITCH_LIMIT = 0.12f;

    private static final int COORDS_PER_VERTEX = 3;

    // We keep the light always position just above the user.
    private static final float[] LIGHT_POS_IN_WORLD_SPACE = new float[]{0.0f, 2.0f, 0.0f, 1.0f};

    private final float[] lightPosInEyeSpace = new float[4];


    private FloatBuffer cubeVertices;
    private FloatBuffer cubeColors;
    private FloatBuffer cubeFoundColors;
    private FloatBuffer cubeNormals;

    private int cubeProgram;


    private int cubePositionParam;
    private int cubeNormalParam;
    private int cubeColorParam;
    private int cubeModelParam;
    private int cubeModelViewParam;
    private int cubeModelViewProjectionParam;
    private int cubeLightPosParam;

    private float[] modelCube;
    private float[] camera;
    private float[] view;
    private float[] headView;
    private float[] modelViewProjection;
    private float[] modelView;
    private float[] modelPosition;
    private float[] headRotation;




String light_vertex = "uniform mat4 u_Model;\n"
        +"uniform mat4 u_MVP;\n"
        +"uniform mat4 u_MVMatrix;\n"
        +"uniform vec3 u_LightPos;\n"

        +"attribute vec4 a_Position;\n"
        +"attribute vec4 a_Color;\n"
        +"attribute vec3 a_Normal;\n"

        +"varying vec4 v_Color;\n"
        +"varying vec3 v_Grid;\n"

        +"void main() {\n"
        +"v_Grid = vec3(u_Model * a_Position);\n"

        +"vec3 modelViewVertex = vec3(u_MVMatrix * a_Position);\n"
        +"vec3 modelViewNormal = vec3(u_MVMatrix * vec4(a_Normal, 0.0));\n"

        +"float distance = length(u_LightPos - modelViewVertex);\n"
        +"vec3 lightVector = normalize(u_LightPos - modelViewVertex);\n"
        +"float diffuse = max(dot(modelViewNormal, lightVector), 0.5);\n"

        +"diffuse = diffuse * (1.0 / (1.0 + (0.00001 * distance * distance)));\n"
        +"v_Color = a_Color * diffuse;\n"
        +"gl_Position = u_MVP * a_Position;\n"
        +"}\n";

    String passthrough_fragment = "precision mediump float;\n"
            +"varying vec4 v_Color;\n"

            +"void main() {\n"
            +"gl_FragColor = v_Color;\n"
            +"}\n";
    public static final float[] CUBE_COORDS = new float[] {
            // Front face
            -1.0f, 1.0f, 1.0f,
            -1.0f, -1.0f, 1.0f,
            1.0f, 1.0f, 1.0f,
            -1.0f, -1.0f, 1.0f,
            1.0f, -1.0f, 1.0f,
            1.0f, 1.0f, 1.0f,

            // Right face
            1.0f, 1.0f, 1.0f,
            1.0f, -1.0f, 1.0f,
            1.0f, 1.0f, -1.0f,
            1.0f, -1.0f, 1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, 1.0f, -1.0f,

            // Back face
            1.0f, 1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            -1.0f, 1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            -1.0f, -1.0f, -1.0f,
            -1.0f, 1.0f, -1.0f,

            // Left face
            -1.0f, 1.0f, -1.0f,
            -1.0f, -1.0f, -1.0f,
            -1.0f, 1.0f, 1.0f,
            -1.0f, -1.0f, -1.0f,
            -1.0f, -1.0f, 1.0f,
            -1.0f, 1.0f, 1.0f,

            // Top face
            -1.0f, 1.0f, -1.0f,
            -1.0f, 1.0f, 1.0f,
            1.0f, 1.0f, -1.0f,
            -1.0f, 1.0f, 1.0f,
            1.0f, 1.0f, 1.0f,
            1.0f, 1.0f, -1.0f,

            // Bottom face
            1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f, -1.0f,
    };

    public static final float[] CUBE_COLORS = new float[] {
            // front, green
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,

            // right, blue
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,

            // back, also green
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,
            0f, 0.5273f, 0.2656f, 1.0f,

            // left, also blue
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,
            0.0f, 0.3398f, 0.9023f, 1.0f,

            // top, red
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,

            // bottom, also red
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f, 0.17578125f, 0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
            0.8359375f,  0.17578125f,  0.125f, 1.0f,
    };

    public static final float[] CUBE_FOUND_COLORS = new float[] {
            // front, yellow
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,

            // right, yellow
            1.0f, 0.6523f, 0.0f, 1.0f,
            1.0f, 0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,

            // back, yellow
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f, 0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,

            // left, yellow
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f, 0.6523f, 0.0f, 1.0f,

            // top, yellow
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,

            // bottom, yellow
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
            1.0f,  0.6523f, 0.0f, 1.0f,
    };

    public static final float[] CUBE_NORMALS = new float[] {
            // Front face
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,

            // Right face
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,

            // Back face
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,

            // Left face
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,

            // Top face
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,

            // Bottom face
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f
    };
   public MySr() {
        initMode();
    }

    public void initMode() {
        modelCube = new float[16];
        camera = new float[16];
        view = new float[16];
        modelViewProjection = new float[16];
        modelView = new float[16];

        // Model first appears directly in front of user.
        //modelPosition = new float[]{0.0f, 0.0f, -MAX_MODEL_DISTANCE / 2.0f};
        modelPosition = new float[]{-0.0f, -0.0f, -5f};
        headRotation = new float[4];
        headView = new float[16];
    }

    private int loadGLShader(int type, String code) {
        int shader = GLES20.glCreateShader(type);
        GLES20.glShaderSource(shader, code);
        GLES20.glCompileShader(shader);

        // Get the compilation status.
        final int[] compileStatus = new int[1];
        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

        // If the compilation failed, delete the shader.
        if (compileStatus[0] == 0) {
            Log.e(TAG, "Error compiling shader: " + GLES20.glGetShaderInfoLog(shader));
            GLES20.glDeleteShader(shader);
            shader = 0;
        }

        if (shader == 0) {
            throw new RuntimeException("Error creating shader.");
        }

        return shader;
    }
    /**
     * Checks if we've had an error inside of OpenGL ES, and if so what that error is.
     *
     * @param label Label to report in case of error.
     */
    private static void checkGLError(String label) {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
            Log.e(TAG, label + ": glError " + error);
            throw new RuntimeException(label + ": glError " + error);
        }
    }

    @Override
    public void onRendererShutdown() {
        Log.i(TAG, "onRendererShutdown");
    }

    @Override
    public void onSurfaceChanged(int width, int height) {
        Log.i(TAG, "onSurfaceChanged");
    }

    /**
     * Creates the buffers we use to store information about the 3D world.
     * <p/>
     * <p>OpenGL doesn't use Java arrays, but rather needs data in a format it can understand.
     * Hence we use ByteBuffers.
     *
     * @param config The EGL configuration used when creating the surface.
     */
    @Override
    public void onSurfaceCreated(EGLConfig config) {
        Log.i(TAG, "onSurfaceCreated");
        //GLES20.glClearColor(0.1f, 0.1f, 0.1f, 0.5f); // Dark background so text shows up well.
        GLES20.glClearColor(1f, 1f, 1f, 1.0f);

        ByteBuffer bbVertices = ByteBuffer.allocateDirect(CUBE_COORDS.length * 4);
        bbVertices.order(ByteOrder.nativeOrder());
        cubeVertices = bbVertices.asFloatBuffer();
        cubeVertices.put(CUBE_COORDS);
        cubeVertices.position(0);

        ByteBuffer bbColors = ByteBuffer.allocateDirect(CUBE_COLORS.length * 4);
        bbColors.order(ByteOrder.nativeOrder());
        cubeColors = bbColors.asFloatBuffer();
        cubeColors.put(CUBE_COLORS);
        cubeColors.position(0);

        ByteBuffer bbFoundColors =
                ByteBuffer.allocateDirect(CUBE_FOUND_COLORS.length * 4);
        bbFoundColors.order(ByteOrder.nativeOrder());
        cubeFoundColors = bbFoundColors.asFloatBuffer();
        cubeFoundColors.put(CUBE_FOUND_COLORS);
        cubeFoundColors.position(0);

        ByteBuffer bbNormals = ByteBuffer.allocateDirect(CUBE_NORMALS.length * 4);
        bbNormals.order(ByteOrder.nativeOrder());
        cubeNormals = bbNormals.asFloatBuffer();
        cubeNormals.put(CUBE_NORMALS);
        cubeNormals.position(0);


        int vertexShader = loadGLShader(GLES20.GL_VERTEX_SHADER, light_vertex);
        int passthroughShader = loadGLShader(GLES20.GL_FRAGMENT_SHADER, passthrough_fragment);

        cubeProgram = GLES20.glCreateProgram();
        GLES20.glAttachShader(cubeProgram, vertexShader);
        GLES20.glAttachShader(cubeProgram, passthroughShader);
        GLES20.glLinkProgram(cubeProgram);
        GLES20.glUseProgram(cubeProgram);

        checkGLError("Cube program");

        cubePositionParam = GLES20.glGetAttribLocation(cubeProgram, "a_Position");
        cubeNormalParam = GLES20.glGetAttribLocation(cubeProgram, "a_Normal");
        cubeColorParam = GLES20.glGetAttribLocation(cubeProgram, "a_Color");

        cubeModelParam = GLES20.glGetUniformLocation(cubeProgram, "u_Model");
        cubeModelViewParam = GLES20.glGetUniformLocation(cubeProgram, "u_MVMatrix");
        cubeModelViewProjectionParam = GLES20.glGetUniformLocation(cubeProgram, "u_MVP");
        cubeLightPosParam = GLES20.glGetUniformLocation(cubeProgram, "u_LightPos");

        GLES20.glEnableVertexAttribArray(cubePositionParam);
        GLES20.glEnableVertexAttribArray(cubeNormalParam);
        GLES20.glEnableVertexAttribArray(cubeColorParam);

        checkGLError("Cube program params");

        updateModelPosition();

        checkGLError("onSurfaceCreated");
    }

    /**
     * Updates the cube model position.
     */
    private void updateModelPosition() {
        Matrix.setIdentityM(modelCube, 0);
        Matrix.translateM(modelCube, 0, modelPosition[0], modelPosition[1], modelPosition[2]);


        checkGLError("updateCubePosition");
    }



    /**
     * Prepares OpenGL ES before we draw a frame.
     *
     * @param headTransform The head transformation in the new frame.
     */
    @Override
    public void onNewFrame(HeadTransform headTransform) {
        // Build the Model part of the ModelView matrix.
        Matrix.rotateM(modelCube, 0, TIME_DELTA, 0.5f, 0.5f, 1.0f);

        // Build the camera matrix and apply it to the ModelView.
        Matrix.setLookAtM(camera, 0, 0.0f, 0.0f, CAMERA_Z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

        headTransform.getHeadView(headView, 0);

        // Update the 3d audio engine with the most recent head rotation.
        headTransform.getQuaternion(headRotation, 0);


        checkGLError("onReadyToDraw");
    }

    /**
     * Draws a frame for an eye.
     *
     * @param eye The eye to render. Includes all required transformations.
     */
    @Override
    public void onDrawEye(Eye eye) {

        GLES20.glEnable(GLES20.GL_DEPTH_TEST);
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

        checkGLError("colorParam");

        // Apply the eye transformation to the camera.
        Matrix.multiplyMM(view, 0, eye.getEyeView(), 0, camera, 0);

        // Set the position of the light
        Matrix.multiplyMV(lightPosInEyeSpace, 0, view, 0, LIGHT_POS_IN_WORLD_SPACE, 0);

        // Build the ModelView and ModelViewProjection matrices
        // for calculating cube position and light.
        float[] perspective = eye.getPerspective(Z_NEAR, Z_FAR);
        Matrix.multiplyMM(modelView, 0, view, 0, modelCube, 0);
        Matrix.multiplyMM(modelViewProjection, 0, perspective, 0, modelView, 0);
        drawCube();

    }

    @Override
    public void onFinishFrame(Viewport viewport) {
    }

    /**
     * Draw the cube.
     * <p/>
     * <p>We've set all of our transformation matrices. Now we simply pass them into the shader.
     */
    public void drawCube() {

        //GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        GLES20.glUseProgram(cubeProgram);

        GLES20.glUniform3fv(cubeLightPosParam, 1, lightPosInEyeSpace, 0);

        // Set the Model in the shader, used to calculate lighting
        GLES20.glUniformMatrix4fv(cubeModelParam, 1, false, modelCube, 0);

        // Set the ModelView in the shader, used to calculate lighting
        GLES20.glUniformMatrix4fv(cubeModelViewParam, 1, false, modelView, 0);

        // Set the position of the cube
        GLES20.glVertexAttribPointer(
                cubePositionParam, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, 0, cubeVertices);

        // Set the ModelViewProjection matrix in the shader.
        GLES20.glUniformMatrix4fv(cubeModelViewProjectionParam, 1, false, modelViewProjection, 0);

        // Set the normal positions of the cube, again for shading
        GLES20.glVertexAttribPointer(cubeNormalParam, 3, GLES20.GL_FLOAT, false, 0, cubeNormals);
        GLES20.glVertexAttribPointer(cubeColorParam, 4, GLES20.GL_FLOAT, false, 0,
                isLookingAtObject() ? cubeFoundColors : cubeColors);

        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 36);
        checkGLError("Drawing cube");
    }

    /**
     * Check if user is looking at object by calculating where the object is in eye-space.
     *
     * @return true if the user is looking at the object.
     */
    public boolean isLookingAtObject() {
        float[] initVec = {0, 0, 0, 1.0f};
        float[] objPositionVec = new float[4];

        // Convert object space to camera space. Use the headView from onNewFrame.
        Matrix.multiplyMM(modelView, 0, headView, 0, modelCube, 0);
        Matrix.multiplyMV(objPositionVec, 0, modelView, 0, initVec, 0);

        float pitch = (float) Math.atan2(objPositionVec[1], -objPositionVec[2]);
        float yaw = (float) Math.atan2(objPositionVec[0], -objPositionVec[2]);

        return Math.abs(pitch) < PITCH_LIMIT && Math.abs(yaw) < YAW_LIMIT;
    }
}

代码使用opengl知识构建一个正六面体，由于添加了VR效果，和glSurfaceView的Renderer不太一样，多出了一些方法。使用该方法创建的VR效果需要把应用的activity设置mSurfaceView.setVRModeEnabled(true);你也可以添加一个开关，以使你的应用支持VR模式和普通模式切换。谷歌的VR SDK可以帮我节约大量的时间专著于游戏开发，使得可以方便的像开发一般游戏一样，同时使游戏具有两种模式。而不必为VR单独开发代码。谷歌的SDK已经实现的普通模式，VR模式，分屏模式，正常模式，畸变，反畸变，并且封装了手机方向感应器，使得可以使用感应器来瞄准射击之类。


参考：

http://blog.csdn.net/lyx2007825/article/details/8792475

http://book.51cto.com/art/201303/382840.htm

http://blog.csdn.net/kesalin/article/details/7168967

http://wenku.baidu.com/view/a584657e168884868762d6a0.html?from=search

http://www.tuicool.com/articles/VZVJra

http://www.tuicool.com/articles/IFZBJn


残诗
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android OpenGL20 setIdentityM,translateM,rotateM,multiplyMV等方法
刘志保的博客
05-24 9082
在opengl中,默认世界坐标系已经定位好了,要绘制图形,给出图形的顶点坐标参数很多情况下是按照世界坐标系设定各自顶点坐标. 比如,下面给出了一个立方体的各自顶点坐标,那么下面是按照世界坐标系给出的数据参数. final float cubePosition[] = { // Front face
映客VR SDK开发文档1
08-08
映客VR SDK开发文档1
OpenGL ES (11): 答疑解惑 -- 矩阵乘法Matrix.multiplyMM();
八步赶蝉
10-14 5001
1.介绍 之前的文章中有将投影矩阵和相机视图变换矩阵结合的一个方法，生成一个新的矩阵mMVPMatrix。 Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0); 看官方文档： public static void multiplyMM (float[] result, int resultOffset,...
google vr 入门之制作简易的VR播放器(二)
github_2011的博客
04-19 4174
本篇博客是《google vr 入门之制作简易的VR播放器及去除界面控制按钮》的续篇： 是对上次创建的GVR播放器的优化与增强,建议先阅读上篇 本篇对播放器设置做了进一步优化： 1.支持手触模式 VR播放器有两种变换观看视频角度的模式: 陀螺仪模式和手触模式,GVR中默认陀螺仪模式一直存在,手触模式有一个开关可以打开或者关闭(默认关闭) mVideoView.setTouchTrack
google vr 入门之制作简易的VR播放器及去除界面控制按钮
github_2011的博客
03-17 7450
创建一个Android项目，对Android studio以及项目的配置有如下的要求： Android Studio, 2.2.2 or higher. Version 25 of the Android SDK. Gradle 23.0.1 or higher. Android Studio will allow you to upgrade if your installed versi
Google VR Android开发（二）-Simplevideowidget分析
段亮的博客（Android系统-VR系统）
07-18 2297
Simplevideowidget这个Demo运行起来的效果如下： 单击视频显示区域可以暂停/继续播放。 点击眼镜按钮可以进入到双眼VR模式： 现在分析下代码实现： 只有一个Activity文件： 主要是显示了一个SDK中的VrVideoView控件 进入VR双眼模式和全屏显示的切换按钮都在这个控件里面。所以要分析下这个控件的实现。 模式切换的实现是在VrVi
基于Pico VR SDK 开发的简单VR场景.zip
最新发布
05-11
VR技术通过模拟人的视觉、听觉、触觉等感觉器官功能，使人能够沉浸在计算机生成的虚拟境界中，并能够通过语言、手势等自然的方式与之进行实时交互，创建了一种适人化的多维信息空间。 VR技术具有以下主要特点： ...
VRAR开发-基于谷歌GVR框架封装的VR视频播放器.zip
04-03
本项目重点介绍了一个基于谷歌(Google)虚拟现实(GVR)框架封装的VR视频播放器的开发过程。谷歌GVR框架为开发者提供了构建高质量VR应用程序的强大工具，它支持Android和iOS平台，兼容各种头戴式显示器(HMDs)，如Google...
openvr：OpenVR SDK
02-26
OpenVR SDK OpenVR是一种API和运行时，它允许从多个供应商访问VR硬件，而无需应用程序具有他们所针对的硬件的特定知识。 该存储库是一个包含API和示例的SDK。 运行时位于Steam上的工具中的SteamVR下。 文献资料 API...
Google已经推出了Google VR SDK，
05-11
VR技术通过模拟人的视觉、听觉、触觉等感觉器官功能，使人能够沉浸在计算机生成的虚拟境界中，并能够通过语言、手势等自然的方式与之进行实时交互，创建了一种适人化的多维信息空间。 VR技术具有以下主要特点： ...
GoogleVRForUnity 1.0.1
12-30
谷歌的vr SDK，用于unity进行VR开发
matrixMultiply
04-01
动态规划之矩阵连乘 public static void matriChain(int []p,int [][]m,int [][]s) { int n=p.length-1; for(int i=1;i<n;i++) m[i][i]=0; for(int r=2;r<=n;r++) for(int i=1;i<=n-r+1;i++){ int j=i+r-1; m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j]; s[i][j]=i; for(int k=i+1;k<j;k++){ int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]; if(t<m[i][j]){ m[i][j]=t; s[i][j]=k;} } } }
Microsoft Platform SDK
11-30
Microsoft Platform SDK.exe 为文档VS2013配置ARToolkit所设工具包
OpenGL ES 2.0 - Matrix. setLookAtM/.frustumM/.multiplyMM
05-12 1242
最近学习了 opengl es， 要显示3D 的效果，主要对坐标系和位置向量有一个概念. Matrix.frustumM 透视投影 target Matrix.setLookAtM 相机位置 camera Matrix.multiplyMM 矩阵合并 result view http://web.mit.edu/ruggles/MacData/afs/sipb/project/android/docs/reference/android/opengl/Matrix.html 在Open...
OpenGL ES之八——GLES20类和Matrix类
gongxiaoou的博客
04-26 6166
概况 上面对于GLSL也有了一定的了解，并且通过之前编程过程，我们基本了解了GLSL语言的特色和通过调用Java语言编写的SDK来完成一些基本操作。下面总结一下GLES20的方法（GLES30或者更高这里就不一一列举了，方法基本和GLES20相同） 一 获取着色器程序内成员变量的id（句柄、指针） GLES20.glGetAttribLocation方法：获取着色器程序中，指定为attribute...
GOOGLE VR SDK开发VR游戏，VR播放器之一
热门推荐
懒人日志
03-24 1万+
最近一年来，VR虚拟现实和AR增强现实技术的宣传甚嚣尘上。其实VR，AR技术很早就有了，一直没有流行开来，不可否认价格是影响技术推广的最大壁垒。谷歌对VR最大的贡献是提供了廉价的谷歌眼镜，按照GOOGLE提供的图纸，使用两个放大镜和一个披萨盒就能轻松DIY出自己的VR眼镜，同一时期谷歌推出来开源的VR SDK，使得开发者可以轻松构建VR游戏和VR播放器，使得几乎所有对这一切感兴趣的公司可以轻松的低
Google VR Views实战（VR全景图播放器）
xiaowenAmy的博客
07-03 2225
Google VR Views实战（VR全景图播放器）
google vr 入门之制作简易的VR播放器(三)
github_2011的博客
04-27 2712
先看一下效果图,如果对google vr有一定了解的朋友,会对这种效果感兴趣的!(将我们的控制界面添加到VR模式中,目前单纯的集成google vr肯定是做不了这种效果的) google vr视频播放共有三种模式,我们可控制的只有第一种模式,其它两种模式我们可以调用api进入这种模式,仅此而已。 三种模式的官网链接 我的前两篇google vr入门博客中使用的就是第一种模式,它不
写给VR手游开发小白的教程：（二）UnityVR插件CardboardSDKForUnity解析（一）
xf__mao的博客
07-16 1万+
现在我们已经有了开发环境，还没安装环境的小伙伴可以看上一篇： （一）Unity3D进行Android开发的环境搭建（虚拟机调试） 今天主要介绍的是谷歌为自己的Cardboard平台提供的开发工具Cardboard SDK插件解析。Cardboard是谷歌公司在14年发布的一款极具创意的产品，由手机内部的传感器支持，它仅需硬纸板和两片透镜就能打造移动平台上的VR体验。Cardboard这里不多做
GoogleVR sdk的使用
04-03
GoogleVR SDK是Google开发的一款虚拟现实软件开发工具包，用于创建VR应用程序。以下是GoogleVR SDK的使用步骤： 1. 下载GoogleVR SDK：从Google开发者网站下载GoogleVR SDK。 2. 导入GoogleVR SDK：将下载的Google...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值