OpenGL ES 1. Текстурирование на примере

В данном примере показано как создать текстурированный многогранник в Android OpenGL ES на примере пирамид. Применен объектно-ориентированный подход. Пирамида разбита на отдельные самостоятельные объекты (полигоны) - треугольники и прямоугольник, внутри которых содержатся собственные свойства полигонов - координаты вершин и текстур, а также определен метод позволяющий вращать полигоны в пространстве.

Используемые классы:

· Texture - класс текстуры. При создании объекта данного класса в память загружется графический файл, соответствующий данной текстуре, а также присваивается уникальное имя для обращения к текстуре. Таким образом, текстура однозначно связывается с картинкой.

· Triangle - класс треугольника. Знает координаты своих вершин и координаты текстур, присвоенных вершинам. При помощи метода rotate можно поворачивать треугольник вокруг любой оси. При этом собственные координаты вершин будут меняться. К треугольнику можно привязать текстуру методом setTextureName, а также отвязать её если сделать имя текстуры равной нулю. Для правильной сортировки полигонов при рисовании полупрозрачной пирамиды  в треугольник встроены координаты центра, которые также изменяются  при вращении треугольника. Содержит метод draw, рисующий треугольник на экране.

· Quadr - прямоугольник для дна пирамиды. Описывается аналогично треугольнику. При создании прямоугольника задаются координаты трёх вершин, а четвертая рассчитывается автоматически как сумма двух векторов образованных тремя вершинами, т.к. все четыре вершины должны лежать в одной плоскости.

· Pyramid - пирамида, собранная из четырех треугольников и одного прямоугольника. Все пять полигонов жестко связаны по координатам вершин. Определены методы вращающие пирамиду относительно осей, соединяющих её центр и вершины. Каждая грань пирамиды может быть залита отдельной текстурой, а также текстура может быть общей для всех граней пирамиды. Для этого перегружен метод setTextureName.

------------------------------------------------------------------------------------------------------------
Перейдем от теории к практике. Создадим класс Texture, описывающий двумерную текстуру
------------------------------------------------------------------------------------------------------------
package com.blogspot.andmonahov.pyramid;
import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.opengles.GL11;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLUtils;
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Texture{
            private int name; // поле для хранения имени текстуры
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // конструктор   
            public Texture(GL10 gl, Context context, int idpicture){
                        int[] names=new int[1];
                        // генерирует массив свободных имен текстур,
                        // состоящий из одного элемента
                        gl.glGenTextures(1, names, 0);
                        // запомним имя текстуры
                        name=names[0];
                        // имя текстуры - это ее уникальный номер,
                        // по которому можно к ней обращаться
                        // имя текстуры будем хранить в поле name
                        // для получения имени из других классов 
                        //позже напишем метод getName
                        //
                        // установим выравнивание
                        gl.glPixelStorei(GL10.GL_UNPACK_ALIGNMENT,1);

                        // команда glBindTexture устанавливает текстуру с номером name
                        // в качестве текущей активной текстуры
                        gl.glBindTexture(GL10.GL_TEXTURE_2D, name);
                        // в дальнейшем все настройки действуют 
                        // на текущую активную текстуру
                        // устанавливаем параметры текстуры
                        // включаем автоматическую генерацию мип-мапов всех уровней
                        gl.glTexParameterx(GL11.GL_TEXTURE_2D,
                                    GL11.GL_GENERATE_MIPMAP, GL11.GL_TRUE);
                        // устанавливаем фильтры
                        gl.glTexParameterf(GL10.GL_TEXTURE_2D, 
                                    GL10.GL_TEXTURE_MIN_FILTER, 
                                     GL10.GL_LINEAR_MIPMAP_LINEAR);
                        gl.glTexParameterf(GL10.GL_TEXTURE_2D,
                                    GL10.GL_TEXTURE_MAG_FILTER,
                                    GL10.GL_LINEAR);
                        // если текстура не полностью закрывает рисуемый полигон 
                        // устанавливаем режим повтора рисунка текстуры
                        gl.glTexParameterx(GL10.GL_TEXTURE_2D,
                                    GL10.GL_TEXTURE_WRAP_S, GL10.GL_REPEAT);
                        gl.glTexParameterx(GL10.GL_TEXTURE_2D,
                                    GL10.GL_TEXTURE_WRAP_T,
                                    GL10.GL_REPEAT);
                        //загружаем картинку с идентификаторм idpicture
                        // idpicture - это уникальный номер картинки в R.java
                        Bitmap bitmap = BitmapFactory.decodeResource
                                                (context.getResources(),idpicture);
                        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
                        // удаляем картину из памяти
                        bitmap.recycle();
                        // т.о. текущая текстура с именем name связана с картинкой idpicture
            }
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // метод возвращает имя текстуры
            public int getName(){
                        return name;
             }
            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

------------------------------------------------------------------------------------------------------------ 

В нашем примере будем рисовать текстурированную пирамиду, поэтому нам понадобятся два класса треугольник для боковых граней пирамиды и прямоугольник для основания. Создадим класс Triangle, описывающий треугольник:

------------------------------------------------------------------------------------------------------------ 

package com.blogspot.andmonahov.pyramid;

import java.nio.*;

import javax.microedition.khronos.opengles.GL10;

import android.opengl.Matrix;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class Triangle {
            // определение полей класса   

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

            private float x1,y1,z1;

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

            private float x2,y2,z2;

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

            private float x3,y3,z3;
            // координаты вектора нормали
            // т.к. три точки треугольника всегда лежат

            // в одной плоскости достаточно задать координаты 
            // одного вектора нормали для всех трех точек
            private float nx,ny,nz;
            // координаты центра треугольника
            // они будут нам нужны в дальнейшем для сортировки треугольников
            // по расстоянию до камеры
            private float xcenter,ycenter,zcenter; 
            // OpenGl не принимает координаты в виде чисел float
            // Внешние данные должны быть переданы в OpenGL в байтовых буферах
            // поэтому определим три буфера 
            // буфер координат вершин 
            private FloatBuffer vertexBuffer;
            // буфер вектора нормали
            private FloatBuffer normalBuffer;
            // буфер координат текстур
            private FloatBuffer texcoordBuffer; 
            // треугольник может быть заполнен какой либо текстурой
            // поэтому создадим поле для хранения имени текстуры
            //внутри класса треугольника
            private int textureName;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// конструктор

public Triangle(float x1, float y1, float z1, float x2, 
            float y2, float z2, float x3, float y3, float z3){
            // треугольник однозначно описывается тремя точками

            // поэтому в момент его создания в конструктор должны
            //быть переданы координаты точек

            // порядок точек 1,2,3 должен соответствовать обходу треугольника 

            // против часовой стрелки 

            // присваиваем координаты точкам

            this.x1=x1;

            this.y1=y1;

            this.z1=z1;

            this.x2=x2;

            this.y2=y2;

            this.z2=z2;

            this.x3=x3;

            this.y3=y3;

            this.z3=z3;

            // подготавливаем буфер вершин

            // каждая вершина треугольника содержит три коодинаты x,y,z типа float

            // каждая координата типа float занимает 4 байта, итого 12 байт на вершину

            // три вершины используют 3*12=36 байт 

            ByteBuffer b1 = ByteBuffer.allocateDirect(36);

            b1.order(ByteOrder.nativeOrder());

            vertexBuffer = b1.asFloatBuffer();

            // подготавливаем буфер нормалей

            ByteBuffer b2 = ByteBuffer.allocateDirect(36);

            b2.order(ByteOrder.nativeOrder());
            normalBuffer = b2.asFloatBuffer();

            // пересчет нормалей и центра, заполнение буферов координат и нормалей

            recount(); //этот метод описан ниже

            // подготавливаем буфер координат текстур

            // каждой вершине треугольника присвоены две координаты текстур s и t

            // каждая координата занимает 4 байта как число типа float

            // итого 8 байт на вершину, 24 байта не треугольник

            ByteBuffer b4 = ByteBuffer.allocateDirect(24);

            b4.order(ByteOrder.nativeOrder());

            texcoordBuffer = b4.asFloatBuffer();

            // заполняем буфер текстур 

            // выполняем обход вершин против часовой стрелки

            // текстурные координаты верхней точки

            texcoordBuffer.put(0.5f); // s 

            texcoordBuffer.put(1); // t

            // текстурные коодинаты левой нижней точки

            texcoordBuffer.put(0); // s

            texcoordBuffer.put(0); // t

            // текстурные координаты правой нижней точки

            texcoordBuffer.put(1); // s

            texcoordBuffer.put(0); // t

            // установим текущую позицию буфера на его начало

            texcoordBuffer.position(0);

            // при создании треугольника ему еще не присвоена текстура

            // поэтому ставим

            textureName = 0;

            // присвоить имя текстуры можно через метод setTextureName

}  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// описание методов класса

// при изменении координат вершин треугольника

// изменяются координаты вектора нормали и координаты центра

// поэтому создадим метод который будет их пересчитывать

// и заполнять буферы новыми координатами

private void recount(){  

            //заполняем буфер вершин значением координат точек

            vertexBuffer.position(0);

            // для вершины 1

            vertexBuffer.put(x1); 

            vertexBuffer.put(y1);

            vertexBuffer.put(z1); 

            // для вершины 2

            vertexBuffer.put(x2);

            vertexBuffer.put(y2);

            vertexBuffer.put(z2);

            // для вершины 3

            vertexBuffer.put(x3);

            vertexBuffer.put(y3);

            vertexBuffer.put(z3);

            vertexBuffer.position(0);

            // нормаль может быть получена путем векторного произведения

            // двух векторов - из точки 1 в точку 2 и из точки 2 в точку 3 

            float dx1=x2-x1;

            float dy1=y2-y1;

            float dz1=z2-z1;

            float dx2=x3-x2;

            float dy2=y3-y2;

            float dz2=z3-z2;

            nx=dy1*dz2-dy2*dz1;

            ny=dx2*dz1-dx1*dz2;

            nz=dx1*dy2-dx2*dy1;

            // приведение вектора нормали к единичной длине выполнять не будем

            // это выполнит OpenGL

              normalBuffer.position(0);

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

            // для вершин 1,2,3 одно и тоже три раза

            for (int i=1;i<4;i++){

                        normalBuffer.put(nx);

                        normalBuffer.put(ny);

                        normalBuffer.put(nz);

            }

            normalBuffer.position(0);

            // вычисляем центр треугольника

            xcenter=(x1+x2+x3)/3;

            ycenter=(y1+y2+y3)/3;

            zcenter=(z1+z2+z3)/3;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// метод, устанавливающий для использования имя текстуры 

public void setTextureName(int name){

            textureName=name;  

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// нам могут понадобиться координаты вершин и центра треугольника

// поэтому опишем методы, возвращающие их

public float getx1(){ return x1;}

public float gety1(){ return y1;}

public float getz1(){ return z1;}

public float getx2(){ return x2;}

public float gety2(){ return y2;}

public float getz2(){ return z2;}

public float getx3(){ return x3;}

public float gety3(){ return y3;}

public float getz3(){ return z3;}

public float getxcenter(){ return xcenter;}

public float getycenter(){ return ycenter;}

public float getzcenter(){ return zcenter;}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// создадим метод, который поворачивает треугольник 

// относительно вектора заданного двумя точками xa,ya,za и xb,yb,zb

// на угол angle против часовой стрелки

public void rotate(float angle,

            float xa, float ya, float za,

            float xb, float yb, float zb){

            // создаем матрицу вращения

            float [] rotatematrix=new float[16];

            // передаем в метод setRotateM угол и три координаты вектора,
            // образованного двумя точками a-b

            Matrix.setRotateM(rotatematrix, 0, angle, xb-xa, yb-ya, zb-za);

            // в результате получаем заполненную матрицу вращения rotatematrix

            // для нахождения новых координат точек после поворота 

            // будем использовать метод multiplyMV 

            // умножения матрицы на вектор размером в 4 элемента

            // зададим вектор, соединяющий точку a и вершину 1 треугольника 

            float [] oldvector1={x1-xa,y1-ya,z1-za,1};

            // получаем новый вектор после поворота

            float [] newvector=new float [4];

            Matrix.multiplyMV(newvector,0,rotatematrix,0,oldvector1,0);

            // добавляем к полученному вектору координаты точки a

            // в результате получаем новые координаты точки 1

            x1=newvector[0]+xa;

            y1=newvector[1]+ya;

            z1=newvector[2]+za;

            // аналогично получаем коодинаты точек 2 и 3 после поворота

            // поворачиваем точку 2

            float [] oldvector2={x2-xa,y2-ya,z2-za,1}; 

            Matrix.multiplyMV(newvector, 0, rotatematrix, 0, oldvector2, 0);

            x2=newvector[0]+xa;

            y2=newvector[1]+ya;

            z2=newvector[2]+za;

            // поворачиваем точку 3

            float [] oldvector3={x3-xa,y3-ya,z3-za,1};

            Matrix.multiplyMV(newvector, 0, rotatematrix, 0, oldvector3, 0);

            x3=newvector[0]+xa;

            y3=newvector[1]+ya;

            z3=newvector[2]+za;

            // пересчитывам нормали, центр и заполняем буферы

            recount();

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// метод, рисующий треугольник на экране

public void draw (GL10 gl){

  vertexBuffer.position(0);

  normalBuffer.position(0);

  texcoordBuffer.position(0);

  // включаем использование массивов вершин

  gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 

  // указываем, что буфер с именем vertexBuffer является буфером вершин

  gl.glVertexPointer(3,GL10.GL_FLOAT,0,vertexBuffer);

  // включаем использование массивов нормалей

  gl.glEnableClientState(GL10.GL_NORMAL_ARRAY); 

  // указываем, что буфер с именем normalBuffer является буфером нормалей

  gl.glNormalPointer(GL10.GL_FLOAT,0,normalBuffer);

  if (textureName!=0){

     // если имя текстуры не пустое

     // включаем использование двумерных текстур

     gl.glEnable(GL10.GL_TEXTURE_2D);

     // устанавливаем активной текстуру с именем textureName

     gl.glBindTexture(GL10.GL_TEXTURE_2D, textureName);

     // для учета освещения при использовании текстур 
     // включаем режим модуляции

     // если вместо GL10.GL_MODULATE поставить GL10.GL_REPLACE
     //эффект освещения исчезнет 

     gl.glTexEnvx(GL10.GL_TEXTURE_ENV,
        GL10.GL_TEXTURE_ENV_MODE,
        GL10.GL_MODULATE);

     // включаем использование массивов текстур 

      gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

     // указываем программе, что буфер с именем texcoordBuffer
     //является буфером текстур

     // первый параметр - это количество координат (две-s и t) 

     gl.glTexCoordPointer(2,GL10.GL_FLOAT,0,texcoordBuffer);
  }else{

     // если имя текстуры пустое

     // отключаем использование двумерных текстур

     gl.glDisable(GL10.GL_TEXTURE_2D);

  }

  // рисуем треугольник

  // последний параметр - это количество точек треугольника (т.е. три)

  gl.glDrawArrays(GL10.GL_TRIANGLES,0,3);

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

} // конец класса

------------------------------------------------------------------------------------------------------------ 

Таким образом мы создали класс, описывающий треугольник в трехмерном пространстве, научили его поворачиваться на произвольный угол относительно любой оси и хранить внутри себя ссылку на имя текстуры. Аналогично создается класс прямоугольника Quadr.

------------------------------------------------------------------------------------------------------------
package com.blogspot.andmonahov.pyramid;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import javax.microedition.khronos.opengles.GL10;
import android.opengl.Matrix;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Quadr {
private float x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4;
private float nx,ny,nz;
private float xcenter,ycenter,zcenter;
private FloatBuffer vertexBuffer,normalBuffer,texcoordBuffer;
private int textureName;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// конструктор
public Quadr(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3){
  // присваиваем координаты трем точкам, четвертую найдем
  // т.к. все четыре точки должны лежать в одной плоскости
  this.x1=x1;
  this.y1=y1;
  this.z1=z1;
  this.x2=x2;
  this.y2=y2;
  this.z2=z2;
  this.x3=x3;
  this.y3=y3;
  this.z3=z3;
  // подготавливаем буфер вершин
  ByteBuffer b1 = ByteBuffer.allocateDirect(4*12);
  b1.order(ByteOrder.nativeOrder());
  vertexBuffer = b1.asFloatBuffer();
  // подготавливаем буфер нормалей
  ByteBuffer b2 = ByteBuffer.allocateDirect(4*12);
  b2.order(ByteOrder.nativeOrder());
  normalBuffer = b2.asFloatBuffer();
  recount(); // пересчет нормалей и центра, поиск 4-ой точки
  // подготавливаем и заполняем буфер координат текстур
  ByteBuffer b4 = ByteBuffer.allocateDirect(4*8);
  b4.order(ByteOrder.nativeOrder());
  texcoordBuffer = b4.asFloatBuffer();
  texcoordBuffer.put(0); 
  texcoordBuffer.put(1);
  texcoordBuffer.put(0);
  texcoordBuffer.put(0);
  texcoordBuffer.put(1);
  texcoordBuffer.put(0);
  texcoordBuffer.put(1);
  texcoordBuffer.put(1);
  texcoordBuffer.position(0);
} 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// метод перезаписывает буфер вершин и буфер нормалей, 
// вычисляет центр прямоугольника
private void recount(){
  // ищем четвертую точку
  x4=x1-x2+x3;
  y4=y1-y2+y3;
  z4=z1-z2+z3;
  // заполняем буфер вершин значением координат точек
  vertexBuffer.position(0);
  // для вершины 1
  vertexBuffer.put(x1); 
  vertexBuffer.put(y1);
  vertexBuffer.put(z1); 
  // для вершины 2
  vertexBuffer.put(x2);
  vertexBuffer.put(y2);
  vertexBuffer.put(z2);
  // для вершины 3
  vertexBuffer.put(x3);
  vertexBuffer.put(y3);
  vertexBuffer.put(z3);
  // для вершины 4
  vertexBuffer.put(x4);
  vertexBuffer.put(y4);
  vertexBuffer.put(z4);
  vertexBuffer.position(0);
  // вычисляем нормаль
  float dx1=x2-x1;
  float dy1=y2-y1;
  float dz1=z2-z1;
  float dx2=x3-x2;
  float dy2=y3-y2;
  float dz2=z3-z2;
  nx=dy1*dz2-dy2*dz1;
  ny=dx2*dz1-dx1*dz2;
  nz=dx1*dy2-dx2*dy1;
  /заполняем буфер нормалей, нормаль одинакова для всех четырех вершин
  normalBuffer.position(0);
  // для вершин 1,2,3,4 одно и тоже 4 раза
  for (int i=1;i<5;i++){
     normalBuffer.put(nx);
     normalBuffer.put(ny);
  normalBuffer.put(nz);
  }
  normalBuffer.position(0);
  // вычисляем центр
  xcenter=(x1+x2+x3+x4)/4;
  ycenter=(y1+y2+y3+y4)/4;
  zcenter=(z1+z2+z3+z4)/4;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// методы возвращающие координаты вершин и центра
public float getx1(){ return x1;}
public float gety1(){ return y1;}
public float getz1(){ return z1;}

public float getx2(){ return x2;}
public float gety2(){ return y2;}
public float getz2(){ return z2;}

public float getx3(){ return x3;}
public float gety3(){ return y3;}
public float getz3(){ return z3;}

public float getx4(){ return x4;}
public float gety4(){ return y4;}
public float getz4(){ return z4;}

public float getxcenter(){ return xcenter;}
public float getycenter(){ return ycenter;}
public float getzcenter(){ return zcenter;} 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// метод, поворачивающий прямоугольник
public void rotate(float angle,
  float xa, float ya, float za,
  float xb, float yb, float zb){
  // создаем матрицу вращения
  float [] rotatematrix=new float[16];
  // передаем в метод setRotateM
  // угол и три координаты вектора, образованного двумя точками a-b
  Matrix.setRotateM(rotatematrix, 0, angle, xb-xa, yb-ya, zb-za);
  // в результате получаем заполненную матрицу вращения rotatematrix
  // для нахождения новых координат точек после поворота 
  // будем использовать метод multiplyMV 
  // умножения матрицы на вектор размером в 4 элемента
  // зададим вектор, соединяющий точку a и вершину 1  
  float [] oldvector1={x1-xa,y1-ya,z1-za,1};
  // получаем новый вектор после поворота
  float [] newvector=new float [4];
  Matrix.multiplyMV(newvector,0,rotatematrix,0,oldvector1,0);
  // добавляем к полученному вектору координаты точки a
  // в результате получаем новые координаты точки 1
  x1=newvector[0]+xa;
  y1=newvector[1]+ya;
  z1=newvector[2]+za;
  // аналогично получаем коодинаты точек 2 и 3 после поворота
  // поворачиваем точку 2
  float [] oldvector2={x2-xa,y2-ya,z2-za,1}; 
  Matrix.multiplyMV(newvector, 0, rotatematrix, 0, oldvector2, 0);
  x2=newvector[0]+xa;
  y2=newvector[1]+ya;
  z2=newvector[2]+za;
  // поворачиваем точку 3
  float [] oldvector3={x3-xa,y3-ya,z3-za,1};
  Matrix.multiplyMV(newvector, 0, rotatematrix, 0, oldvector3, 0);
  x3=newvector[0]+xa;
  y3=newvector[1]+ya;
  z3=newvector[2]+za;
  // новая точка 4 ищется методом recount
  // пересчитываем нормали, центр и заполняем буферы
  recount();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// метод, устанавливающий для использования имя текстуры 
public void setTextureName(int name){
  textureName=name;  
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//метод, рисующий прямоугольник
public void draw (GL10 gl){
  vertexBuffer.position(0);
  normalBuffer.position(0);
  texcoordBuffer.position(0);
  // включаем использование массивов вершин
  gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 
  // указываем программе, 
            // что буфер с именем vertexBuffer является буфером вершин
  gl.glVertexPointer(3,GL10.GL_FLOAT,0,vertexBuffer);
  // включаем использование массивов нормалей
  gl.glEnableClientState(GL10.GL_NORMAL_ARRAY); 
  // указываем программе, 
            //что буфер с именем normalBuffer является буфером нормалей
  gl.glNormalPointer(GL10.GL_FLOAT,0,normalBuffer);
  if (textureName!=0){
     gl.glEnable(GL10.GL_TEXTURE_2D);
     // устанавливаем активной текстуру с именем textureName
     gl.glBindTexture(GL10.GL_TEXTURE_2D, textureName);
       // для учета освещения при использовании текстур 
                         // включаем режим модуляции 
     gl.glTexEnvx(GL10.GL_TEXTURE_ENV,
        GL10.GL_TEXTURE_ENV_MODE,
        GL10.GL_MODULATE);
     // включаем использование массивов текстур 
     gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
     // указываем программе, что буфер с именем texcoordBuffer
     //является буфером текстур
     gl.glTexCoordPointer(2,GL10.GL_FLOAT,0,texcoordBuffer);
  }else{
     gl.glDisable(GL10.GL_TEXTURE_2D);
  }
  //рисуем прямоугольник
  gl.glDrawArrays(GL10.GL_TRIANGLE_FAN,0,4);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
} // конец класса

------------------------------------------------------------------------------------------------------------
Соберем из треугольников и прямоугольника пирамиду
------------------------------------------------------------------------------------------------------------
package com.blogspot.andmonahov.pyramid;
import javax.microedition.khronos.opengles.GL10;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Pyramid  {
private float xcenter;
private float ycenter;
private float zcenter;
public Triangle [] triangle=new Triangle[4]; // массив боковых треугольников
public Quadr quadr; // квадрат дна
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// конструктор 
public Pyramid (float x, float y, float z, float l, float h ) {
            //x,y,z координаты центра основания
            //l пол-ширины основания
            //h высота
            //создаем боковые треугольники 
            triangle[0]=new Triangle(x,y+h,z,   x-l,y,z+l,  x+l,y,z+l);
            triangle[1]=new Triangle(x,y+h,z,   x+l,y,z+l,  x+l,y,z-l);
            triangle[2]=new Triangle(x,y+h,z,   x+l,y,z-l,  x-l,y,z-l);
            triangle[3]=new Triangle(x,y+h,z,   x-l,y,z-l,  x-l,y,z+l);
            //создаем основание пирамиды
            quadr=new Quadr(x-l,y,z+l,  x-l,y,z-l,  x+l,y,z-l);
            recount(); // пересчитаем центр
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// пересчет координат центра
public void recount(){
            xcenter=(triangle[0].getx1()+triangle[0].getx2()+triangle[0].getx3()+
                        triangle[2].getx2()+triangle[2].getx3())/5;
            ycenter=(triangle[0].gety1()+triangle[0].gety2()+triangle[0].gety3()+
                        triangle[2].gety2()+triangle[2].gety3())/5;
            zcenter=(triangle[0].getz1()+triangle[0].getz2()+triangle[0].getz3()+
                        triangle[2].getz2()+triangle[2].getz3())/5;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// для того, чтобы повернуть пирамиду относительно вектора a-b
// на угол angle достаточно повернуть боковые треугольники и квадрат дна 
public void rotate(float angle,
            float xa, float ya, float za,
            float xb, float yb, float zb){
            // вызываем методы вращения треугольников четырех треугольников
            for (int i=0; i<4; i++){
                        triangle[i].rotate(angle, xa, ya, za, xb, yb, zb);
            }
            // вызываем метод вращения квадрата дна 
            quadr.rotate(angle, xa, ya, za, xb, yb, zb);
            // пересчитываем центр пирамиды
            recount();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// частные случаи метода rotate
// поворачивает пирамиду относительно оси центр-вершина
public void rotatecenter0 (float angle){
            rotate(angle, xcenter, ycenter, zcenter, 
                        triangle[0].getx1(),triangle[0].gety1(), triangle[0].getz1());
}
// аналогично получаем методы
// поворачивающие пирамиду относительно оси центр-нижний угол
public void rotatecenter1 (float angle){
            rotate(angle, xcenter, ycenter, zcenter,
                        triangle[0].getx2(), triangle[0].gety2(), triangle[0].getz2());
}
public void rotatecenter2 (float angle){
            rotate(angle, xcenter, ycenter, zcenter,
                        triangle[0].getx3(), triangle[0].gety3(), triangle[0].getz3());
}
public void rotatecenter3 (float angle){
            rotate(angle, xcenter, ycenter, zcenter,
                        triangle[2].getx2(), triangle[2].gety2(), triangle[2].getz2());
}
public void rotatecenter4 (float angle){
            rotate(angle, xcenter, ycenter, zcenter,
                        triangle[2].getx3(), triangle[2].gety3(), triangle[2].getz3());
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// если грани пирамиды надо закрасить разными текстурами
// применяем этот метод
public void setTextureName(int name1, int name2, int name3, int name4, int name5){
            // устанавливаем текстуру боковых треугольников
            triangle[0].setTextureName(name1);
            triangle[1].setTextureName(name2);
            triangle[2].setTextureName(name3);
            triangle[3].setTextureName(name4);
            // устанавливаем текстуру дна
            quadr.setTextureName(name5);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// если всю пирамиду надо закрасить одной текстурой 
// применяем этот метод
public void setTextureName(int name){
            // устанавливаем текстуру боковых треугольников
            triangle[0].setTextureName(name);
            triangle[1].setTextureName(name);
            triangle[2].setTextureName(name);
            triangle[3].setTextureName(name);
            // устанавливаем текстуру дна
            quadr.setTextureName(name);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
// рисуем пирамиду
public void draw (GL10 gl){
            // рисуем боковые треугольники 
            for (int i=0; i<4; i++){
                        triangle[i].draw(gl);
            }
            // рисуем дно пирамиды
            quadr.draw(gl);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}//конец класса

------------------------------------------------------------------------------------------------------------ 

Рисование осуществляется в классе, реализующем интерфейс GLSurfaceView.Renderer. Создадим такой класс MyClassRenderer.Предварительно поместим в каталоги res\drawable-hdpi, res\drawable-ldpi, res\drawable-mdpi какие-нибудь картинки с именами icon1.jpg, icon2.jpg, icon3.jpg, icon4.jpg, icon5.jpg. Эти фалы будут загружаться в качестве текстур.

------------------------------------------------------------------------------------------------------------ 

package com.blogspot.andmonahov.pyramid;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.opengl.GLU;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class MyClassRenderer implements GLSurfaceView.Renderer{

            // интерфейс GLSurfaceView.Renderer содержит
            // три метода onDrawFrame, onSurfaceChanged, onSurfaceCreated

            // которые должны быть переопределены

            // текущий контекст

            private Context context;

            // позиция камеры (почему поля определены как public static поясню позже)

            public static float xposition,yposition,zposition;

            // направление взгляда камеры

             private float xlook,ylook,zlook;

            // координаты вектора, указывающего камере, где верх

            private float xtop,ytop,ztop;

            // массивы для хранения цветов материала

            // цвета общего фонового освещения

            private float [] ambientmaterialArray={0.2f, 0.2f, 0.2f, 1f};

            // цвета отраженного рассеянного света

            private float [] diffusematerialArray={0.8f, 0.8f, 0.8f, 1f};

            // цвета отраженного зеркального света

            private float [] specularmaterialArray={0.5f, 0.5f, 0.5f,1f};

            // соответствующие им буферы цветов материала

            private FloatBuffer ambientmaterialBuffer,

                        diffusematerialBuffer,specularmaterialBuffer;

            // массив для хранения координат источника света

            private float [] positionlightArray={0.5f,0,0.2f,0};

            // массивы для хранения цветов источника света

            // цвета общего фонового освещения

            private float [] ambientlightArray={0.5f, 0.5f, 0.5f, 1f};

            // цвета отраженного рассеянного света

            private float [] diffuselightArray={0.8f, 0.8f, 0.8f, 1f};

            // цвета отраженного зеркального света

            private float [] specularlightArray={0.8f, 0.8f, 0.8f,1f};

            // соответствующие им буферы источника света

            private FloatBuffer positionlightBuffer,ambientlightBuffer,

                        diffuselightBuffer,specularlightBuffer;

            //текстуры
            private Texture tex1,tex2,tex3,tex4,tex5;

            //пирамиды

            private Pyramid p1, p2;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //конструктор  
            public MyClassRenderer(Context context) {

            // запомним контекст,он нам понадобится для загрузки текстур

            this.context=context;

            // настройки камеры

            xposition=0.3f;

            yposition=0.3f;

            zposition=1.2f;

            xlook=0;

            ylook=0;

            zlook=0;

            xtop=0;

            ytop=1;

            ztop=0;

            // переписываем цвета материалов из массивов в буферы

            ByteBuffer b1 = ByteBuffer.allocateDirect(4 * 4);

            b1.order(ByteOrder.nativeOrder());

            ambientmaterialBuffer = b1.asFloatBuffer();

            ambientmaterialBuffer.put(ambientmaterialArray);

            ambientmaterialBuffer.position(0);

            //

            ByteBuffer b2 = ByteBuffer.allocateDirect(4 * 4);

            b2.order(ByteOrder.nativeOrder());

            diffusematerialBuffer = b2.asFloatBuffer();

            diffusematerialBuffer.put(diffusematerialArray);

            diffusematerialBuffer.position(0);

            //

            ByteBuffer b3 = ByteBuffer.allocateDirect(4 * 4);

            b3.order(ByteOrder.nativeOrder());

            specularmaterialBuffer = b3.asFloatBuffer();

            specularmaterialBuffer.put(specularmaterialArray);

            specularmaterialBuffer.position(0);

            //

            // переписываем координаты источника света в буфер

            ByteBuffer b4 = ByteBuffer.allocateDirect(4 * 4);

            b4.order(ByteOrder.nativeOrder());

            positionlightBuffer = b4.asFloatBuffer();

            positionlightBuffer.put(positionlightArray);

            positionlightBuffer.position(0);

            //

            // переписываем цвета источника света из массивов в буферы

            ByteBuffer b5 = ByteBuffer.allocateDirect(4 * 4);

            b5.order(ByteOrder.nativeOrder());

            ambientlightBuffer = b5.asFloatBuffer();

            ambientlightBuffer.put(ambientlightArray);

            ambientlightBuffer.position(0);

            //

            ByteBuffer b6 = ByteBuffer.allocateDirect(4 * 4);

            b6.order(ByteOrder.nativeOrder());

            diffuselightBuffer = b6.asFloatBuffer();

            diffuselightBuffer.put(diffuselightArray);

            diffuselightBuffer.position(0);

            //

            ByteBuffer b7 = ByteBuffer.allocateDirect(4 * 4);

            b7.order(ByteOrder.nativeOrder());

            specularlightBuffer = b7.asFloatBuffer();

            specularlightBuffer.put(specularlightArray);

            specularlightBuffer.position(0);

            // создаем пирамиды

            p1=new Pyramid(-0.15f, 0, 0, 0.3f, 0.45f);

            p2=new Pyramid( 0.3f, 0.2f,-1, 0.3f, 0.45f);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public void onDrawFrame(GL10 gl) {

            //этот метод вызывается циклически

            //здесь мы будем выполнять рисование

            // очищаем буферы глубины и цвета

            gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

            // перейдем в режим работы с матрицей модели-вида

            gl.glMatrixMode(GL10.GL_MODELVIEW);

            // сбросим матрицу модели-вида на единичную

            gl.glLoadIdentity();

            // поворачиваем пирамиды  вокруг осей

            // относительно текущего положения пирамиды

            p1.rotatecenter0(0.5f);

            p1.rotatecenter1(0.2f);

            p2.rotatecenter1(-0.5f);

            p2.rotatecenter2(-0.2f);

            // устанавливаем камеру

            GLU.gluLookAt(gl, xposition,yposition,zposition, xlook,ylook,zlook, xtop,ytop,ztop);
            // включаем источник света с номером 0

            gl.glEnable(GL10.GL_LIGHT0);

            // устанавливаем координаты источника света

            gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, positionlightBuffer);

            // устанавливаем цвета источника света

            gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, ambientlightBuffer);

            gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, diffuselightBuffer);

            gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, specularlightBuffer);

            // устанавливаем цвета материала

            gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, 
                        GL10.GL_AMBIENT, ambientmaterialBuffer);

            gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, 
                        GL10.GL_DIFFUSE, diffusematerialBuffer);

            gl.glMaterialfv(GL10.GL_FRONT_AND_BACK,
                        GL10.GL_SPECULAR, specularmaterialBuffer);

            //рисуем дальнюю пирамиду

            p2.draw(gl);

            //рисуем ближнюю пирамиду

            p1.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();

            // устанавливаем перспективную проекцию

            // угол обзора 60 градусов

            // передняя отсекающая плоскость 0.1

            // задняя отсекающая плоскость 100

            GLU.gluPerspective (gl, 60, ratio, 0.1f, 100f);

            // перейдем в режим работы с матрицей модели-вида

            gl.glMatrixMode(GL10.GL_MODELVIEW);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public void onSurfaceCreated(GL10 gl, EGLConfig config) {

            // вызывается при создании окна

            // включим пересчет нормалей на единичную длину

            gl.glEnable(GL10.GL_NORMALIZE);

            // включим сглаживание цветов

            gl.glShadeModel(GL10.GL_SMOOTH);

            // включим проверку глубины

            gl.glEnable(GL10.GL_DEPTH_TEST);

            gl.glDepthFunc(GL10.GL_LEQUAL);

            // разрешим использовать освещение

            gl.glEnable(GL10.GL_LIGHTING);

            //загружаем текстуры

            tex1=new Texture(gl,context, R.drawable.icon1);

            tex2=new Texture(gl,context, R.drawable.icon2);

            tex3=new Texture(gl,context, R.drawable.icon3);

            tex4=new Texture(gl,context, R.drawable.icon4);

            tex5=new Texture(gl,context, R.drawable.icon5);

            //привязываем текстуры к пирамидам

            // грани ближней пирамиды закрасим разными текстурами

            p1.setTextureName(tex1.getName(),tex2.getName(),
                        tex3.getName(),tex4.getName(),tex5.getName());

            // грани дальней пирамиды закрасим одинаковой текстурой

            p2.setTextureName(tex1.getName());

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}//конец класса

------------------------------------------------------------------------------------------------------------

Рендерер будет создан и запущен в классе, расширяющем GLSurfaceView. Создадим такой класс MyClassSurfaceView.

------------------------------------------------------------------------------------------------------------
package com.blogspot.andmonahov.pyramid;
import android.content.Context;
import android.opengl.GLSurfaceView;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class MyClassSurfaceView extends GLSurfaceView{
            //создадим ссылку для хранения экземпляра нашего класса рендерера
            private MyClassRenderer renderer;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// конструктор
public MyClassSurfaceView(Context context) {
            // вызовем конструктор родительского класса GLSurfaceView
            super(context);
            // создадим экземпляр нашего класса MyClassRenderer
            renderer = new MyClassRenderer(context);
            // запускаем рендерер
            setRenderer(renderer);
            // установим режим циклического запуска метода onDrawFrame 
            setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
            // при этом запускается отдельный поток
            // в котором циклически вызывается метод onDrawFrame
            // т.е. бесконечно происходит перерисовка кадров
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
} // конец класса

------------------------------------------------------------------------------------------------------------ 

Нам осталось только создать экземпляр класса MyClassSurfaceView в нашем Activity и установить вызов его через метод setContentView.

------------------------------------------------------------------------------------------------------------
package com.blogspot.andmonahov.pyramid;
import android.app.Activity;
import android.os.Bundle;
public class PyramidActivity extends Activity {
            // создадим ссылку на экземпляр нашего класса MyClassSurfaceView
            private MyClassSurfaceView mGLSurfaceView;
// переопределим метод onCreate
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
            //создадим экземпляр нашего класса MyClassSurfaceView
            mGLSurfaceView = new MyClassSurfaceView(this);
            //вместо вызова стандартного контента  
            //setContentView(R.layout.main);
            //вызовем экземпляр нашего класса MyClassSurfaceView  
            setContentView(mGLSurfaceView);
            // на экране появится поверхность для рисования в OpenGL ES
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void onPause() {
            super.onPause();
            mGLSurfaceView.onPause();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void onResume() {
            super.onResume();
            mGLSurfaceView.onResume();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
} // конец класса

------------------------------------------------------------------------------------------------------------ 

В результате получим две вращающиеся пирамиды