OpenGL ES GLSL 自定义着色器、及翻转策略

1、OpenGL ES 版本

目前OpenGL ES有如下三个版本:

• OpenGL ES 1.X :针对固定功能流⽔管线硬件
• OpenGL ES 2.X :针对可编程流⽔管线硬件
• OpenGL ES 3.X :OpenGL ES 2.0的扩展

2、EGL (Embedded Graphics Library )

主要功能：

• 和本地窗⼝系统(native windowing system)通讯
• 查询可⽤的配置
• 创建OpenGL ES可⽤的“绘图表⾯”(drawing surface)
• 同步不同类别的API之间的渲染，(例在OpenGL ES和OpenVG之间同步，或者在OpenGL和本地窗⼝的绘图命令之间)
• 管理“渲染资源”，(例：纹理映射rendering map)

2.1 GLSL中的向量数据类型

类型	描述
vec2，vec3，vec4	2分量、3分量、4分量浮点向量
ivec2，ivec3，ivec4	2分量、3分量、4分量整型向量
uvec2，uvec3，uvec4	2分量、3分量、4分量⽆符号整型向量
bvec2，bvec3，bvec4	2分量、3分量、4分量bool型向量

2.2 GLSL中的矩阵数据类型

类型	描述
mat2，mat2x2	两行两列
mat3，mat3x3	三行三列
mat4，mat4x4	四行四列
mat2x3	三⾏两列
mat2x4	四⾏两列
mat3x2	两行三列
mat3x4	四行三列
mat4x2	两⾏四列
mat4x3	三行四列

2.3 变量存储限定符

类型	描述
	只是普通的本地变量，外部不见，外部不可访问
const	⼀个编译常量，或者说是⼀个对函数来说为只读的参数
in/varying	从以前阶段传递过来的变量
in/varying centroid	⼀个从以前的阶段传递过来的变量，使用质⼼插值
out/attribute	传递到下一个处理阶段或者在一个函数中指定一个返回值
out/attribute centroid	传递到下一个处理阶段，质心插值
uniform	⼀个从客户端代码传递过来的变量，在顶点之间不做改变

3、OpenGL ES 错误处理

如果不正确使⽤OpenGL ES命令,应⽤程序就会产⽣⼀个错误编码。这个错误编码将被记录,可以⽤glGetError查询。 在应⽤程序⽤glGetError查询第⼀个错误代码之前,不会记录其他错误代码。⼀旦查询到错误代码,当前错误代码便复位为GL_NO_ERROR。

GLenum glGetError(void)

错误代码	描述
GL_NO_ERROR	从上⼀次调用glGetError 以来没有⽣成任何错误
GL_INVALID_ENUM	GLenum 参数超出范围,忽略⽣成错误命令
GL_INVALID_VALUE	数值型 参数超出范围,忽略⽣成错误命令
GL_INVALID_OPERATION	特定命令在当前OpenGL ES 状态⽆法执行
GL_OUT_OF_MEMORY	内存不足时执行该命令,如果遇到这个错误,除非当前错误代码,否则OpenGL ES 管线的状态被认为未定义

4、实例创建顶点着色器、片元着色加载纹理图片

4.1、在Xcode中创建顶点着色器文件、片元着色器文件
在Xcode中，是不支持编写顶点着色器文件、片元着色器文件的，也没有相应的后缀，需要自己创建一个文件把后缀改为.vsh(顶点着色器文件)和.fsh(片元着色器文件)。(也有可以直接使用.glsl文件后缀，一般为了直观展示，使用.vsh和.fsh，其实GLSL语言就是一段字符串)
提示：不建议写中文注释，可能会出先意想不到的bug，一般不在GLSL文件里面写太多的注释
4.2 GLSL中的三种修饰类型

• uniform
  把客户端代码(App端)传递到顶点着色器(vertex)和片元着色器(fragment)里面用到的变量。使用gluiform传递参数。我们一般把vertex和fragment看作常量(这里的常量是指，在着色器里面不变的数据)。使用uniform传递的数据一般有: 视图矩阵，投影矩阵，投影视图矩阵。
• attribute
  其最大的特点就是只能从客户端把数据传递到顶点着色器，也只能在顶点着色器里面使用。一般用来修饰顶点数据、纹理坐标、颜色、法线，即一切和坐标、和颜色有关的数据。
• varying
  当需要把纹理坐标传递到片元着色器里面来时，无法使用attribute来传递，需要使用varying来做以下桥接。

4.1顶点着色器
需要创建2个基本对象才能⽤着⾊器进⾏渲染: 着⾊器对象和程序对象。
获取链接后着⾊器对象的⼀般过程包括6个步骤:

• 1、创建⼀个顶点着⾊器对象和⼀个⽚段着⾊器对象
• 2、将源代码链接到每个着⾊器对象
• 3、编译着⾊器对象
• 4、创建⼀个程序对象
• 5、将编译后的着⾊器对象连接到程序对象
• 6、链接程序对象

创建与编译⼀个着⾊器

创建与编译⼀个着⾊器

GLuint glCreateShader(GLenum type);
type — 创建着⾊器的类型,GL_VERTEX_SHADER 或者GL_FRAGMENT_SHADER
返回值 — 是指向新着色器对象的句柄.可以调用glDeleteShader 删除 void glDeleteShader(GLuint shader);
shader — 要删除的着⾊器对象句柄

void glShaderSource(GLuint shader , GLSizei count ,const GLChar * const *string, const GLint *length);
shader — 指向着⾊器对象的句柄
count — 着⾊器源字符串的数量,着⾊器可以由多个源字符串组成,但是每个着⾊器只有一个main函数 
string — 指向保存数量的count 的着⾊器源字符串的数组指针
length — 指向保存每个着⾊器字符串大小且元素数量为count 的整数数组指针.

void glCompileShader(GLuint shader); 
shader — 需要编译的着⾊器对象句柄

void glGetShaderiv(GLuint shader , GLenum pname , GLint *params );
shader — 需要编译的着⾊器对象句柄
pname — 获取的信息参数,可以为 GL_COMPILE_STATUS/GL_DELETE_STATUS/ GL_INFO_LOG_LENGTH/GL_SHADER_SOURCE_LENGTH/ GL_SHADER_TYPE
params — 指向查询结果的整数存储位置的指针.

void glGetShaderInfolog(GLuint shader , GLSizei maxLength, GLSizei *length , GLChar *infoLog);
shader — 需要获取信息日志的着⾊器对象句柄
maxLength — 保存信息⽇志的缓存区⼤小
length — 写⼊的信息⽇志的⻓度(减去null 终⽌符); 如果不需要知道⻓度. 这个参数可以为Null 
infoLog — 指向保存信息⽇志的字符缓存区的指针.

创建与链接程序

GLUint glCreateProgram( )
创建一个程序对象
返回值: 返回一个执行新程序对象的句柄

void glDeleteProgram( GLuint program ) 
program : 指向需要删除的程序对象句柄

//着⾊器与程序连接/附着
void glAttachShader( GLuint program , GLuint shader );
program : 指向程序对象的句柄
shader : 指向程序连接的着⾊器对象的句柄

//断开连接
void glDetachShader(GLuint program);
program : 指向程序对象的句柄
shader : 指向程序断开连接的着⾊器对象句柄

glLinkProgram(GLuint program)
program: 指向程序对象句柄。
链接程序之后, 需要检查链接是否成功. 你可以使用glGetProgramiv 检查链接状态: 
void glGetProgramiv (GLuint program,GLenum pname, GLint *params);
program: 需要获取信息的程序对象句句柄 
pname : 获取信息的参数,可以是:
GL_ACTIVE_ATTRIBUTES GL_ACTIVE_ATTRIBUTES_MAX_LENGTH GL_ACTIVE_UNIFORM_BLOCK GL_ACTIVE_UNIFORM_BLOCK_MAX_LENGTH GL_ACTIVE_UNIFROMS GL_ACTIVE_UNIFORM_MAX_LENGTH GL_ATTACHED_SHADERS GL_DELETE_STATUS
GL_INFO_LOG_LENGTH
GL_LINK_STATUS GL_PROGRAM_BINARY_RETRIEVABLE_HINT GL_TRANSFORM_FEEDBACK_BUFFER_MODE GL_TRANSFORM_FEEDBACK_VARYINGS GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH GL_VALIDATE_STATUS
params : 指向查询结果整数存储位置的指针

从程序信息⽇志中获取信息
void glGetPorgramInfoLog( GLuint program ,GLSizei maxLength, GLSizei *length , GLChar *infoLog )
program : 指向需要获取信息的程序对象句柄
maxLength : 存储信息日志的缓存区⼤小
length : 写入的信息日志⻓度(减去null 终⽌止符),如果不需要知道长度,这个参数可以为Null.
infoLog : 指向存储信息日志的字符缓存区的指针

void glUseProgram(GLuint program)
program: 设置为活动程序的程序对象句柄.

顶点着色器代码shaderv.vsh

attribute vec4 position;//顶点
attribute vec2 textCoordinate;//纹理坐标
varying lowp vec2 varyTextCoord;//把纹理坐标从顶点着色器传递到片元着色器

void main()
{
   //从顶点着色器传递到片元着色器
    varyTextCoord = textCoordinate;
   //顶点没有发生变化，直接输出给gl_Position
    gl_Position = position;
}

片元着色器代码shaderf.fsh

precision highp float;
varying lowp vec2 varyTextCoord;
uniform sampler2D colorMap;

void main()
{
    /*
     1.拿到纹理对应的坐标下的纹素。纹素：就是纹理对象像素的颜色值
     在片元着色器中有一个非常重要且高频的内建函数:texture2D(纹理， 纹理坐标),返回一个0~1四维向量的颜色值
 
     2.另一个非常重要且必须的内建变量 gl_FragColor, 即片元着色器执行后得到的结果,片元像素颜色
     */

    //lowp vec4 temp = texture2D(colorMap, varyTextCoord);
    //gl_FragColor = temp;
    gl_FragColor = texture2D(colorMap, varyTextCoord);
}

注意：
shaderf.fsh和shaderv.vsh此处为理解添加了中文注释，开发文件中一定去掉。
片元着色器，如果有120个像素点，这里就会执行120次,得到120个结果
在模拟器上也能运行GLSL，是因为模拟器使用CPU来模拟GPU。所以有时候在执行一个复杂的特效时，模拟器就会非常的卡。

加载着色器shader

//加载shader
-(GLuint)loadShaders:(NSString *)vert Withfrag:(NSString *)frag
{
    //1.定义2个临时着色器对象
    GLuint verShader, fragShader;//顶点着色器、片元着色器
    //创建program
    GLint program = glCreateProgram();
    
    //2.编译顶点着色程序、片元着色器程序
    //参数1：编译完存储的底层地址
    //参数2：编译的类型，GL_VERTEX_SHADER（顶点）、GL_FRAGMENT_SHADER(片元)
    //参数3：文件路径
    [self compileShader:&verShader type:GL_VERTEX_SHADER file:vert];
    [self compileShader:&fragShader type:GL_FRAGMENT_SHADER file:frag];
    
    //3.创建最终的程序将shader附着到program
    glAttachShader(program, verShader);
    glAttachShader(program, fragShader);
    
    //4.释放不需要的shader
    glDeleteShader(verShader);
    glDeleteShader(fragShader);
    
    return program;
}

编译着色器shader

//编译shader
- (void)compileShader:(GLuint *)shader type:(GLenum)type file:(NSString *)file{
    
    //1.读取文件路径字符串
    NSString* content = [NSString stringWithContentsOfFile:file encoding:NSUTF8StringEncoding error:nil];
    const GLchar* source = (GLchar *)[content UTF8String];
    
    //2.创建一个shader（根据type类型）
    *shader = glCreateShader(type);
    
    //3.将着色器源码附加到着色器对象上。
    //参数1：shader,要编译的着色器对象 *shader
    //参数2：numOfStrings,传递的源码字符串数量 1个
    //参数3：strings,着色器程序的源码（真正的着色器程序源码）
    //参数4：lenOfStrings,长度，具有每个字符串长度的数组，或NULL，这意味着字符串是NULL终止的
    glShaderSource(*shader, 1, &source,NULL);
    
    //4.把着色器源代码编译成目标代码
    glCompileShader(*shader);
}

5、实例用自定义shader加载图片

不采样GLKBaseEffect，使用编译链接自定义的着色器(shader)。用简单的glsl语言来实现顶点、片元着色器，并图形进行简单的变换。
实现思路：
1、创建图层
2、创建上下文
3、清空缓存区
4、设置RenderBuffer
5、设置FrameBuffer
6、开始绘制
5.1 创建图层

//1.设置图层
-(void)setupLayer
{
    //1.创建特殊图层
    /*重写layerClass，将CCView返回的图层从CALayer替换成CAEAGLLayer*/
    self.myEagLayer = (CAEAGLLayer *)self.layer;
 
    //2.设置scale
    [self setContentScaleFactor:[[UIScreen mainScreen]scale]];

    //3.设置描述属性，这里设置不维持渲染内容以及颜色格式为RGBA8
    /*
     kEAGLDrawablePropertyRetainedBacking  表示绘图表面显示后，是否保留其内容。
     kEAGLDrawablePropertyColorFormat
         可绘制表面的内部颜色缓存区格式，这个key对应的值是一个NSString指定特定颜色缓存区对象。默认是kEAGLColorFormatRGBA8；
     
     kEAGLColorFormatRGBA8：32位RGBA的颜色，4*8=32位
     kEAGLColorFormatRGB565：16位RGB的颜色，
     kEAGLColorFormatSRGBA8：sRGB代表了标准的红、绿、蓝，即CRT显示器、LCD显示器、投影机、打印机以及其他设备中色彩再现所使用的三个基本色素。sRGB的色彩空间基于独立的色彩坐标，可以使色彩在不同的设备使用传输中对应于同一个色彩坐标体系，而不受这些设备各自具有的不同色彩坐标的影响。
     */
    self.myEagLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys:@false,kEAGLDrawablePropertyRetainedBacking, kEAGLColorFormatRGBA8,kEAGLDrawablePropertyColorFormat,nil];
}

5.2 创建上下文

-(void)setupContext
{
    //1.指定OpenGL ES 渲染API版本，我们使用2.0
    EAGLRenderingAPI api = kEAGLRenderingAPIOpenGLES2;
    //2.创建图形上下文
    EAGLContext *context = [[EAGLContext alloc]initWithAPI:api];
    //3.判断是否创建成功
    if (!context) {
        NSLog(@"Create context failed!");
        return;
    }
    //4.设置图形上下文
    if (![EAGLContext setCurrentContext:context]) {
        NSLog(@"setCurrentContext failed!");
        return;
    }
    //5.将局部context，变成全局的
    self.myContext = context;
    
}

5.3 清空缓存区

//3.清空缓存区
-(void)deleteRenderAndFrameBuffer
{
    /*
     buffer分为frame buffer 和 render buffer2个大类。
     其中frame buffer 相当于render buffer的管理者。
     frame buffer object即称FBO。
     render buffer则又可分为3类。colorBuffer、depthBuffer、stencilBuffer。
     */
  
    glDeleteBuffers(1, &_myColorRenderBuffer);
    self.myColorRenderBuffer = 0;
    
    glDeleteBuffers(1, &_myColorFrameBuffer);
    self.myColorFrameBuffer = 0;
    
}

5.4 设置RenderBuffer

//4.设置RenderBuffer
-(void)setupRenderBuffer
{
    //1.定义一个缓存区ID
    GLuint buffer;
    
    //2.申请一个缓存区标志
    glGenRenderbuffers(1, &buffer);
    
    //3.
    self.myColorRenderBuffer = buffer;
    
    //4.将标识符绑定到GL_RENDERBUFFER
    glBindRenderbuffer(GL_RENDERBUFFER, self.myColorRenderBuffer);
    
    //5.将可绘制对象drawable object's  CAEAGLLayer的存储绑定到OpenGL ES renderBuffer对象
    [self.myContext renderbufferStorage:GL_RENDERBUFFER fromDrawable:self.myEagLayer];
    
}

5.5 设置FrameBuffer

//5.设置FrameBuffer
-(void)setupFrameBuffer
{
    //1.定义一个缓存区ID
    GLuint buffer;
    
    //2.申请一个缓存区标志
    //glGenRenderbuffers(1, &buffer);
    //glGenFramebuffers(1, &buffer);
    glGenBuffers(1, &buffer);
    
    //3.
    self.myColorFrameBuffer = buffer;
    
    //4.
    glBindFramebuffer(GL_FRAMEBUFFER, self.myColorFrameBuffer);
    
    /*生成帧缓存区之后，则需要将renderbuffer跟framebuffer进行绑定，
     调用glFramebufferRenderbuffer函数进行绑定到对应的附着点上，后面的绘制才能起作用
     */
    
    //5.将渲染缓存区myColorRenderBuffer 通过glFramebufferRenderbuffer函数绑定到 GL_COLOR_ATTACHMENT0上。
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, self.myColorRenderBuffer);
    
}

5.6 开始绘制

//6.开始绘制
-(void)renderLayer
{
    //设置清屏颜色
    glClearColor(0.3f, 0.45f, 0.5f, 1.0f);
    //清除屏幕
    glClear(GL_COLOR_BUFFER_BIT);
    
    //1.设置视口大小
    CGFloat scale = [[UIScreen mainScreen]scale];
    glViewport(self.frame.origin.x * scale, self.frame.origin.y * scale, self.frame.size.width * scale, self.frame.size.height * scale);
    
    //2.读取顶点着色程序、片元着色程序
    NSString *vertFile = [[NSBundle mainBundle]pathForResource:@"shaderv" ofType:@"vsh"];
    NSString *fragFile = [[NSBundle mainBundle]pathForResource:@"shaderf" ofType:@"fsh"];
    
    NSLog(@"vertFile:%@",vertFile);
    NSLog(@"fragFile:%@",fragFile);
    
    //3.加载shader
    self.myPrograme = [self loadShaders:vertFile Withfrag:fragFile];
    
    //4.链接
    glLinkProgram(self.myPrograme);
    GLint linkStatus;
    //获取链接状态
    glGetProgramiv(self.myPrograme, GL_LINK_STATUS, &linkStatus);
    if (linkStatus == GL_FALSE) {
        GLchar message[512];
        glGetProgramInfoLog(self.myPrograme, sizeof(message), 0, &message[0]);
        NSString *messageString = [NSString stringWithUTF8String:message];
        NSLog(@"Program Link Error:%@",messageString);
        return;
    }
    
    NSLog(@"Program Link Success!");
    //5.使用program
    glUseProgram(self.myPrograme);
    
    //6.设置顶点、纹理坐标
    //前3个是顶点坐标，后2个是纹理坐标
    GLfloat attrArr[] =
    {
        0.5f, -0.5f, -1.0f,     1.0f, 0.0f,
        -0.5f, 0.5f, -1.0f,     0.0f, 1.0f,
        -0.5f, -0.5f, -1.0f,    0.0f, 0.0f,
        
        0.5f, 0.5f, -1.0f,      1.0f, 1.0f,
        -0.5f, 0.5f, -1.0f,     0.0f, 1.0f,
        0.5f, -0.5f, -1.0f,     1.0f, 0.0f,
    };
    
    
    //7.-----处理顶点数据--------
    //(1)顶点缓存区
    GLuint attrBuffer;
    //(2)申请一个缓存区标识符
    glGenBuffers(1, &attrBuffer);
    //(3)将attrBuffer绑定到GL_ARRAY_BUFFER标识符上
    glBindBuffer(GL_ARRAY_BUFFER, attrBuffer);
    //(4)把顶点数据从CPU内存复制到GPU上
    glBufferData(GL_ARRAY_BUFFER, sizeof(attrArr), attrArr, GL_DYNAMIC_DRAW);

    //8.将顶点数据通过myPrograme中的传递到顶点着色程序的position
    //1.glGetAttribLocation,用来获取vertex attribute的入口的.
    //2.告诉OpenGL ES,通过glEnableVertexAttribArray，
    //3.最后数据是通过glVertexAttribPointer传递过去的。
    
    //(1)注意：第二参数字符串必须和shaderv.vsh中的输入变量：position保持一致
    GLuint position = glGetAttribLocation(self.myPrograme, "position");
    
    //(2).设置合适的格式从buffer里面读取数据
    glEnableVertexAttribArray(position);
    
    //(3).设置读取方式
    //参数1：index,顶点数据的索引
    //参数2：size,每个顶点属性的组件数量，1，2，3，或者4.默认初始值是4.
    //参数3：type,数据中的每个组件的类型，常用的有GL_FLOAT,GL_BYTE,GL_SHORT。默认初始值为GL_FLOAT
    //参数4：normalized,固定点数据值是否应该归一化，或者直接转换为固定值。（GL_FALSE）
    //参数5：stride,连续顶点属性之间的偏移量，默认为0；
    //参数6：指定一个指针，指向数组中的第一个顶点属性的第一个组件。默认为0
    glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, NULL);
    
    
    //9.----处理纹理数据-------
    //(1).glGetAttribLocation,用来获取vertex attribute的入口的.
    //注意：第二参数字符串必须和shaderv.vsh中的输入变量：textCoordinate保持一致
    GLuint textCoor = glGetAttribLocation(self.myPrograme, "textCoordinate");
    
    //(2).设置合适的格式从buffer里面读取数据
    glEnableVertexAttribArray(textCoor);
    
    //(3).设置读取方式
    //参数1：index,顶点数据的索引
    //参数2：size,每个顶点属性的组件数量，1，2，3，或者4.默认初始值是4.
    //参数3：type,数据中的每个组件的类型，常用的有GL_FLOAT,GL_BYTE,GL_SHORT。默认初始值为GL_FLOAT
    //参数4：normalized,固定点数据值是否应该归一化，或者直接转换为固定值。（GL_FALSE）
    //参数5：stride,连续顶点属性之间的偏移量，默认为0；
    //参数6：指定一个指针，指向数组中的第一个顶点属性的第一个组件。默认为0
    glVertexAttribPointer(textCoor, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*5, (float *)NULL + 3);
    
    //10.加载纹理(图片解压缩)
    [self setupTexture:@"imgName"];
    
    //11. 设置纹理采样器 sampler2D
    glUniform1i(glGetUniformLocation(self.myPrograme, "colorMap"), 0);
    
    //12.绘图
    glDrawArrays(GL_TRIANGLES, 0, 6);
    
    //13.从渲染缓存区显示到屏幕上
    [self.myContext presentRenderbuffer:GL_RENDERBUFFER];
    
}

绘制中加载纹理的部分

//从图片中加载纹理
- (GLuint)setupTexture:(NSString *)fileName {
    
    //1、将 UIImage 转换为 CGImageRef
    CGImageRef spriteImage = [UIImage imageNamed:fileName].CGImage;
    
    //判断图片是否获取成功
    if (!spriteImage) {
        NSLog(@"Failed to load image %@", fileName);
        exit(1);
    }
    
    //2、读取图片的大小，宽和高
    size_t width = CGImageGetWidth(spriteImage);
    size_t height = CGImageGetHeight(spriteImage);
    
    //3.获取图片字节数 宽*高*4（RGBA）
    GLubyte * spriteData = (GLubyte *) calloc(width * height * 4, sizeof(GLubyte));
    
    //4.创建上下文
    /*
     参数1：data,指向要渲染的绘制图像的内存地址
     参数2：width,bitmap的宽度，单位为像素
     参数3：height,bitmap的高度，单位为像素
     参数4：bitPerComponent,内存中像素的每个组件的位数，比如32位RGBA，就设置为8
     参数5：bytesPerRow,bitmap的没一行的内存所占的比特数
     参数6：colorSpace,bitmap上使用的颜色空间  kCGImageAlphaPremultipliedLast：RGBA
     */
    CGContextRef spriteContext = CGBitmapContextCreate(spriteData, width, height, 8, width*4,CGImageGetColorSpace(spriteImage), kCGImageAlphaPremultipliedLast);
    

    //5、在CGContextRef上--> 将图片绘制出来
    /*
     CGContextDrawImage 使用的是Core Graphics框架，坐标系与UIKit 不一样。UIKit框架的原点在屏幕的左上角，Core Graphics框架的原点在屏幕的左下角。
     CGContextDrawImage 
     参数1：绘图上下文
     参数2：rect坐标
     参数3：绘制的图片
     */
    CGRect rect = CGRectMake(0, 0, width, height);
   
    //6.使用默认方式绘制
    CGContextDrawImage(spriteContext, rect, spriteImage);
   
    //7、画图完毕就释放上下文
    CGContextRelease(spriteContext);
    
    //8、绑定纹理到默认的纹理ID（
    glBindTexture(GL_TEXTURE_2D, 0);
    
    //9.设置纹理属性
    /*
     参数1：纹理维度
     参数2：线性过滤、为s,t坐标设置模式
     参数3：wrapMode,环绕模式
     */
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
    float fw = width, fh = height;
    
    //10.载入纹理2D数据
    /*
     参数1：纹理模式，GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
     参数2：加载的层次，一般设置为0
     参数3：纹理的颜色值GL_RGBA
     参数4：宽
     参数5：高
     参数6：border，边界宽度
     参数7：format
     参数8：type
     参数9：纹理数据
     */
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fw, fh, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteData);
    
    //11.释放spriteData
    free(spriteData);   
    return 0;
}

运行得到的效果图1
图片是上下颠倒的(纹理坐标的原点在左下角为(0,0),屏幕在左上角)。

6、解决图片翻转问题

6.1 使用旋转矩阵翻转图形,不翻转纹理
添加矩阵翻转

-(void)rotateTextureImage
{
    //注意，想要获取shader里面的变量，这里记得要在glLinkProgram后面，后面，后面！
    //1. rotate等于shaderv.vsh中的uniform属性，rotateMatrix
    GLuint rotate = glGetUniformLocation(self.myPrograme, "rotateMatrix");
    
    //2.获取渲旋转的弧度
    float radians = 180 * 3.14159f / 180.0f;
    //3.求得弧度对于的sin\cos值
    float s = sin(radians);
    float c = cos(radians);
    
    //4.因为在3D课程中用的是横向量，在OpenGL ES用的是列向量
    /*
     参考Z轴旋转矩阵
     */
    GLfloat zRotation[16] = {
        c,-s,0,0,
        s,c,0,0,
        0,0,1,0,
        0,0,0,1
    };
    
    //5.设置旋转矩阵
    /*
     glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
     location : 对于shader 中的ID
     count : 个数
     transpose : 转置
     value : 指针
     */
    glUniformMatrix4fv(rotate, 1, GL_FALSE, zRotation);
    
}

顶点着色器(顶点乘以翻转矩阵)

attribute vec4 position;
attribute vec2 textCoordinate;
uniform mat4 rotateMatrix;
varying lowp vec2 varyTextCoord;

void main() {
    varyTextCoord = textCoordinate;
    vec4 vPos = position;
    vPos = vPos * rotateMatrix;
    gl_Position = vPos;
}

绘制时调用(绘制方法添加)

···
//11. 设置纹理采样器 sampler2D
glUniform1i(glGetUniformLocation(self.myPrograme, "colorMap"), 0);

[self rotateTextureImage];

    //12.绘图
glDrawArrays(GL_TRIANGLES, 0, 6);
···

6.2 解压图片时,将图片源文件翻转

//6.使用默认方式绘制
CGContextDrawImage(spriteContext, rect, spriteImage);

//将图片源文件翻转
// CGContextTranslateCTM(spriteContext, rect.origin.x, rect.origin.y);// 可以不写
CGContextTranslateCTM(spriteContext, 0, rect.size.height);
CGContextScaleCTM(spriteContext, 1.0, -1.0);
//CGContextTranslateCTM(spriteContext, -rect.origin.x, -rect.origin.y);// 可以不写
CGContextDrawImage(spriteContext, rect, spriteImage);

//7、画图完毕就释放上下文
CGContextRelease(spriteContext);

6.3 修改片元着色器,纹理坐标

precision highp float;
varying lowp vec2 varyTextCoord;
uniform sampler2D colorMap;
void main() {
    gl_FragColor = texture2D(colorMap, vec2(varyTextCoord.x, 1.0 - varyTextCoord.y));
}

6.4 修改顶点着色器,纹理坐标

attribute vec4 position;
attribute vec2 textCoordinate;
varying lowp vec2 varyTextCoord;

void main() {
    varyTextCoord = vec2(textCoordinate.x,1.0-textCoordinate.y);
    gl_Position = position;
}

6.5 直接从源纹理坐标数据修改

GLfloat attrArr[] = {
    0.5f, -0.5f, 0.0f,        1.0f, 1.0f, //右下
    -0.5f, 0.5f, 0.0f,        0.0f, 0.0f, // 左上
    -0.5f, -0.5f, 0.0f,       0.0f, 1.0f, // 左下
    0.5f, 0.5f, 0.0f,         1.0f, 0.0f, // 右上
    -0.5f, 0.5f, 0.0f,        0.0f, 0.0f, // 左上
    0.5f, -0.5f, 0.0f,        1.0f, 1.0f, // 右下
};

运行结果图2

7、为什么要⽤FrameBuffer和 RenderBuffer? 它们是什么关系?

⼀个renderbuffer对象是通过应⽤分配的⼀个2D图像缓存区。renderbuffer能够被⽤来分配和存储颜⾊、深度或者模板值。也能够在⼀个framebuffer被⽤作颜⾊、深度、模板的附件。⼀个renderbuffer是⼀个类似于屏幕窗⼝系统提供可绘制的表⾯。⽐如pBuffer。⼀个renderbuffer,它并不能直接的使⽤像⼀个GL纹理。

⼀个frameBuffer对象(通常被称为⼀个FBO)。是⼀个收集颜⾊、深度和模板缓存区的附着点。描述属性的状态，例如颜⾊、深度和模板缓存区的⼤⼩和格式，都关联到FBO(Frame Buffer Object)。并且纹理的名字和renderBuffer对象也都是关联于FBO。各种各样的2D图形能够被附着framebuffer对象的颜⾊附着点。它们包含了renderbuffer对象存储的颜⾊值、⼀个2D纹理或⽴⽅体贴图或者⼀个mip-level的⼆维切⾯在3D纹理。同样，各种各样的2D图形包含了当时的深度值可以附加到⼀个FBO的深度附着点钟去。唯⼀的⼆维图像，能够附着在FBO的模板附着点,是一个renderbuffer对象存储模板值。

FrameBuffer Objects,RenderBuffer Objects and Textures