在Android中设置正方形opengl 2.0的扩散、镜面照明

我是OpenGLES2.0的新手。我想为三角形的每个顶点设置不同的颜色

   /*
     * Copyright (C) 2011 The Android Open Source Project
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    package com.example.android.opengl;

    import java.nio.ByteBuffer;
    import java.nio.ByteOrder;
    import java.nio.FloatBuffer;
    import java.nio.ShortBuffer;

    import android.opengl.GLES20;

    /**
     * A two-dimensional square for use as a drawn object in OpenGL ES 2.0.
     */
    public class Square {
        private final String vertexShaderCode =
                // This matrix member variable provides a hook to manipulate
                // the coordinates of the objects that use this vertex shader
                "uniform mat4 uMVPMatrix;" +
                "attribute vec4 vPosition;" +
                "void main() {" +
                // The matrix must be included as a modifier of gl_Position.
                // Note that the uMVPMatrix factor *must be first* in order
                // for the matrix multiplication product to be correct.
                "  gl_Position = uMVPMatrix * vPosition;" +
                "}";

        private final String fragmentShaderCode =
                "precision mediump float;" +
                "uniform vec4 vColor;" +
                "void main() {" +
                "  gl_FragColor = vColor;" +
                "}";

        private final FloatBuffer vertexBuffer;
        private final ShortBuffer drawListBuffer;
        private final int mProgram;
        private int mPositionHandle;
        private int mColorHandle;
        private int mMVPMatrixHandle;

        // number of coordinates per vertex in this array
        static final int COORDS_PER_VERTEX = 3;
        static float squareCoords[] = {
                -0.5f,  0.5f, 0.0f,   // top left
                -0.5f, -0.5f, 0.0f,   // bottom left
                 0.5f, -0.5f, 0.0f,   // bottom right
                 0.5f,  0.5f, 0.0f }; // top right

        private final short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices

        private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex

        float color[] = { 0.2f, 0.709803922f, 0.898039216f, 1.0f,
                1.0f, 0.0f, 0.0f, 1.0f,
                0.0f, 1.0f, 0.0f, 1.0f };

        /**
         * Sets up the drawing object data for use in an OpenGL ES context.
         */
        public Square() {
            // initialize vertex byte buffer for shape coordinates
            ByteBuffer bb = ByteBuffer.allocateDirect(
            // (# of coordinate values * 4 bytes per float)
                    squareCoords.length * 4);
            bb.order(ByteOrder.nativeOrder());
            vertexBuffer = bb.asFloatBuffer();
            vertexBuffer.put(squareCoords);
            vertexBuffer.position(0);

            // initialize byte buffer for the draw list
            ByteBuffer dlb = ByteBuffer.allocateDirect(
                    // (# of coordinate values * 2 bytes per short)
                    drawOrder.length * 2);
            dlb.order(ByteOrder.nativeOrder());
            drawListBuffer = dlb.asShortBuffer();
            drawListBuffer.put(drawOrder);
            drawListBuffer.position(0);

            // prepare shaders and OpenGL program
            int vertexShader = MyGLRenderer.loadShader(
                    GLES20.GL_VERTEX_SHADER,
                    vertexShaderCode);
            int fragmentShader = MyGLRenderer.loadShader(
                    GLES20.GL_FRAGMENT_SHADER,
                    fragmentShaderCode);

            mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
            GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
            GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
            GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables
        }

        /**
         * Encapsulates the OpenGL ES instructions for drawing this shape.
         *
         * @param mvpMatrix - The Model View Project matrix in which to draw
         * this shape.
         */
        public void draw(float[] mvpMatrix) {
            // Add program to OpenGL environment
            GLES20.glUseProgram(mProgram);

            // get handle to vertex shader's vPosition member
            mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");

            // Enable a handle to the triangle vertices
            GLES20.glEnableVertexAttribArray(mPositionHandle);

            // Prepare the triangle coordinate data
            GLES20.glVertexAttribPointer(
                    mPositionHandle, COORDS_PER_VERTEX,
                    GLES20.GL_FLOAT, false,
                    vertexStride, vertexBuffer);

            // get handle to fragment shader's vColor member
            mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");

            // Set color for drawing the triangle
            GLES20.glUniform4fv(mColorHandle, 1, color, 0);

            // get handle to shape's transformation matrix
            mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
            MyGLRenderer.checkGlError("glGetUniformLocation");

            // Apply the projection and view transformation
            GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
            MyGLRenderer.checkGlError("glUniformMatrix4fv");

            // Draw the square
            GLES20.glDrawElements(
                    GLES20.GL_TRIANGLES, drawOrder.length,
                    GLES20.GL_UNSIGNED_SHORT, drawListBuffer);

            // Disable vertex array
            GLES20.glDisableVertexAttribArray(mPositionHandle);
        }

    }

我还有一个问题：我应该为旋转、缩放和变换创建矩阵，还是应该使用

matrix.multiplyMM（scratch，0，mMVPMatrix，0，mRotationMatrix，0）
按原样工作。
如果这是一个关于照明广场的问题，您应该添加您尝试过的内容、出现的问题或您不清楚的部分。在你发布的内容中似乎没有与照明相关的代码。网上有很多关于如何做到这一点的帖子

要为顶点设置不同的颜色，需要在着色器中使用新属性，而不是统一属性。片段着色器应具有
属性vec4 aColor
和
可变vec4颜色然后设置
vColor=aColor在主菜单中。片段着色器还应包含变化的vec4 vColor
取代
统一的vec4彩色。在代码中，您需要执行与位置相同的操作，但使用颜色数组并将其绑定到
aColor

为旋转、缩放和平移创建矩阵取决于您正在执行的操作，但通常情况下，这不是一个好主意。如果您需要这些值的引用，最好将角度、比例和平移数据保留为浮点数和向量，以便在需要时用于构建矩阵。
如果这是一个关于照明正方形的问题，您应该添加您尝试过的内容以及出现的错误或不清楚的部分。在你发布的内容中似乎没有与照明相关的代码。网上有很多关于如何做到这一点的帖子

要为顶点设置不同的颜色，需要在着色器中使用新属性，而不是统一属性。片段着色器应具有
属性vec4 aColor
和
可变vec4颜色然后设置
vColor=aColor在主菜单中。片段着色器还应包含变化的vec4 vColor
取代
统一的vec4彩色。在代码中，您需要执行与位置相同的操作，但使用颜色数组并将其绑定到
aColor

为旋转、缩放和平移创建矩阵取决于您正在执行的操作，但通常情况下，这不是一个好主意。如果需要这些值的引用，最好将角度、比例和平移数据保留为浮点数和向量，以便在需要时用于构造矩阵