OpenGL ES 2.0. Урок 4. Гладкие поверхности. Полигональная сетка.

В этом уроке мы рассмотрим рисование гладких 3D-функций с помощью полигональной сетки.  Пусть наша сетка будет лежать в плоскости XZ, а значение Y будет вычисляться как функция от X и Z, т.е. y=f(x,z). В узлах сетки будут находиться вершины. Обозначим порядковый номер  узла сетки вдоль оси X как i, а вдоль оси Z как j. Номера узлов могут меняться от нуля до imax или jmax соответственно.

Обозначим шаг сетки вдоль оси X как dx, а шаг сетки вдоль оси Z как dz. Тогда мы можем легко вычислить координаты X и Z для всех вершин:

//зададим массивы для хранения координат X и Z

float [] x=new float [imax+1];
float [] z=new float [jmax+1];
//заполним массивы X и Z координатами сетки
for (int i=0; i<=imax; i++){
        x[i]=x0+i*dx; 

 }
for (int j=0; j<=jmax; j++){
        z[j]=z0+j*dz;
}

//где x0 и z0 координаты нулевой точки

Координата Y у нас меняется в зависимости от двух координат других координат X и Z. Поэтому будем хранить ее в двумерном массиве:

float [] [] y=new float [jmax+1][imax+1];

Придумаем какую-нибудь функцию, например функцию "холма с центром в начале координат", и вычислим её для всех вершин:

// заполним массив Y значениями функции
for (int j=0; j<=jmax; j++){
        for (int i=0; i<=imax; i++){
                y[j][i]=(float)Math.exp(-3*(x[i]*x[i]+z[j]*z[j]));
        }
}

Итак, у нас теперь есть все координаты вершин. Теперь нужно переписать их в байтовый буфер, который будет понятен для OpenGL. Двумерный  массив координаты Y в буфер никак загнать не получится. Поэтому мы должны переписать координаты вершин в одномерный массив в последовательности x0, y0, z0,  x1, y1, z1,  x2, y2, z2  и.т.д., а затем его уже переписать в буфер. Создадим такой одномерный массив:

float [] vertex=new float[(jmax+1)*(imax+1)*3];

где (jmax+1)*(imax+1)*3 - это количество координат вершин (каждая вершина имеет три координаты, поэтому умножаем количество вершин на три).

Определимся с правилом хранения координат в этом массиве. Будем хранить вершины последовательно по строчкам как показано на рисунке выше. Т.е. сначала перепишем в массив vertex координаты первой строки, затем второй, третьей и.т.д.

// заполним массив координат vertex
int k=0;
for (int j=0; j<=jmax; j++){
        for (int i=0; i<=imax; i++){
                vertex[k]=x[i];
                k++;
                vertex[k]=y[j][i];
                k++;
                vertex[k]=z[j];
                k++;
       }
}
Теперь создадим буфер для хранения координат вершин и перепишем в него массив vertex:

ByteBuffer vb = ByteBuffer.allocateDirect((jmax+1)*(imax+1)*3*4);
vb.order(ByteOrder.nativeOrder());
vertexBuffer = vb.asFloatBuffer();
vertexBuffer.position(0);

vertexBuffer.put(vertex);
vertexBuffer.position(0);

В перспективе наша функция Y будет изменяться с течением времени и картинка будет двигаться , поэтому удобно оформить ее расчет в виде метода:
private void getVertex(){
        // заполним массив Y значениями функции
        for (int j=0; j<=jmax; j++){
                for (int i=0; i<=imax; i++){

                        y[j][i]=(float)Math.exp(-3*(x[i]*x[i]+z[j]*z[j]));

                }

        }
        // заполним массив координат vertex
        int k=0;
        for (int j=0; j<=jmax; j++){
                for (int i=0; i<=imax; i++){

                        vertex[k]=x[i];

                        k++;

                        vertex[k]=y[j][i];

                        k++;

                        vertex[k]=z[j];

                        k++;

                }

        }
        //перепишем координаты вершин из массива vertex в буфер
        vertexBuffer.put(vertex);
        vertexBuffer.position(0);
}

Расчет нормалей.

Для того чтобы использовать освещение нам нужно вычислить нормаль для каждой  вершины сетки. Напомню, что вектор нормали - это вектор единичной длины, перпендикулярный к поверхности в данной точке этой поверхности и направленный от обратной стороны поверхности к лицевой стороне. Чтобы нарисовать поверхность, нам потребуется ее разбить на множество треугольников. Лицевой стороной треугольника является сторона, которая при рисовании обходится по вершинам против часовой стрелки:

Нормаль к плоскости может быть вычислена как векторное произведение двух векторов A и B, лежащих в данной плоскости:

Как видно из рисунка направление нормали определяется по правилу правого винта при переходе от вектора A к вектору B. При переходе против часовой стрелки нормаль направлена вверх, при переходе по часовой стрелке - вниз. Направление "вверх" у нас совпадает с направление оси Y.  В математическом виде компоненты векторного произведения записываются так:

normalX=ay*bz-by*az

normalY=bx*az-ax*bz

normalZ=ax*by-bx*ay

где ax, ay, az - координаты вектора A

bx, by, bz - координаты вектора B

Чтобы вычислить нормаль для конкретной вершины сетки, нам нужно определить для нее векторы A и B. Возьмем вершину с индексами [j] [i] и достроим от нее два вектора - вниз на один шаг - вектор A и вправо один шаг - вектор B:

Зададим для хранения координат векторов нормалей три массива:

float [] normalX=new float[jmax+1][imax+1];
float [] normalY=new float[jmax+1][imax+1];
float [] normalZ=new float[jmax+1][imax+1];

Теперь мы можем вычислить нормаль для вершины [j] [i]:

ax = 0
ay = y [j+1] [i] -y [j] [i]
az = z [j+1] - z [j] = dz    шаг сетки по оси Z
bx = x [i+1] - x [i] = dx   шаг сетки по оси X
by = y [j] [i+1] - y [j] [i]
bz=0

normalX [j] [i] = ay*bz-by*az = - by*az = - ( y [j] [i+1] - y [j] [i] ) * dz
normalY [j] [i] = bx*az-ax*bz =   bx*az = dx * dz
normalZ [j] [i] = ax*by-bx*ay = - bx*ay = - dx * ( y [j+1] [i] - y [j] [i] )

По этим формулам мы можем вычислить нормали в диапазоне номеров i от 0 до (imax-1)  и j от 0 до (jmax-1). Отдельно нужно рассчитать нормали для крайнего правого столбца (i=imax) и крайней нижней строки (j=jmax), а также для правого нижнего угла (i=imax, j=jmax). Для расчета нормалей нужно правильно подобрать векторы A и B:

Расчет вектора нормали для вершин с индексами [ j ] [ imax ] в крайнем правом столбце:

ax = x [ imax -1] - x [imax] = - dx
ay = y [ j ] [ imax -1] - y [ j ] [ imax]
az = 0   
bx = 0   
by = y [ j+1 ] [ imax] - y [ j ] [ imax ]
bz = z [ j+1] - z [ j ] = dz 

normalX [j] [imax] = ay*bz-by*az = ay*bz = ( y [ j ] [ imax -1] - y [ j ] [ imax] ) * dz
normalY [j] [imax] = bx*az-ax*bz =  - ax*bz = dx  * dz
normalZ [j] [imax] = ax*by-bx*ay = ax*by = - dx * ( y [ j+1 ] [ imax] - y [ j ] [ imax ] )

Расчет вектора нормали для вершин с индексами [ jmax ] [ i ] в крайней нижней строке:
ax =  x [ i+1 ] - x [ i ] = dx

ay =  y [ jmax ] [ i+1 ] - y [ jmax ] [ i ]
az =  0 
bx =  0 
by = y [ jmax-1 ] [ i ] - y [ jmax ] [ i ]
bz = z [ jmax -1] - z [ jmax ] = - dz 

normalX [jmax] [ i ] = ay*bz-by*az = ay*bz = - ( y [ jmax ] [ i+1 ] - y [ jmax ] [ i ] ) * dz
normalY [jmax] [ i ] = bx*az-ax*bz = -ax*bz =  dx * dz
normalZ [jmax] [ i ] = ax*by-bx*ay = ax*by = dx * ( y [ jmax-1 ] [ i ] - y [ jmax ] [ i ] )

Расчет вектора нормали для правого нижнего угла [ jmax ] [ imax ]:
ax =  0 

ay =  y [ jmax-1 ] [ imax ] - y [ jmax ] [ imax ]
az =  z [ jmax -1 ] - z [ jmax ] = - dz
bx =  x [ imax -1 ] - x [ imax ] = - dx
by = y [ jmax ] [ imax -1 ] - y [ jmax ] [ imax ]
bz = 0 

normalX [jmax] [ imax ]=ay*bz-by*az =-by*az =(y [ jmax] [ imax-1] - y [ jmax] [imax]) * dz
normalY [jmax] [ imax ] = bx*az-ax*bz =  bx*az = dx * dz
normalZ [jmax] [  imax ] =ax*by-bx*ay = -bx*ay=dx * (y [jmax-1] [imax] - y[jmax ] [imax])

По аналогии с координатами вершин мы должны переписать координаты нормалей последовательно в одномерный массив и отправить его в байтовый буфер:
float [] normal=new float [(jmax+1)*(imax+1)*3];

ByteBuffer nb = ByteBuffer.allocateDirect((jmax+1)*(imax+1)*3*4);
nb.order(ByteOrder.nativeOrder());
normalBuffer = nb.asFloatBuffer();
normalBuffer.position(0);

int k=0;
for (int j=0; j<=jmax; j++){
        for (int i=0; i<=imax; i++){
                normal[k]=normalX[j][i];
                k++;
                normal[k]=normalY[j][i];
                k++;
                normal[k]=normalZ[j][i];
                k++;
        }
}
normalBuffer.put(normal);
normalBuffer.position(0);

Итак, мы научились по координатам вершин в сетки вычислять вектор нормали для каждой вершины. Оформим расчет нормалей в виде метода:
private void getNormal(){
        for (int j=0; j<jmax; j++){
                for (int i=0; i<imax; i++){

                        normalX [j] [i] = - ( y [j] [i+1] - y [j] [i] ) * dz;

                        normalY [j] [i] = dx * dz;

                        normalZ [j] [i] = - dx * ( y [j+1] [i] - y [j] [i] );

                }

        }
        //нормаль для i=imax
        for (int j=0; j<jmax; j++){
                normalX [j] [imax] = ( y [ j ] [ imax -1] - y [ j ] [ imax] ) * dz;

                normalY [j] [imax] = dx * dz;

                normalZ [j] [imax] = - dx * ( y [ j+1 ] [ imax] - y [ j ] [ imax ] );

        }
        //нормаль для j=jmax
        for (int i=0; i<imax; i++){
                normalX [jmax] [ i ] = - ( y [ jmax ] [ i+1 ] - y [ jmax ] [ i ] ) * dz;

                normalY [jmax] [ i ] = dx * dz;

                normalZ [jmax] [ i ] = dx * ( y [ jmax-1 ] [ i ] - y [ jmax ] [ i ] );

        }
        //нормаль для i=imax и j=jmax
        normalX [jmax] [ imax ]= (y [ jmax] [ imax-1] - y [ jmax] [imax]) * dz;
        normalY [jmax] [ imax ] = dx * dz;
        normalZ [jmax] [ imax ] = dx * (y [jmax-1] [imax] - y[jmax ] [imax]);

        //переписываем координаты вектора нормали в одномерный массив normal

        int k=0;
        for (int j=0; j<=jmax; j++){
                for (int i=0; i<=imax; i++){
                        normal[k]=normalX[j][i];
                        k++;
                        normal[k]=normalY[j][i];
                        k++;
                        normal[k]=normalZ[j][i];
                        k++;
                }
        }
        //отправляем одномерный массив normal в буфер 
        normalBuffer.put(normal);
        normalBuffer.position(0); 
} // конец метода

Мы не будем нормализовать нормали на CPU, поручим нормализацию шейдерам. 

Разбиваем сетку на треугольники и рисуем поверхность.

Далее мы будем рисовать нашу поверхность в одном проходе, т.е. с использованием одной команды glDrawElements и правила обхода вершин GL_TRIANGLE_STRIP. Разобьем нашу сетку на ленты из треугольников. В нашем примере сначала идет лента слева-направо и вершины передаются в OpenGL в следующем порядке  0,5,1,6,2,7,3,8,4,9. Правило GL_TRIANGLE_STRIP автоматически создает ряд треугольников 0-5-1, 1-5-6, 1-6-2, 2-6-7, 2-7-3, 3-7-8, 3-8-4, 4-8-9. Порядок перечисления вершин выбран так, чтобы обход выполнялся против часовой стрелки и верхняя сторона сетки считалась лицевой.

Дойдя до 9-ой вершины мы переходим к ленте справа-налево :

 Нам удобно перечислять вершины в таком же порядке 9,14, 8,13, 7,12, т.е. сверху-вниз. Однако при этом топология правила GL_TRIANGLE_STRIP нарушится и обход будет выполняться по часовой стрелке. Для того чтобы склеить две ленты я продублировал 9-ю вершину между лентами и мысленно продолжил ряд. На рисунке добавленная вершина отмечена красным цветом:

Теперь порядок перечисления вершин будет такой:
 0,5,1,6,2,7,3,8,4,9, 9,  9,14,8,13,7,12,6,11,5,10, 10,  10,15,11,16,12,17,13,18,14,19
Красным цветом отмечены добавленные вершины.

Таким образом, чтобы сделать единую цепь вершин для правила GL_TRIANGLE_STRIP нужно дублировать последнюю вершину в каждой ленте. Порядок перечисления вершин называют массивом индексов и передают OpenGL в виде буфера. Создадим такой массив:

// временный массив индексов
short[] index;
// 2*(imax+1) - количество индексов в ленте
// jmax - количество лент
// (jmax-1) - добавленные индексы для связки лент
// размер индексного массива
sizeindex=2*(imax+1)*jmax + (jmax-1);
index = new short[sizeindex];

Для того, чтобы получить порядковый номер вершины по известным номерам i и j введем дополнительную функцию chain: 

private short chain(int j, int i){
        return (short) (i+j*(imax+1));

}
Например, для i=3, j=2 функция chain возвратит 13, т.к. в нашем примере imax=4.
Приступим к расчету массива индексов:
int k=0;
int j=0;
while (j < jmax) {
        // лента слева направо
        for (int i = 0; i <= imax; i++) {
                index[k] = chain(j,i);
                k++;
                index[k] = chain(j+1,i);
                k++;
        }
        if (j < jmax-1){
                // вставим хвостовой индекс для связки
                index[k] = chain(j+1,imax);
                k++;
        }
        // переводим ряд
        j++;

        // проверяем достижение конца
        if (j < jmax){
                // лента справа налево
                for (int i = imax; i >= 0; i--) {
                        index[k] = chain(j,i);
                        k++;
                        index[k] = chain(j+1,i);
                        k++;
                }
               if (j < jmax-1){
                        // вставим хвостовой индекс для связки
                        index[k] = chain(j+1,0);
                        k++;
                }
                // переводим ряд
                j++;
        }
}

// буфер индексов - тип short содержит 2 байта
ByteBuffer bi = ByteBuffer.allocateDirect(sizeindex * 2);
bi.order(ByteOrder.nativeOrder());
indexBuffer = bi.asShortBuffer();
// заполняем буфер индексов
indexBuffer.put(index);
indexBuffer.position(0);
// уничтожаем временный массив индексов,
// т.к. в дальнейшем нужен только буфер индексов
index = null;

Для того, чтобы нарисовать нашу поверхность достаточно вызвать команду:
GLES20.glDrawElements(GLES20.GL_TRIANGLE_STRIP, sizeindex,
                                 GLES20.GL_UNSIGNED_SHORT, indexBuffer);

Полный код класса рендерера, рисующего поверхность.

Для примера приведу полный код класса MyClassRenderer, который создает  сетку размером 50x50 и рисует холм.

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import android.content.Context;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;

public class MyClassRenderer implements GLSurfaceView.Renderer{
// интерфейс GLSurfaceView.Renderer содержит
// три метода onDrawFrame, onSurfaceChanged, onSurfaceCreated
// которые должны быть переопределены
// текущий контекст
private Context context;
//координаты камеры
private float xСamera, yCamera, zCamera;
//координаты источника света
private float xLightPosition, yLightPosition, zLightPosition;
//матрицы
private float[] modelMatrix;
private float[] viewMatrix;
private float[] modelViewMatrix;
private float[] projectionMatrix;
private float[] modelViewProjectionMatrix;
//размеры сетки
private int imax=49;
private int jmax=49;
//размер индексного массива
private int sizeindex;
//начальная координата x
private float x0=-1f;
//начальная координата z
private float z0=-1f;
//шаг сетки по оси x
private float dx=0.04f;
//шаг сетки по оси z
private float dz=0.04f;
// массив для хранения координаты x
private float [] x;
// массив для хранения координаты y
private float [][] y;
//массив для хранения координаты z
private float [] z;
//массив для хранения координат вершин для записи в буфер
private float [] vertex;
//массивы для хранения координат вектора нормали
private float [][] normalX;
private float [][] normalY;
private float [][] normalZ;
//массив для хранения координат вектора нормали для записи в буфер
private float [] normal;
//буферы для координат вершин и нормалей
private FloatBuffer vertexBuffer, normalBuffer;
//буфер индексов
private ShortBuffer indexBuffer;
//шейдерный объект
private Shader mShader;
//------------------------------------------------------------------------------------------
//конструктор
public MyClassRenderer(Context context) {
         // запомним контекст

         // он нам понадобится в будущем для загрузки текстур
         this.context=context;
         //координаты точечного источника света
         xLightPosition=5f;
         yLightPosition=5f;
         zLightPosition=5f;
         //матрицы
         modelMatrix=new float[16];
         viewMatrix=new float[16];
         modelViewMatrix=new float[16];
         projectionMatrix=new float[16];
         modelViewProjectionMatrix=new float[16];
         //мы не будем двигать объекты

         //поэтому сбрасываем модельную матрицу на единичную
         Matrix.setIdentityM(modelMatrix, 0);
         //координаты камеры
         xСamera=0.3f;
         yCamera=1.7f;
         zCamera=1.5f;
         //пусть камера смотрит на начало координат

         //и верх у камеры будет вдоль оси Y

         //зная координаты камеры получаем матрицу вида
         Matrix.setLookAtM(viewMatrix, 0, xСamera, yCamera, zCamera, 0, 0, 0, 0, 1, 0);
         // умножая матрицу вида на матрицу модели

         // получаем матрицу модели-вида
         Matrix.multiplyMM(modelViewMatrix, 0, viewMatrix, 0, modelMatrix, 0);
         // создаем массивы
         x=new float [imax+1];
         z=new float [jmax+1];
         y=new float [jmax+1][imax+1];
         vertex=new float[(jmax+1)*(imax+1)*3];
         normalX=new float[jmax+1][imax+1];
         normalY=new float[jmax+1][imax+1];
         normalZ=new float[jmax+1][imax+1];
         normal=new float[(jmax+1)*(imax+1)*3];
         //заполним массивы x и z координатами сетки
         for (int i=0; i<=imax; i++){
                  x[i]=x0+i*dx; 

         }
         for (int j=0; j<=jmax; j++){
                  z[j]=z0+j*dz; 

         }
         //создадим буфер для хранения координат вершин

         // он заполняется в методе getVertex()
         ByteBuffer vb = ByteBuffer.allocateDirect((jmax+1)*(imax+1)*3*4);
         vb.order(ByteOrder.nativeOrder());
         vertexBuffer = vb.asFloatBuffer();
         vertexBuffer.position(0);
         //создадим буфер для хранения координат векторов нормалей

         // он заполняется в методе getNormal()
         ByteBuffer nb = ByteBuffer.allocateDirect((jmax+1)*(imax+1)*3*4);
         nb.order(ByteOrder.nativeOrder());
         normalBuffer = nb.asFloatBuffer();
         normalBuffer.position(0);
         //индексы

         // временный массив индексов
         short[] index;

         // 2*(imax+1) - количество индексов в ленте

         // jmax - количество лент

         // (jmax-1) - добавленные индексы для связки лент
         sizeindex=2*(imax+1)*jmax + (jmax-1);
         index = new short[sizeindex];
         // расчет массива индексов для буфера
         int k=0;
         int j=0;
         while (j < jmax) {
                  // лента слева направо

                  for (int i = 0; i <= imax; i++) {

                           index[k] = chain(j,i);

                           k++;

                           index[k] = chain(j+1,i);

                           k++; 

                  }

                  if (j < jmax-1){

                           // вставим хвостовой индекс для связки

                           index[k] = chain(j+1,imax);

                           k++;

                  }

                  // переводим ряд

                  j++;

                  // проверяем достижение конца

                  if (j < jmax){

                           // лента справа налево

                           for (int i = imax; i >= 0; i--) {

                                    index[k] = chain(j,i);

                                    k++;

                                    index[k] = chain(j+1,i);

                                    k++; 

                           }

                           if (j < jmax-1){

                                    // вставим хвостовой индекс для связки

                                    index[k] = chain(j+1,0);

                                    k++;

                           }

                           // переводим ряд

                           j++;

                  }

         }
         // буфер индексов - тип short содержит 2 байта
         ByteBuffer bi = ByteBuffer.allocateDirect(sizeindex * 2);
         bi.order(ByteOrder.nativeOrder());
         indexBuffer = bi.asShortBuffer();
         // заполняем буфер индексов
         indexBuffer.put(index);
         indexBuffer.position(0);
         // уничтожаем временный массив индексов,

         // т.к. в дальнейшем нужен только буфер индексов
         index = null;
         //начальное заполнение буферов вершин и нормалей
         getVertex();
         getNormal();
}//конец конструктора
//------------------------------------------------------------------------------------------
// вспомогательная функция
// возвращает порядковый номер вершины по известным j и i
private short chain(int j, int i){
         return (short) (i+j*(imax+1));
}
//------------------------------------------------------------------------------------------
//метод выполняет расчет координат вершин
private void getVertex(){
         // заполним массив Y значениями функции
         for (int j=0; j<=jmax; j++){
                  for (int i=0; i<=imax; i++){

                           y[j][i]=(float)Math.exp(-3*(x[i]*x[i]+z[j]*z[j]));

                  }

         }
         // заполним массив координат vertex
         int k=0;
         for (int j=0; j<=jmax; j++){
                  for (int i=0; i<=imax; i++){

                           vertex[k]=x[i];

                           k++;

                           vertex[k]=y[j][i];

                           k++;

                           vertex[k]=z[j];

                           k++;

                  }

         }
         //перепишем координаты вершин из массива vertex в буфер координат вершин
         vertexBuffer.put(vertex);
         vertexBuffer.position(0);
}//конец метода
//------------------------------------------------------------------------------------------
//метод выполняет расчет векторов нормалей
//по известным координатам вершин
private void getNormal(){
         for (int j=0; j<jmax; j++){
                  for (int i=0; i<imax; i++){

                           normalX [j] [i] = - ( y [j] [i+1] - y [j] [i] ) * dz;

                           normalY [j] [i] = dx * dz;

                           normalZ [j] [i] = - dx * ( y [j+1] [i] - y [j] [i] );

                  }

         }
         //нормаль для i=imax
         for (int j=0; j<jmax; j++){
                  normalX [j] [imax] = ( y [ j ] [ imax -1] - y [ j ] [ imax] ) * dz;

                  normalY [j] [imax] = dx * dz;

                  normalZ [j] [imax] = - dx * ( y [ j+1 ] [ imax] - y [ j ] [ imax ] );

         }
         //нормаль для j=jmax
         for (int i=0; i<imax; i++){
                  normalX [jmax] [ i ] = - ( y [ jmax ] [ i+1 ] - y [ jmax ] [ i ] ) * dz;

                  normalY [jmax] [ i ] = dx * dz;

                  normalZ [jmax] [ i ] = dx * ( y [ jmax-1 ] [ i ] - y [ jmax ] [ i ] );

         }
         //нормаль для i=imax и j=jmax
         normalX [jmax] [ imax ]= (y [ jmax] [ imax-1] - y [ jmax] [imax]) * dz;
         normalY [jmax] [ imax ] = dx * dz;
         normalZ [jmax] [ imax ] = dx * (y [jmax-1] [imax] - y[jmax ] [imax]);
         //переписываем координаты вектора нормали в одномерный массив normal
         int k=0;
         for (int j=0; j<=jmax; j++){
                  for (int i=0; i<=imax; i++){

                           normal[k]=normalX[j][i];

                           k++;

                           normal[k]=normalY[j][i];

                           k++;

                           normal[k]=normalZ[j][i];

                           k++;

                  }

         }
         //отправляем одномерный массив normal в буфер
         normalBuffer.put(normal);
         normalBuffer.position(0);
} // конец метода
//------------------------------------------------------------------------------------------
//метод, который срабатывает при изменении размеров экрана
//в нем мы получим матрицу проекции и матрицу модели-вида-проекции
public void onSurfaceChanged(GL10 unused, int width, int height) {
         // устанавливаем glViewport
         GLES20.glViewport(0, 0, width, height);
         float ratio = (float) width / height;
         float k=0.055f;
         float left = -k*ratio;
         float right = k*ratio;
         float bottom = -k;
         float top = k;
         float near = 0.1f;
         float far = 10.0f;
         // получаем матрицу проекции
         Matrix.frustumM(projectionMatrix, 0, left, right, bottom, top, near, far);
         // матрица проекции изменилась,

         // поэтому нужно пересчитать матрицу модели-вида-проекции
         Matrix.multiplyMM( modelViewProjectionMatrix, 0, projectionMatrix, 0, modelViewMatrix, 0);
} //конец метода
//------------------------------------------------------------------------------------------
//метод, который срабатывает при создании экрана
//здесь мы создаем шейдерный объект
public void onSurfaceCreated(GL10 unused, EGLConfig config) {
         //включаем тест глубины
         GLES20.glEnable(GLES20.GL_DEPTH_TEST);
         //включаем отсечение невидимых граней
         GLES20.glEnable(GLES20.GL_CULL_FACE);
         //включаем сглаживание текстур, это пригодится в будущем
         GLES20.glHint(GLES20.GL_GENERATE_MIPMAP_HINT, GLES20.GL_NICEST);
         //простые шейдеры для освещения
         String vertexShaderCode=
         "uniform mat4 u_modelViewProjectionMatrix;"+

         "attribute vec3 a_vertex;"+

         "attribute vec3 a_normal;"+

         "varying vec3 v_vertex;"+

         "varying vec3 v_normal;"+

          "void main() {"+

                   "v_vertex=a_vertex;"+

                   "vec3 n_normal=normalize(a_normal);"+

                   "v_normal=n_normal;"+

                   "gl_Position = u_modelViewProjectionMatrix * vec4(a_vertex,1.0);"+

          "}"; 

         String fragmentShaderCode=
         "precision mediump float;"+

         "uniform vec3 u_camera;"+

         "uniform vec3 u_lightPosition;"+

          "varying vec3 v_vertex;"+

          "varying vec3 v_normal;"+

          "void main() {"+

                "vec3 n_normal=normalize(v_normal);"+

                 "vec3 lightvector = normalize(u_lightPosition - v_vertex);"+

                "vec3 lookvector = normalize(u_camera - v_vertex);"+

                "float ambient=0.1;"+

                "float k_diffuse=0.7;"+

                "float k_specular=0.3;"+

                "float diffuse = k_diffuse * max(dot(n_normal, lightvector), 0.0);"+

                "vec3 reflectvector = reflect(-lightvector, n_normal);"+

                "float specular=k_specular*pow( max(dot(lookvector,reflectvector),0.0),40.0);"+

                "vec4 one=vec4(1.0,1.0,1.0,1.0);"+

                "vec4 lightColor=(ambient+diffuse+specular)*one;"+ 

                "gl_FragColor=lightColor;"+

          "}";

         //создадим шейдерный объект
         mShader=new Shader(vertexShaderCode, fragmentShaderCode);
         //свяжем буфер вершин с атрибутом a_vertex в вершинном шейдере
         mShader.linkVertexBuffer(vertexBuffer);
         //свяжем буфер нормалей с атрибутом a_normal в вершинном шейдере
         mShader.linkNormalBuffer(normalBuffer);
         //связь атрибутов с буферами сохраняется до тех пор,

         //пока не будет уничтожен шейдерный объект
}//конец метода
//------------------------------------------------------------------------------------------
//метод, в котором выполняется рисование кадра
public void onDrawFrame(GL10 unused) {          //передаем в шейдерный объект матрицу модели-вида-проекции
         mShader.linkModelViewProjectionMatrix(modelViewProjectionMatrix);
         //передаем в шейдерный объект координаты камеры
         mShader.linkCamera(xСamera, yCamera, zCamera);
         //передаем в шейдерный объект координаты источника света
         mShader.linkLightSource(xLightPosition, yLightPosition, zLightPosition);
         //вычисляем координаты вершин
         getVertex();
         //вычисляем координаты нормалей
         getNormal();
         //очищаем кадр
         GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT
                                  | GLES20.GL_DEPTH_BUFFER_BIT);
         //рисуем поверхность
         GLES20.glDrawElements(GLES20.GL_TRIANGLE_STRIP, sizeindex,
                           GLES20.GL_UNSIGNED_SHORT, indexBuffer); 
}//конец метода
//------------------------------------------------------------------------------------------
}//конец класса
//------------------------------------------------------------------------------------------
Запустим код на исполнение и получим следующую картинку:

Теперь заставим изображение двигаться. Изобразим волну и заставим ее двигаться. Поднимем вверх источник света, чтобы на волне не было очень темных областей:

xLightPosition=5f;
yLightPosition=30f;
zLightPosition=5f;
и в методе getVertex заменим вычисление функции Y:

// определим фактор времени

double time=System.currentTimeMillis();
// заполним массив Y значениями функции
for (int j=0; j<=jmax; j++){
         for (int i=0; i<=imax; i++){
                  y[j][i]=0.2f*(float)Math.cos(0.005*time+5*(z[j]+x[i]));
         }
}
По экрану побежит волна:

Полный код урока можно скачать отсюда PolygonCell.zip
Если непонятно, что такое класс Shader и его методы читайте первый урок http://andmonahov.blogspot.ru/2012/10/opengl-es-20-1.html