OpenGLES2.0笔记

capacity：容量
allocate：分配
Coord：坐标
vertex:顶点
Square：平面
Program：程序
Compile：编译
font：字体
pname：工程名称
Validate：验证
Uniform：均匀

ByteBuffer和FloatBuffer是java.nio包下的类
ByteBuffer bb=ByteBuffer.allocate(capacity);//参数是一个容量
ByteBuffer bb2=ByteBuffer.allocateDirect(capacity);//这个方法在参与I/O操作性能会更好

called unimplemented OpenGL ES API 报错。。

坐标系：安卓中的坐标系在横屏的时候会变形，变粗，所以在横屏的时候需要处理摄像机。
屏幕的左上角是（-1.0,1.0）横向向右为X轴正向，纵向向下为Y轴负向，其范围都是从 -1到 +1。

我们在该类中定义的float类型的数据并不能直接被opengl使用，float[]是属于虚拟机环境的，而Opengl作为本地系统库
直接运行在硬件上，所以我们需要将float[] 转化为FloatBuffer以使数据可以被opengl使用
//如下浮点数组代表的是一个三角形的顶点坐标
float[] vertex={0.1f,0.1f,
0.1f,0.1f,
0.1f,0.1f};
//浮点缓冲
FloatBuffer fb=FloatBuffer.allocate(int capacity);
//把顶点坐标添加到FloatBuffer中，并把位置0作为开始位置。
fb.put(vertex);
fb.position(0);

着色器语言（shading language），由C/C++编写
如下是顶点shader
attribute vec4 a_Position;
void main()
{
gl_Position = a_Position;
}
gl_Position即opengl定义的顶点的坐标，我们目的就是通过这个来告诉opengl我们的顶点数据。
vec4是着色器语言中的向量类型的一种，包含了四个浮点数的向量

如下是面shader
precision mediump float;
uniform vec4 u_Color;
void main()
{
gl_FragColor = u_Color;
}
传入一个颜色信息。这里注意一下 上面顶点着色器的 限定符 attribute 和 uniform 。attribute 一般用于每个顶点
各不相同的量，如顶点位置等，后者一般用于同一组顶点组成的相同的量，如光源位置，一组颜色等。

编写shader的帮助类ShaderHelper和TextResourceReader，可以直接使用。
在使用的时候通过TextResourceReader的readTextFileFromResource（Context context,int resourceId）方法返回shader字符串，然后再用ShaderHelper的buildProgram(String vertexShaderSource,String fragmentShaderSource)返回的内容直接使用。
ShaderHelper主要功能是
1，读取shader文本内容
2，编译shader
3，将顶点shader和面shader链接成program
4，验证program
TextResourceReader主要功能是
1，把shader源代码通过流的转换返回我们需要的shader字符串。

public class ShaderHelper {

    private static final String TAG = "ShaderHelper";

    /**
     * 加载并编译顶点shader，返回得到的opengl id
     * @param shaderCode
     * @return
     */
    public static int compileVertexShader(String shaderCode) {
        return compileShader(GL_VERTEX_SHADER, shaderCode);
    }

    /**
     * 加载并编译片段shader，返回opengl id
     * @param shaderCode
     * @return
     */
    public static int compileFragmentShader(String shaderCode) {
        return compileShader(GL_FRAGMENT_SHADER, shaderCode);
    }

    /**
     * 加载并编译着色器，返回opengl id
     * @param type
     * @param shaderCode
     * @return
     */
    private static int compileShader(int type, String shaderCode) {
        // 建立新的着色器对象
        final int shaderObjectId = glCreateShader(type);

        if (shaderObjectId == 0) {
            if (LoggerConfig.ON) {
                Log.w(TAG, "不能创建新的着色器.");
            }

            return 0;
        }

        // 传递着色器资源代码.
        glShaderSource(shaderObjectId, shaderCode);

        //编译着色器
        glCompileShader(shaderObjectId);

        // 获取编译的状态
        final int[] compileStatus = new int[1];
        glGetShaderiv(shaderObjectId, GL_COMPILE_STATUS,
            compileStatus, 0);

        if (LoggerConfig.ON) {
            //打印log
            Log.v(TAG, "代码编译结果:" + "\n" + shaderCode
                + "\n:" + glGetShaderInfoLog(shaderObjectId));
        }

        // 确认编译的状态
        if (compileStatus[0] == 0) {
            // 如果编译失败，则删除该对象
            glDeleteShader(shaderObjectId);

            if (LoggerConfig.ON) {
                Log.w(TAG, "编译失败!.");
            }

            return 0;
        }

        // 返回着色器的opengl id
        return shaderObjectId;
    }

    /**
     * 链接顶点着色器和片段着色器成一个program
     * 并返回这个pragram的opengl id
     * @param vertexShaderId
     * @param fragmentShaderId
     * @return
     */
    public static int linkProgram(int vertexShaderId, int fragmentShaderId) {

        // 新建一个program对象
        final int programObjectId = glCreateProgram();

        if (programObjectId == 0) {
            if (LoggerConfig.ON) {
                Log.w(TAG, "不能新建一个 program");
            }

            return 0;
        }

        //把点shader添加到program中
        glAttachShader(programObjectId, vertexShaderId);

        //把shader添加到program中
        glAttachShader(programObjectId, fragmentShaderId);

        //将两个着色器连接成一个program
        glLinkProgram(programObjectId);

        // 获取连接状态
        final int[] linkStatus = new int[1];
        glGetProgramiv(programObjectId, GL_LINK_STATUS,linkStatus, 0);

        if (LoggerConfig.ON) {
            // Print the program info log to the Android log output.
            Log.v(
                TAG,
                "Results of linking program:\n"
                    + glGetProgramInfoLog(programObjectId));
        }

        // 验证连接状态
        if (linkStatus[0] == 0) {
            // 如果失败就删除
            glDeleteProgram(programObjectId);

            if (LoggerConfig.ON) {
                Log.w(TAG, "连接 program 失败!.");
            }

            return 0;
        }

        // Return the program object ID.
        return programObjectId;
    }

    /**
     * Validates an OpenGL program. Should only be called when developing the
     * application.
     */
    public static boolean validateProgram(int programObjectId) {
        glValidateProgram(programObjectId);
        final int[] validateStatus = new int[1];
        glGetProgramiv(programObjectId, GL_VALIDATE_STATUS,
            validateStatus, 0);
        Log.v(TAG, "Results of validating program: " + validateStatus[0]
            + "\nLog:" + glGetProgramInfoLog(programObjectId));

        return validateStatus[0] != 0;
    }

    /**
     * /**
     * 编译，连接 ，返回 program 的 ID
     * @param vertexShaderSource
     * @param fragmentShaderSource
     * @return
     */
    public static int buildProgram(String vertexShaderSource,
        String fragmentShaderSource) {
        int program;

        // Compile the shaders.
        int vertexShader = compileVertexShader(vertexShaderSource);
        int fragmentShader = compileFragmentShader(fragmentShaderSource);

        // Link them into a shader program.
        program = linkProgram(vertexShader, fragmentShader);

        if (LoggerConfig.ON) {
            validateProgram(program);
        }
        return program;
    }

}

如下工具类TextResourceReader是把shader源代码通过流的转换返回我们需要的shader字符串。

public class TextResourceReader {

    public static String readTextFileFromResource(Context context,
        int resourceId) {
        StringBuilder body = new StringBuilder();

        try {
            InputStream inputStream = 
                context.getResources().openRawResource(resourceId);
            InputStreamReader inputStreamReader = 
                new InputStreamReader(inputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

            String nextLine;

            while ((nextLine = bufferedReader.readLine()) != null) {
                body.append(nextLine);
                body.append('\n');
            }
        } catch (IOException e) {
            throw new RuntimeException(
                "Could not open resource: " + resourceId, e);
        } catch (Resources.NotFoundException nfe) {
            throw new RuntimeException("Resource not found: " + resourceId, nfe);
        }

        return body.toString();
    }
}

方便打印的工具类

public class LoggerConfig {
    public static final boolean ON = true;
}

图形类

public class Square2 {  

    private Context context;  
    /*------------------第一步: 修改顶点数据-------------------------*/  
    //矩形(其实是菱形)顶点坐标 ，按逆时针
    static float squareCoords[] = { -0.25f,  0.5f , // top left  
        0.75f,  0.5f  ,   // top right  
       -0.75f, -0.5f  ,   // bottom left  
        0.25f, -0.5f  };  // bottom right  
    //float类型的字节数，用于给FloatBuffer指定容量时使用
    private static final int BYTES_PER_FLOAT = 4;  
    // 数组中每个顶点的坐标数  
    static final int COORDS_PER_VERTEX = 2;  
    /*------------------第二步: 修改顶点个数-------------------------*/  
    private static final int POSITION_COMPONENT_COUNT = 4;  
    //要把定义的float坐标数组转化成FloatBuffer类型，因为它是直接运行在硬件上的，不是java虚拟机。
    private FloatBuffer vertexBuffer;


    //A_POSITION是顶点shader的变量名，U_COLOR是片段shader的变量名 ,它们用于匹配shader文件中的变量。
    private static final String A_POSITION = "a_Position";
    private static final String U_COLOR = "u_Color";

    //------------获得program的ID的含义类似的  
    private int uColorLocation;  
    private int aPositionLocation;  
    private int program;//保存program的id  

    //矩形的构造方法
    public Square2(Context context) {  
        this.context = context;  
        vertexBuffer = ByteBuffer  
                .allocateDirect(squareCoords.length * BYTES_PER_FLOAT)  
                .order(ByteOrder.nativeOrder())  
                .asFloatBuffer();  
        // 把坐标数组加入FloatBuffer中，并且从0下标开始读取 
        vertexBuffer.put(squareCoords);  
        vertexBuffer.position(0);  


        getProgram();  

        //----------第三步: 获取这两个ID ，通过匹配shader文件中的变量来获取
        uColorLocation = GLES20.glGetUniformLocation(program, U_COLOR);  
        aPositionLocation = GLES20.glGetAttribLocation(program, A_POSITION);  


        //---------第四步: 传入数据  
        //GLES20.glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride, Buffer ptr)
        //int index：？？？
        //int size：每个顶点的坐标数
        //int type：类型，用GLES20.GL_FLOAT
        //boolean normalized：？？？是否统一化
        //int stride：？？？跨度   
        //Buffer ptr：承载坐标数组转换成的FloatBuffer。
        GLES20.glVertexAttribPointer(aPositionLocation, COORDS_PER_VERTEX,  
                GLES20.GL_FLOAT, false, 0, vertexBuffer);  
        //使面变成顶点数组???
        GLES20.glEnableVertexAttribArray(aPositionLocation);  
    }  

    //获取program，
    private void getProgram(){  
        //获取顶点shader文本  
        String vertexShaderSource = TextResourceReader  
                .readTextFileFromResource(context, R.raw.simple_vertex_shader);  
        //获取片段shader文本  
        String fragmentShaderSource = TextResourceReader  
                .readTextFileFromResource(context, R.raw.simple_fragment_shader);  
        //获取program的id  
        program = ShaderHelper.buildProgram(vertexShaderSource, fragmentShaderSource);  
        //使用该program
        GLES20.glUseProgram(program);  
    }  


    public void draw(){  
        GLES20.glUniform4f(uColorLocation, 0.0f, 0.0f, 1.0f, 1.0f);       
        //绘制模式
        //GLES20.glDrawArrays(int mode, int first, int count)
        //int mode：绘制模式， GLES20.GL_TRIANGLE_STRIP：将传入的顶点按照顺序依次连接进行绘制
        //int first：从数组的哪个位置开始
        //int count：绘制的个数
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POSITION_COMPONENT_COUNT);  
    }
}

Render类

public class MyRender implements Renderer {  

    private Context context;  

    public MyRender(Context context){  
        this.context = context;  
    }  

    //定义三角形对象  
    Triangle triangle;  
    Square2 square;  

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {  
        Log.w("MyRender","onSurfaceCreated");  
        // TODO Auto-generated method stub  
        //First:设置清空屏幕用的颜色，前三个参数对应红绿蓝，最后一个对应alpha  
        glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
//      triangle = new Triangle(context);  
        square = new Square2(context);  
    }  

    public void onSurfaceChanged(GL10 gl, int width, int height) {  
        Log.w("MyRender","onSurfaceChanged");  
        // TODO Auto-generated method stub  
        //Second:设置视口尺寸，即告诉opengl可以用来渲染的surface大小  
        glViewport(0,0,width,height);  
    }  

    public void onDrawFrame(GL10 gl) {  
        Log.w("MyRender","onDrawFrame");  
        // TODO Auto-generated method stub  
        //Third:清空屏幕，擦除屏幕上所有的颜色，并用之前glClearColor定义的颜色填充整个屏幕  
        glClear(GL_COLOR_BUFFER_BIT);  
        square.draw();  
    }  
}

Activity

public class MainActivity extends Activity {

    private GLSurfaceView glSurfaceView;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        glSurfaceView = new GLSurfaceView(this);  
        glSurfaceView.setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context.  
        glSurfaceView.setRenderer(new MyRender(this));  
        setContentView(glSurfaceView);  
    }  
}

手机的屏幕和普通的OpenGL的坐标系不一样，因为手机横竖屏转换的时候会拉伸，
它的坐标系是Y轴向上为正，向下为负，X轴向右为正，X轴向左为负。
坐标范围是
左上角(-1.0，1.0)；
右上角(1.0，1.0)；
左下角(-1.0，-1.0)；
右下角(1.0，-1.0)；
一个正方形按照Z字形画出两个三角形，重合的点可以复用前提是在draw的时候使用GLES20.GL_TRIANGLE_STRIP模式，在画图之前需要指定顶点数量，每个顶点所占有的坐标数(坐标是从数组中依次获取，必须把float数组转换成FloatBuffer类型，OpenGL是直接在硬件中进行的，不是虚拟机)。如果使用的是不复用的模式，那么一个矩形需要指定6对坐标，也就是画出两个三角形。

画圆