opengl es 第一课(诡异的3D旋转)

诡异的3D旋转

  • (void)glkView:(GLKView *)view drawInRect:(CGRect)rect
    在以上方法回掉里面修改
    cEffect.transform.modelviewMatrix
    这个属性会触发过渡动画???

interface

1
2
3
4
5
6
7
8
9
10
11
12
13
#import <UIKit/UIKit.h>
#import <GLKit/GLKit.h>
#import "ViewController.h"
#import <OpenGLES/ES3/gl.h>
#import <OpenGLES/ES3/glext.h>

@interface ViewController ()
{
EAGLContext *context;
GLKBaseEffect *cEffect;
GLKBaseEffect *c3Effect;
}
@end

implementation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
@implementation ViewController

- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.

//1.OpenGL ES 相关初始化
[self setUpConfig];

//2.加载顶点/纹理坐标数据
[self setUpVertexData];

//3.加载纹理数据(使用GLBaseEffect)
[self setUpTexture];
}


static float rod = 0.1;
- (IBAction)left:(id)sender {


// GLKMatrix4 mat = GLKMatrix4RotateX(cEffect.transform.modelviewMatrix, 0.08);
// mat = GLKMatrix4RotateZ(mat, 0.05);
// cEffect.transform.modelviewMatrix = mat;

// [((GLKView *)self.view) display];
}

#pragma mark -- OpenGL ES setUp

-(void)setUpTexture
{
//1.获取纹理图片路径
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"kunkun" ofType:@"jpg"];
NSString *file2Path = [[NSBundle mainBundle]pathForResource:@"1" ofType:@"jpg"];

//2.设置纹理参数
//纹理坐标原点是左下角,但是图片显示原点应该是左上角.
NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:@(1),GLKTextureLoaderOriginBottomLeft, nil];

GLKTextureInfo *textureInfo = [GLKTextureLoader textureWithContentsOfFile:filePath options:options error:nil];
GLKTextureInfo *texture2Info = [GLKTextureLoader textureWithContentsOfFile:file2Path options:options error:nil];

//3.使用苹果GLKit 提供GLKBaseEffect 完成着色器工作(顶点/片元)
cEffect = [[GLKBaseEffect alloc]init];
cEffect.texture2d0.enabled = GL_TRUE;
cEffect.texture2d0.name = texture2Info.name;

cEffect.texture2d1.enabled = GL_TRUE;
cEffect.texture2d1.name = textureInfo.name;


}

-(void)setUpVertexData
{
//1.设置顶点数组(顶点坐标,纹理坐标)
/*
纹理坐标系取值范围[0,1];原点是左下角(0,0);
故而(0,0)是纹理图像的左下角, 点(1,1)是右上角.
*/
GLfloat vertexData[] = {
// 后面的
0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
0.5, 0.5, 0.5f, 1.0f, 1.0f, //右上
-0.5, 0.5, 0.5f, 0.0f, 1.0f, //左上

0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
-0.5, 0.5, 0.5f, 0.0f, 1.0f, //左上
-0.5, -0.5, 0.5f, 0.0f, 0.0f, //左下

// 前面的
0.5, -0.5, -0.5f, 1.0f, 0.0f, //右下
0.5, 0.5, -0.5f, 1.0f, 1.0f, //右上
-0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上

0.5, -0.5, -0.5f, 1.0f, 0.0f, //右下
-0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上
-0.5, -0.5, -0.5f, 0.0f, 0.0f, //左下


// 左边的
0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
0.5, 0.5, 0.5f, 1.0f, 1.0f, //右上
0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上

0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上
0.5, -0.5, -0.5f, 0.0f, 0.0f, //左下

// 右边的
-0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
-0.5, 0.5, 0.5f, 1.0f, 1.0f, //右上
-0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上

-0.5, -0.5, 0.5f, 1.0f, 0.0f, //右下
-0.5, 0.5, -0.5f, 0.0f, 1.0f, //左上
-0.5, -0.5, -0.5f, 0.0f, 0.0f, //左下
};

/*
顶点数组: 开发者可以选择设定函数指针,在调用绘制方法的时候,直接由内存传入顶点数据,也就是说这部分数据之前是存储在内存当中的,被称为顶点数组

顶点缓存区: 性能更高的做法是,提前分配一块显存,将顶点数据预先传入到显存当中。这部分的显存,就被称为顶点缓冲区
*/

//2.开辟顶点缓存区
//(1).创建顶点缓存区标识符ID
GLuint bufferID;
glGenBuffers(1, &bufferID);
//(2).绑定顶点缓存区.(明确作用)
glBindBuffer(GL_ARRAY_BUFFER, bufferID);
//(3).将顶点数组的数据copy到顶点缓存区中(GPU显存中)
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);

//3.打开读取通道.
/*
(1)在iOS中, 默认情况下,出于性能考虑,所有顶点着色器的属性(Attribute)变量都是关闭的.
意味着,顶点数据在着色器端(服务端)是不可用的. 即使你已经使用glBufferData方法,将顶点数据从内存拷贝到顶点缓存区中(GPU显存中).
所以, 必须由glEnableVertexAttribArray 方法打开通道.指定访问属性.才能让顶点着色器能够访问到从CPU复制到GPU的数据.
注意: 数据在GPU端是否可见,即,着色器能否读取到数据,由是否启用了对应的属性决定,这就是glEnableVertexAttribArray的功能,允许顶点着色器读取GPU(服务器端)数据。

(2)方法简介
glVertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)

功能: 上传顶点数据到显存的方法(设置合适的方式从buffer里面读取数据)
参数列表:
index,指定要修改的顶点属性的索引值,例如
size, 每次读取数量。(如position是由3个(x,y,z)组成,而颜色是4个(r,g,b,a),纹理则是2个.)
type,指定数组中每个组件的数据类型。可用的符号常量有GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT,GL_UNSIGNED_SHORT, GL_FIXED, 和 GL_FLOAT,初始值为GL_FLOAT。
normalized,指定当被访问时,固定点数据值是否应该被归一化(GL_TRUE)或者直接转换为固定点值(GL_FALSE)
stride,指定连续顶点属性之间的偏移量。如果为0,那么顶点属性会被理解为:它们是紧密排列在一起的。初始值为0
ptr指定一个指针,指向数组中第一个顶点属性的第一个组件。初始值为0
*/

//顶点坐标数据
glEnableVertexAttribArray(GLKVertexAttribPosition);
glVertexAttribPointer(GLKVertexAttribPosition, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLfloat *)NULL + 0);


//纹理坐标数据
glEnableVertexAttribArray(GLKVertexAttribTexCoord0);
glVertexAttribPointer(GLKVertexAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLfloat *)NULL + 3);

}

-(void)setUpConfig
{
//1.初始化上下文&设置当前上下文
/*
EAGLContext 是苹果iOS平台下实现OpenGLES 渲染层.
kEAGLRenderingAPIOpenGLES1 = 1, 固定管线
kEAGLRenderingAPIOpenGLES2 = 2,
kEAGLRenderingAPIOpenGLES3 = 3,
*/
context = [[EAGLContext alloc]initWithAPI:kEAGLRenderingAPIOpenGLES3];
//判断context是否创建成功
if (!context) {
NSLog(@"Create ES context Failed");
}
//设置当前上下文
[EAGLContext setCurrentContext:context];

//2.获取GLKView & 设置context
GLKView *view =(GLKView *) self.view;
view.context = context;

/*3.配置视图创建的渲染缓存区.

(1). drawableColorFormat: 颜色缓存区格式.
简介: OpenGL ES 有一个缓存区,它用以存储将在屏幕中显示的颜色。你可以使用其属性来设置缓冲区中的每个像素的颜色格式。

GLKViewDrawableColorFormatRGBA8888 = 0,
默认.缓存区的每个像素的最小组成部分(RGBA)使用8个bit,(所以每个像素4个字节,4*8个bit)。

GLKViewDrawableColorFormatRGB565,
如果你的APP允许更小范围的颜色,即可设置这个。会让你的APP消耗更小的资源(内存和处理时间)

(2). drawableDepthFormat: 深度缓存区格式

GLKViewDrawableDepthFormatNone = 0,意味着完全没有深度缓冲区
GLKViewDrawableDepthFormat16,
GLKViewDrawableDepthFormat24,
如果你要使用这个属性(一般用于3D游戏),你应该选择GLKViewDrawableDepthFormat16
或GLKViewDrawableDepthFormat24。这里的差别是使用GLKViewDrawableDepthFormat16
将消耗更少的资源

*/

//3.配置视图创建的渲染缓存区.
view.drawableColorFormat = GLKViewDrawableColorFormatRGBA8888;
view.drawableDepthFormat = GLKViewDrawableDepthFormat16;

//4.设置背景颜色
glClearColor(1, 0, 0, 1.0);
}

#pragma mark -- GLKViewDelegate
//绘制视图的内容
/*
GLKView对象使其OpenGL ES上下文成为当前上下文,并将其framebuffer绑定为OpenGL ES呈现命令的目标。然后,委托方法应该绘制视图的内容。
*/
- (void)glkView:(GLKView *)view drawInRect:(CGRect)rect
{
glEnable(GL_DEPTH_TEST);
//1.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


rod = rod + 0.001;

GLKMatrix4 mat = GLKMatrix4RotateY(cEffect.transform.modelviewMatrix, 0.05);
mat = GLKMatrix4RotateX(mat, 0.05);
cEffect.transform.modelviewMatrix = mat;


//2.准备绘制
[cEffect prepareToDraw];

//3.开始绘制
glDrawArrays(GL_TRIANGLES, 0, 6 * 4);

}

- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}


@end

opengl 第八课(game over)

巩固概念

状态机、状态机、状态机,
不管是矩阵变换、还是纹理绑定,管线使用、还是其他设置,
写代码的时候要记住状态机这个概念

用到的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
GLShaderManager   shaderManager;      //着色器管理器
GLMatrixStack modelViewMatrix; //模型视图矩阵
GLMatrixStack projectionMatrix; //投影矩阵
GLFrustum viewFrustum; //视景体
GLGeometryTransform transformPipeline; //几何变换管线

//4个批次容器类
GLBatch floorBatch;//地面
GLBatch ceilingBatch;//天花板
GLBatch leftWallBatch;//左墙面
GLBatch rightWallBatch;//右墙面

//深度初始值,-65。
GLfloat viewZ = -65.0f;

// 纹理标识符号
#define TEXTURE_BRICK 0 //墙面
#define TEXTURE_FLOOR 1 //地板
#define TEXTURE_CEILING 2 //纹理天花板
#define TEXTURE_COUNT 3 //纹理个数

GLuint textures[TEXTURE_COUNT];//纹理标记数组
//文件tag名字数组
const char *szTextureFiles[TEXTURE_COUNT] = { "brick.tga", "floor.tga", "ceiling.tga" };

初始化方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
void SetupRC(){
//1.黑色的背景
glClearColor(0.0f, 0.0f, 0.0f,1.0f);

//2.初始化shaderManager
shaderManager.InitializeStockShaders();

GLbyte *pBytes;
GLint iWidth, iHeight, iComponents;
GLenum eFormat;
GLint iLoop;

//3.生成纹理标记
/** 分配纹理对象 glGenTextures
参数1:纹理对象的数量
参数2:纹理对象标识数组
*/
glGenTextures(TEXTURE_COUNT, textures);

//4. 循环设置纹理数组的纹理参数
for(iLoop = 0; iLoop < TEXTURE_COUNT; iLoop++)
{
/**绑定纹理对象 glBindTexture
参数1:纹理模式,GL_TEXTURE_1D,GL_TEXTURE_2D,GL_TEXTURE_3D
参数2:需要绑定的纹理对象
*/
glBindTexture(GL_TEXTURE_2D, textures[iLoop]);

/**加载tga文件
参数1:纹理文件名称
参数2:文件宽度变量地址
参数3:文件高度变量地址
参数4:文件组件变量地址
参数5:文件格式变量地址
返回值:pBytes,指向图像数据的指针
*/

pBytes = gltReadTGABits(szTextureFiles[iLoop],&iWidth, &iHeight,
&iComponents, &eFormat);

//加载纹理、设置过滤器和包装模式
//GL_TEXTURE_MAG_FILTER(放大过滤器,GL_NEAREST(最邻近过滤)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//GL_TEXTURE_MIN_FILTER(缩小过滤器),GL_NEAREST(最邻近过滤)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//GL_TEXTURE_WRAP_S(s轴环绕),GL_CLAMP_TO_EDGE(环绕模式强制对范围之外的纹理坐标沿着合法的纹理单元的最后一行或一列进行采样)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//GL_TEXTURE_WRAP_T(t轴环绕),GL_CLAMP_TO_EDGE(环绕模式强制对范围之外的纹理坐标沿着合法的纹理单元的最后一行或一列进行采样)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);


/**载入纹理 glTexImage2D
参数1:纹理维度,GL_TEXTURE_2D
参数2:mip贴图层次
参数3:纹理单元存储的颜色成分(从读取像素图中获得)
参数4:加载纹理宽度
参数5:加载纹理的高度
参数6:加载纹理的深度
参数7:像素数据的数据类型,GL_UNSIGNED_BYTE无符号整型
参数8:指向纹理图像数据的指针
*/
glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);

/**为纹理对象生成一组完整的mipmap glGenerateMipmap
参数1:纹理维度,GL_TEXTURE_1D,GL_TEXTURE_2D,GL_TEXTURE_2D
*/
glGenerateMipmap(GL_TEXTURE_2D);

//释放原始纹理数据,不在需要纹理原始数据了
free(pBytes);
}

//5. 设置几何图形顶点/纹理坐标(上.下.左.右)
GLfloat z;

/*
GLTools库中的容器类,GBatch,
void GLBatch::Begin(GLenum primitive,GLuint nVerts,GLuint nTextureUnits = 0);
参数1:图元枚举值
参数2:顶点数
参数3:1组或者2组纹理坐标
*/

floorBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
//参考PPT图6-10
//Z表示深度,隧道的深度
for(z = 60.0f; z >= 0.0f; z -=10.0f)
{
floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
floorBatch.Vertex3f(-10.0f, -10.0f, z);

floorBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
floorBatch.Vertex3f(10.0f, -10.0f, z);

floorBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
floorBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f);

floorBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
floorBatch.Vertex3f(10.0f, -10.0f, z - 10.0f);
}
floorBatch.End();

//参考PPT图6-11
ceilingBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
for(z = 60.0f; z >= 0.0f; z -=10.0f)
{
ceilingBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
ceilingBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);

ceilingBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
ceilingBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);

ceilingBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
ceilingBatch.Vertex3f(-10.0f, 10.0f, z);

ceilingBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
ceilingBatch.Vertex3f(10.0f, 10.0f, z);
}
ceilingBatch.End();

//参考PPT图6-12
leftWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
for(z = 60.0f; z >= 0.0f; z -=10.0f)
{
leftWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
leftWallBatch.Vertex3f(-10.0f, -10.0f, z);

leftWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
leftWallBatch.Vertex3f(-10.0f, 10.0f, z);

leftWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
leftWallBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f);

leftWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
leftWallBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);
}
leftWallBatch.End();

//参考PPT图6-13
rightWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
for(z = 60.0f; z >= 0.0f; z -=10.0f)
{
rightWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
rightWallBatch.Vertex3f(10.0f, -10.0f, z);

rightWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
rightWallBatch.Vertex3f(10.0f, 10.0f, z);

rightWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
rightWallBatch.Vertex3f(10.0f, -10.0f, z - 10.0f);

rightWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
rightWallBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);
}
rightWallBatch.End();
}

绘制场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void RenderScene(void)
{
//1.用当前清除色,清除窗口
glClear(GL_COLOR_BUFFER_BIT);

//2.模型视图压栈
modelViewMatrix.PushMatrix();
//Z轴平移viewZ 距离
modelViewMatrix.Translate(0.0f, 0.0f, viewZ);

//3.纹理替换矩阵着色器
/*
参数1:GLT_SHADER_TEXTURE_REPLACE(着色器标签)
参数2:模型视图投影矩阵
参数3:纹理层
*/
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetModelViewProjectionMatrix(), 0);

//4.绑定纹理
/*
参数1:纹理模式,GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
参数2:需要绑定的纹理
*/
glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_FLOOR]);
floorBatch.Draw();

glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_CEILING]);
ceilingBatch.Draw();

glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_BRICK]);
leftWallBatch.Draw();
rightWallBatch.Draw();

//5.pop
modelViewMatrix.PopMatrix();

//6.缓存区交换
glutSwapBuffers();
}

opengl 第七课(纹理)

概念

纹理
图像存储空间 = 图像的⾼高度 * 图像宽度 * 每个像素的字节数
压缩图片(jpg,png…),TAG,位图
2D纹理坐标左下角为(0,0),右上角为(1.0, 1.0),

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//参数1:x,矩形左下⻆角的窗⼝口坐标
//参数2:y,矩形左下⻆角的窗⼝口坐标
//参数3:width,矩形的宽,以像素为单位 //参数4:height,矩形的⾼高,以像素为单位
//参数5:format,OpenGL 的像素格式,参考 表6-1 //参数6:type,解释参数pixels指向的数据,告诉OpenGL 使⽤用缓存区中的什什么 数据类型来存储颜⾊色分量量,像素数据的数据类型,参考 表6-2 //参数7:pixels,指向图形数据的指针
void glReadPixels(GLint x,GLint y,GLSizei width,GLSizei,height, GLenum format, GLenum type,const void * pixels);

// 指定读取的缓存
glReadBuffer(mode);
// 指定写⼊入的缓存
glWriteBuffer(mode);

/**
* target:`GL_TEXTURE_1D`、`GL_TEXTURE_2D`、`GL_TEXTURE_3D`。
* Level:指定所加载的mip贴图层次。⼀一般我们都把这个参数设置为0。
* internalformat:每个纹理理单元中存储多少颜⾊色成分。
* width、height、depth参数:指加载纹理理的宽度、⾼高度、深度。==注意!==这些值必须是 2的整数次⽅方。(这是因为OpenGL 旧版本上的遗留留下的⼀一个要求。当然现在已经可以⽀支持不不是 2的整数次⽅方。但是开发者们还是习惯使⽤用以2的整数次⽅方去设置这些参数。)
* border参数:允许为纹理理贴图指定⼀一个边界宽度。
* format、type、data参数:与我们在讲glDrawPixels 函数对于的参数相同
*/
void glTexImage2D(GLenum target,GLint level,GLint,internalformat,GLsizei width,GLsizei height,GLint, border,GLenum format,GLenum type,void * data);


//使⽤用函数分配纹理理对象
//指定纹理理对象的数量量 和 指针(指针指向⼀一个⽆无符号整形数组,由纹理理对象标识符填充)。
void glGenTextures(GLsizei n,GLuint * textTures);

//绑定纹理理状态 //参数target:GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
//参数texture:需要绑定的纹理理对象
void glBindTexture(GLenum target,GLunit texture);

//删除绑定纹理对象
//纹理对象 以及 纹理对象指针(指针指向⼀个⽆符号整形数组,由纹理对象标识符填充)。
void glDeleteTextures(GLsizei n, GLuint *textures); //测试纹理对象是否有效
//如果texture是⼀个已经分配空间的纹理对象,那么这个函数会返回GL_TRUE,否则会返回GL_FALSE。
GLboolean glIsTexture(GLuint texture);


//参数1:target,指定这些参数将要应⽤用在那个纹理理模式上,⽐比如GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D。
//参数2:pname,指定需要设置那个纹理理参数
//参数3:param,设定特定的纹理理参数的值
glTexParameterf(GLenum target,GLenum pname,GLFloat param);
glTexParameteri(GLenum target,GLenum pname,GLint param);
glTexParameterfv(GLenum target,GLenum pname,GLFloat *param);
glTexParameteriv(GLenum target,GLenum pname,GLint *param);


// 重复纹理
GL_REPEAT
// 重复图片的镜像
GL_MIRRORED_REPEAT
// 纹理坐标约束在0~1之间,超出部分重复纹理边缘,一像素的拉伸
GL_CLAMP_TO_EDGE
// 超出坐标的用指定颜色
GL_CLAMP_TO_BORDER

opengl 第六课(3D数学,矩阵变换)

概念

向量
M3DVector3f

矩阵
M3DMatrix44f
opengl 默认:列矩阵
{
Ax, Bx, Cx, Dx
Ay, By, Cy, Dy
Az, Bz, Cz, Dz
0, 0, 0, 1
}

矩阵相乘规则
矩阵A * 矩阵B
当 A的列 等于 B的行
生成 A的行数、B的列数的矩阵

叉乘
m3dCrossProduct3
点乘
m3dDotProduct3

矩阵相关的变换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 平移
inline void m3dTranslationMatrix44(M3DMatrix44f m, float x, float y, float z)
// 旋转
void m3dRotationMatrix44(M3DMatrix44f m, float angle, float x, float y, float z)
// 缩放
inline void m3dScaleMatrix44(M3DMatrix44f m, float xScale, float yScale, float zScale)

// 矩阵相乘
void m3dMatrixMultiply44(M3DMatrix44f product, const M3DMatrix44f a, const M3DMatrix44f b)


// --- MVP 矩阵的变换操作
// 几何变换管道,变换两个栈
GLGeometryTransform transformPipeline
GLMatrixStack modelViewMatrix; // 视图模型栈
GLMatrixStack projectionMatrix; // 投影栈
GLFrame cameraFrame; // 视图3D向量, 可转为视图矩阵
GLFrame objectFrame; // 模型3D向量, 可转为模型矩阵
GLFrustum viewFrustum; // 投影空间模型(圆锥台),可获取投影矩阵

// A
// 设置变换管道
transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);

// B
// 设置投影矩阵
viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f);
// 压入投影矩阵
projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix())
// 压入单元矩阵
modelViewMatrix.LoadIdentity();

// C
// 改变模型变换
objectFrame.RotateWorld(m3dDegToRad(-5.0f), 1.0f, 0.0f, 0.0f);
objectFrame.MoveForward(15.0f);
...

// 压入矩阵计算,并且替换栈顶数据
modelViewMatrix.PushMatrix(objectFrame)
// 记得要 pop
modelViewMatrix.PopMatrix()

// D
// 获取 MVP 矩阵结果
transformPipeline.GetModelViewProjectionMatrix()

opengl 第五课(颜色混合)

概念

正面剔除
解决:视觉效果应该不可见的像素值,显示出来的问题
原理:Opengl默认
正面三角形顶点为逆时针
背面三角形顶点为顺时针
三角形的正面、背面是,相对于观察者视角而言的。

深度缓存区
缓存屏幕上每个像素点( Z值)

深度测试
对比深度缓存区,显示离用户最近的像素
glEnable(GL_DEPTH_TEST)
Polygon Offset(多边形偏移) 解决 z-flighting(无法区分的层级)

组合颜色
目标颜色:颜色缓存区里的,要被替换的
源颜色:渲染结果的颜色,要进入缓存区
cf=(css)+(cdd)
cs:源颜色
cd:目标颜色
s:源混合因子
d:目标混合因子

相关代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 用固定管线,单元着色器,画4个矩形
for 4
shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vColor);
batch1.Draw();
end

// 开启混合
glEnable(GL_BLEND)
// 开启组合函数 计算混合颜色因子
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

// 在画需要 颜色混合的矩形
shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vRed);
squareBatch.Draw();

// 关闭混合
glDisable(GL_BLEND);

//
glutSwapBuffers();