03-初始OpenGL ES--用GLSL简单实现加载一张图片

前言

• ios中使用OpenGL ES有两种方式，一种是使用GLKit，一种是使用GLSL。
• 上一篇中记录了如何用GLKit简单加载一张图片。
• 这一篇主要记录如何用GLSL简单实现加载一张图片。

1.使用GLSL之前，需要了解的几个知识点

1.1 着色器的渲染流程

着色器的渲染流程，如下图：

• 在使用GLKit时，是不需要单独处理着色器的。但是用GLSL实现OpenGS时，必须要手动实现两个着色器：顶点着色器和片元着色器。
• 也就说，到时候，需要在Xcode中，手动创建两个着色器，如下图：
  

1.2 语法介绍修饰符

• 在OpenGL 3.0之前，OpenGL 包含一个固定功能的管线，它可以在不使⽤着色器的情况下处理几何与像素数据。
• 在3.1版本开始，固定管线从核⼼ 模式去掉。因此现在需要使⽤着色器来完成工作。
• OpenGL 中的图元只不过是顶点的集合以预定义的方式结合一起罢了。下图为管线流程：
  

上图中，可以看出，顶点着色器接收Attribute数据；Uniforms和TextureData可以给顶点着色器赋值，也可以给片元着色器赋值。在赋值过程中，需要遵守一些协议，因此有了特别重要的变量限定符：uniform,attribute,varying.

1.2.1 Uniform

Uniform:外部application传递给vertex\fragment shader 变量的修饰符。

它是通过glUnifrom**()函数调用的
在vertex，fragment shader程序内容使用， Uniform和contst类型，表示它不能被shader修改。

注意：

• 被Uniform修改的变量，只能被shader使用，不能修改；
• 如果Uniform 在vertex、fragment 两者的声明方式一样，则可以被vertex、fragment 共享。可以理解为：vertex、fragment 的全局变量

使用场景：

变换矩阵、素材、光照、颜色等

实例：

uniform mat4 viewProjMatrix; 
uniform mat4 viewMatrix; 
uniform mat4 lightPosition; // 光源位置

1.2.2 attribute

• attribute变量， 只能在vertex shader中使用。
• 在applicatiion中，用glBindAttribLocation()函数 来绑定每个变量的位置，
• 然后在使用glVertexAttribPointer()为变量赋值，
• 最后用glGetAttribLocation()来获取变量。

使用场景：

顶点坐标、发现、纹理坐标、顶点颜色等等

1.2.3 varying

• varying 是vertex和fragment shader之间做数据传递使用的。
• 如果需要做传递，则必须保证vertex shader和fragment shader 中两者的声明必须保持一致（修饰符、类型、变量名）。
• 否则，不可实现数据传递。

使用场景：

纹理坐标、顶点颜色等等。

1.3 了解FrameBuffer和RenderBuffer

1.3.1 什么是RenderBuffer？

渲染缓存是为离线渲染而新引进的。它允许将一个场景直接渲染到一个渲染缓存对象中，而不是渲染到纹理对象中。渲染缓存对象是用于存储单幅图像的数据存储区域。该图像按照一种可渲染的内部格式存储。它用于存储没有相关纹理格式的OpenGL逻辑缓存，比如模板缓存或者深度缓存。官方的解释如下：

A renderbuffer object is a 2D image buffer allocated by the application. The renderbuffer can be used to allocate and store color, depth, or stencil values and can be used as a color, depth, or stencil attachment in a framebuffer Color Attachment Depth Attachment Stencil Attachment FrameBuffer Objects object. A renderbuffer is similar to an off-screen window system provided drawable surface, such as a pbuffer. A renderbuffer, however, cannot be directly used as a GL texture.

解释如下：

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

1.3.2 什么是FrameBuffer？

在OpenGL渲染管线中，几何数据和纹理经过多次转化和多次测试，最后以二维像素的形式显示在屏幕上。OpenGL管线的最终渲染目的地被称作帧缓冲（framebuffer）。帧缓冲是一些二维数组和OpenG所使用的存储区的集合：颜色缓冲、深度缓冲、模板缓冲和累计缓冲。默认情况下，OpenGL将帧缓冲区作为渲染最终目的地。此帧缓冲区完全由系统生成和管理。

我们知道，在应用程序调用任何的OpenGL ES命令之前，需要首先创建一个渲染上下文和绘图表面，并使之成为现行上下文和表面，之前在渲染的时候，其实一直使用的是原生窗口系统（比如EAGL，GLFW）提供的渲染上下文和绘图表面（即帧缓冲区）。 一般情况下，我们只需要系统提供的帧缓冲区作为绘图表面，但是又有些特殊情况，比如阴影贴图、动态反射、处理后特效等需要渲染到纹理操作的，如果使用系统提供的帧缓冲区，效率会比较低低下，因此需要自定义自己的帧缓冲区。官方解释如下：

A framebuffer object (often referred to as an FBO) is a collection of color, depth, and stencil buffer attachment points; state that describes properties such as the size and format of the color, depth, and stencil buffers attached to the FBO; and the names of the texture and renderbuffer objects attached to the FBO. Various 2D images can be attached to the color attachment point in the framebuffer object. These include a renderbuffer object that stores color values, a mip-level of a 2D texture or a cube map face, or even a mip-level of a 2D slice in a 3D texture. Similarly, various 2D images contain- ing depth values can be attached to the depth attachment point of an FBO. These can include a renderbuffer, a mip-level of a 2D texture or a cubemap
face that stores depth values. The only 2D image that can be attached to the stencil attachment point of an FBO is a renderbuffer object that stores stencil values.

解释如下：

• ⼀个 frameBuffer 对象(通常被称为⼀个FBO),是⼀个收集颜

⾊、深度和模板缓存区的附着点。

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

1.3 了解CAEAGLLayer和EAGLContext

1.3.1 CAEAGLLayer

CAEAGLLay：在iOS和tvOS上绘制OpenGL ES内容的图层，继承与CALayer。官方的解释如下：

本人的理解如下，有错误请指出：

• 当你打算用OpenGL渲染时，可以中这个类作为底部视图。通过调用layerClass这个类方法，返回CAEAGLLayer类对象。如下：

+(Class)layerClass {
return [CAEAGLLayer class];
}

• 你可以修改这个类的drawableProperties属性，这个属性可以配置颜色格式。该属性的声明如下：

@property(nullable, copy) NSDictionary<NSString*, id>* drawableProperties;

这个属性的两个可选值如下：

kEAGLDrawablePropertyRetainedBacking:表示绘图表面显示后，是否保留其内容
这个key的值，是一个通过NSNumber包装的bool值。
如果是false，则显示内容后不能依赖于相同的内容，ture表示显示后内容不变。
一般只有在需要内容保存不变的情况下，才建议设置使用,因为会导致性能降低、内存使用量增减。一般设置为flase.

kEAGLDrawablePropertyColorFormat:可绘制表面的内部颜色缓存区格式
这个key对应的值是一个NSString指定特定颜色缓存区对象。默认是kEAGLColorFormatRGBA8；
kEAGLColorFormatRGBA8：32位RGBA的颜色，4*8=32位
kEAGLColorFormatRGB565：16位RGB的颜色，
kEAGLColorFormatSRGBA8：sRGB代表了标准的红、绿、蓝，
即CRT显示器、LCD显示器、投影机、打印机以及其他设备中色彩再现所使用的三个基本色素。
sRGB的色彩空间基于独立的色彩坐标，可以使色彩在不同的设备使用传输中对应于同一个色彩坐标体系，
而不受这些设备各自具有的不同色彩坐标的影响。

• CALayer默认是透明的，必须将它设为不透明才能将其可见

1.3.1 CAEAGLLayer

EAGLContext是苹果在ios平台上实现opengles渲染层，用于渲染结果在目标suffer上更新。
苹果对于这个类的说明如下：

本人的理解如下：
EAGLContext 对象是管理OpenGL ES渲染的图层，存储OpenGL ES中需要绘制中使用的信息、命令、资源的状态。必须需要一个渲染图层才能要执行OpenGL ES的命令。

2.用简单的GLSL语言实现图片的加载及旋转

不采样GLKBaseEffect，使用编译链接自定义的着色器（shader）。用简单的glsl语言来实现顶点、片元着色器，并图形进行简单的变换。思路：

1.创建图层
2.创建上下文
3.清空缓存区
4.设置RenderBuffer
5.设置FrameBuffer
6.开始绘制
7.重写layoutSubviews

2.0 项目的准备资料

• 准备一张图片
• 创建工程
• 新建一个View，取名为”YZView“（名字自行定义）
• 在YZView的.m中导入#import <OpenGLES/ES2/gl.h>
• 设置需要的属性，如下：

@interface YZView ()

//在iOS和tvOS上绘制OpenGL ES内容的图层，继承与CALayer
@property(nonatomic,strong)CAEAGLLayer *myEagLayer;

@property(nonatomic,strong)EAGLContext *myContext;

@property(nonatomic,assign)GLuint myColorRenderBuffer;
@property(nonatomic,assign)GLuint myColorFrameBuffer;

@property(nonatomic,assign)GLuint myPrograme;

@end

2.1 创建图层

//1. 设置图层
- (void)setupLayer {
    //给图层开辟空间
    /*
     重写layerClass, 将YZView返回的图层将CALayer替换成CAEAGLLayer
     */
    self.myEagLayer = (CAEAGLLayer *)self.layer;
    
    //设置放大倍数
    [self setContentScaleFactor:[UIScreen mainScreen].scale];
    
    //CALayer默认是透明的,必将将它设为不透明才能将其可见
    self.myEagLayer.opaque = YES;
    
    //设置描述属性,这里设置不维持渲染内容,颜色格式为RGBA8
    /*
     kEAGLDrawablePropertyRetainedBacking:表示绘图表面显示后，是否保留其内容
     这个key的值，是一个通过NSNumber包装的bool值。
     如果是false，则显示内容后不能依赖于相同的内容，ture表示显示后内容不变。
     一般只有在需要内容保存不变的情况下，才建议设置使用,因为会导致性能降低、内存使用量增减。一般设置为flase.
     */
    /*
     kEAGLDrawablePropertyColorFormat:可绘制表面的内部颜色缓存区格式
     这个key对应的值是一个NSString指定特定颜色缓存区对象。默认是kEAGLColorFormatRGBA8；
     kEAGLColorFormatRGBA8：32位RGBA的颜色，4*8=32位
     kEAGLColorFormatRGB565：16位RGB的颜色，
     kEAGLColorFormatSRGBA8：sRGB代表了标准的红、绿、蓝，
     即CRT显示器、LCD显示器、投影机、打印机以及其他设备中色彩再现所使用的三个基本色素。
     sRGB的色彩空间基于独立的色彩坐标，可以使色彩在不同的设备使用传输中对应于同一个色彩坐标体系，
     而不受这些设备各自具有的不同色彩坐标的影响。
     */
    self.myEagLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:false], kEAGLDrawablePropertyRetainedBacking,kEAGLColorFormatRGBA8, kEAGLDrawablePropertyColorFormat ,nil];
}

2.2 设置上下文

//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;
}

2.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, &_myColorFrameBuffer);
    self.myColorRenderBuffer = 0;
    
    glDeleteBuffers(1, &_myColorFrameBuffer);
    self.myColorFrameBuffer = 0;
}

2.4 设置RenderBuffer

- (void)setupRenderBuffer {
    //1.定义一个缓存区
    GLuint buffer;
    //2.申请一个缓存区标志
    glGenRenderbuffers(1, &buffer);
    //3.设置强引用
    self.myColorRenderBuffer = buffer;
    //4.将标识符绑定到GL_RENDERBUFFER上
    glBindRenderbuffer(GL_RENDERBUFFER, self.myColorRenderBuffer);
    
    //myColorRenderBuffer渲染缓存区分配存储空间
    /*
     frame buffer紧紧是管理者,不需要分配空间.
     render buffer的存储空间的分配,对于不同的render buffer，使用不同的API进行分配，
     而只有分配空间的时候，render buffer句柄才确定其类型
     */
    [self.myContext renderbufferStorage:GL_RENDERBUFFER fromDrawable:self.myEagLayer];
}

2.5 设置FrameBuffer

//5.设置FrameBuffer
- (void)setupFrameBuffer {
    //1.定义一个缓存区
    GLuint buffer;
    //2.申请一个缓存区标志
    glGenBuffers(1, &buffer);
    //3.设置强引用
    self.myColorFrameBuffer = buffer;
    //4.将标识符绑定到GL_FRAMEBUFFER上
    glBindFramebuffer(GL_FRAMEBUFFER, self.myColorFrameBuffer);
    /*
     生成空间之后,则需要将renderBuffer跟framebuffer进行绑定,
     调用glFramebufferRenderbuffer函数进行绑定,后面的绘制才能起作用.
     */
    //5. 将_myColorRenderBuffer 通过glFramebufferRenderbuffer函数绑定到GL_COLOR_ATTACHMENT0
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, self.myColorRenderBuffer);
}

2.6 开始绘制

2.6.1 设置加载纹理的方法

过程如下：

1. 加载图片
   2.读取图片的大小，宽和高
   3.获取图片字节数 宽高4（RGBA）
   4.创建上下文
   5、在CGContextRef上绘图
   6、画图完毕就释放上下文
   7、绑定纹理到默认的纹理ID
   8.设置纹理属性
   9.载入纹理2D数据
   10.绑定纹理

//设置纹理
- (GLuint)setupTexture:(NSString *)fileName {
    //1、获取图片的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);
     //使用默认方式绘制，发现图片是倒的。
     CGContextDrawImage(spriteContext, CGRectMake(0, 0, width, height), spriteImage);
     /*
      解决图片倒置的方法(2):
      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);
      */
    
     //6、画图完毕就释放上下文
     CGContextRelease(spriteContext);
     
     //绑定纹理到默认的纹理ID（这里只有一张图片，故而相当于默认于片元着色器里面的colorMap，如果有多张图不可以这么做）
     glBindTexture(GL_TEXTURE_2D, 0);
     
     //设置纹理属性
     /*
      参数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;
     //载入纹理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);
     
     //绑定纹理
     /*
      参数1：纹理维度
      参数2：纹理ID,因为只有一个纹理，给0就可以了。
      */
     glBindTexture(GL_TEXTURE_2D, 0);
     
     //释放spriteData
     free(spriteData);
     
     return 0;
}

2.6.2 顶点着色器/片元着色器 编译以及链接过程

1.指定属性
2.设置源码
3.编译
4.链接
5.指定属性索引

• 先创建一个顶点着色器，shaderv.vsh

新建一个顶点着色器，命名为：shaderv.vsh(名称可以改，自己知道这是顶点着色器即可)。
并且必须给gl_Position赋值

添加代码如下：

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;
}

• 创建一个片元着色器

新建一个片元着色器，命名为：shaderf.fsh(名称可以改，自己知道这是顶点着色器即可).
必须给gl_FragColor赋值
添加代码如下：

varying lowp vec2 varyTextCoord;

uniform sampler2D colorMap;

void main()
{
    gl_FragColor = texture2D(colorMap, varyTextCoord);
}

• 设置编译链接顶点着色器和片元着色器

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

• 设置加载着色器的方法

//加载shader
- (GLuint)loadShaders:(NSString *)vert withFrag:(NSString *)frag {
    //定义2个临时着色器对象
    GLuint verShader, fragShader;
    //创建program
    GLint program = glCreateProgram();
        
    //编译顶点着色程序和片元着色器程序
    //参数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];
    
    //创建最终的程序
    glAttachShader(program, verShader);
    glAttachShader(program, fragShader);
    
    //释放不需要的shader
    glDeleteShader(verShader);
    glDeleteShader(fragShader);
    
    return program;

}

• 绘制的方法

//6.开始绘制
- (void)renderLayer {
    //设置清屏颜色
    glClearColor(0.0f, 1.0f, 0.0f, 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];// [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,
    };
    
    //---处理顶点数据---
    //顶点缓存区
    GLuint attrBuffer;
    //申请一个缓存区标识符
    glGenBuffers(1, &attrBuffer);
    //将attrBuffer绑定到GL_ARRAY_BUFFER标识符上
    glBindBuffer(GL_ARRAY_BUFFER, attrBuffer);
    //把顶点数据从CPU内存复制到GPU上
    glBufferData(GL_ARRAY_BUFFER, sizeof(attrArr), attrArr, GL_DYNAMIC_DRAW);
    
    //将顶点数据通过myProgram中的代码传递到顶点着色程序的position
    /*
     过程如下:
     1. glGetAttribLocation,是用来获取vertex attribute的入口
     2. 通过glEnableVertexAttribArray告诉OpenGL ES 顶点数据
     3. 最后数据是通过glVertexAttribPointer传递过去的
     */
    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);
    
    //---处理纹理数据---
    //1. glGetAttriLocation,用来读取fragment attribute的入口
    GLuint textCoor = glGetAttribLocation(self.myPrograme, "textCoordinate");

    //2.设置合适的格式从buffer里面读取数据
    glEnableVertexAttribArray(textCoor);

    //3. 设置读取方式
    glVertexAttribPointer(textCoor, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*5, (float *)NULL + 3);

    
    //加载纹理
    
    [self setupTexture:@"timg-3"];
    
    //注意，想要获取shader里面的变量，这里记得要在glLinkProgram后面，后面，后面！
    /*
     一个一致变量在一个图元的绘制过程中是不会改变的，所以其值不能在glBegin/glEnd中设置。
     一致变量适合描述在一个图元中、一帧中甚至一个场景中都不变的值。
     一致变量在顶点shader和片断shader中都是只读的。
     首先你需要获得变量在内存中的位置，这个信息只有在连接程序之后才可获得
     */
    //rotate等于shaderv.vsh中的uniform属性，rotateMatrix
    GLuint rotate = glGetUniformLocation(self.myPrograme, "rotateMatrix");
    
    //获取渲染的弧度
    float radians = 0 * 3.14159f / 180.0f;
    //求得弧度对于的sin\cos值
    float s = sin(radians);
    float c = cos(radians);
    
    //设置旋转矩阵数据
    GLfloat zRotation[16] = {
        c, -s, 0, 0,
        s, c, 0, 0,
        0, 0, 1.0, 0,
        0.0, 0, 0, 1.0
    };
    
    //设置旋转矩阵
    glUniformMatrix4fv(rotate, 1, GL_FALSE, (GLfloat *)&zRotation[0]);
    
    glDrawArrays(GL_TRIANGLES, 0, 6);
    
    [self.myContext presentRenderbuffer:GL_RENDERBUFFER];
}

2.7 重写layoutSubviews

-(void)layoutSubviews
{
    //1.设置图层
    [self setupLayer];
    
    //2.设置图形上下文
    [self setupContext];
    
    //3.清空缓存区
    [self deleteRenderAndFrameBuffer];
    
    //4.设置RenderBuffer
    [self setupRenderBuffer];
    
    //5.设置FrameBuffer
    [self setupFrameBuffer];
    
    //6.开始绘制
    [self renderLayer]; 
}

2.8 使用

#import "ViewController.h"
#import "YZView.h"

@interface ViewController ()

@property (nonatomic, strong) YZView *myView;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    //需要修改storyBoard中view的父类为YZView
    self.myView = (YZView *)self.view;
}

@end

效果图如下：

3.注意点

3.1 坐标点位置

• OpenGL ES 的世界坐标系是[-1,1],故而(0,0)是屏幕的正中间
• 顶点数据,前3个顶点坐标x,y,z ;后面2个是纹理坐标
• 纹理坐标系的取值范围是[0,1],原点在左下角.故而(0,0)在左小角,(1,1)在右上角
• 一个正方形 由2个三角形构成

3.2 坐标系

• CGContextDrawImage 使用的是Core Graphics框架，坐标系与UIKit 不一样。
• UIKit框架的原点在屏幕的左上角，Core Graphics框架的原点在屏幕的左下角。

3.3 坐标系不一致产生的结果

坐标系不一致容易产生的结果就是加载出来的视图是倒置的。
解决方法：

• 第一种：注意加载的坐标点
  如上面加载顶点的数据可以修改成如下：

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, // 右下
};

• 第二种：将图片选择180度

float radians = 180 * 3.14159f / 180.0f;

• 第三种：绘制时修改

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);
(这种方式不推荐，推荐第一种)