OpenGL

struct Particle {
    float lifetime;
    vec3  position;
    vec3  velocity;
};

float coeff[3] = float[3](1.0,2.0,3.0);
float[3] coeff = float[3](1.0,2.0,3.0);
coeff.length();     // =3
float coeff[3][5];
coeff[2].length();  // =5

// 利用

// 初始化 shader 中 uniform array 数据的两种方法：
uniform vec2 offsets[100];
// --方法 1--
for(GLuint i = 0; i < 100; i++)
{
    stringstream ss;
    string index;
    ss << i;
    index = ss.str();
    GLint location = glGetUniformLocation(shader.Program, ("offsets[" + index + "]").c_str())
    glUniform2f(location, translations[i].x, translations[i].y);
}

// --方法 2--
GLint offset_uniform_local = glGetUniformLocation(program, "offsets");
glUniform2fv(offset_uniform_local,100,translations);
//注意：下面这种方法是不可用的
glUniform1fv(offset_uniform_local,200,translations);

returnType functionName([accessModifier] type1 variable1,[accessModifier] type2 variable2)
{
    // function body
    return returnValue;
}

// -AccessModifier-    -Description-
// in                  值被 copy 到函数
// const in            只读的 copy 到函数的值
// out                 值被 copy 到函数外
// inout               值被 copy 到函数内、外

invariant gl_Position;
invariant centroid out vec3 Color;

precise gl_Position;
precise out vec3 Location;
precise vec3 subdivide(vec3 P1, vec3 P2)
{
    // .....
}

#define
#define LPos(n) gl_LightSource[n].position
__LINE__
__FILE__
__VERSION__
#undef
#if
#ifdef
#ifndef
#else
#elif
#endif
#error text 在编译 shader 时,向日志消息中插入 text
#pragma options
    #pragma optimize(on)
    #pragma optimize(off)
    #pragma debug(on)
    #pragma debug(off)
#extension options
    #extension extension_name : <directive>
    #extension all : <directive>
    // -Directive-         -Description-
    // require             如果扩展不存在或扩展为 all,则标记一个错误
    // enable              如果特定的扩展不存在则给一个警告,如果为 all,则标记一个错误
    // warn                如果特定扩展不存在,或者使用了任意扩展,则给一个警告
    // disable             如果扩展不支持,则产生一个错误或者警告
#version number
#line options

uniform b {     // uniform or in or out or buffer
    vec4 v1;    // list of variables
    bool v2;    // ...
};              // access members as v1 and v2
uniform b {     // uniform or in or out or buffer
    vec4 v1;    // list of variables
    bool v2;    // ...
} name;         // access members as name.v1 and name.v2

// -LayoutQualifier-           -Description-
// shared                      指定 uniform block 被多个程序共享(这个是默认修饰)
// packed                      指定 uniform block 使用最小内存布局.uniform block 不能夸程序共享
// std140                      使用标准布局.
// std430                      使用标准布局.
// row_major                   uniform block 中的矩阵为行主序存储
// column_major                uniform block 中的矩阵为列主序存储(这是默认方式)
layout (shared, row_major) uniform
{
    //.....
};

  GLint program = GLHelper::CreateShaderProgramWithFiles(":/vertex_UniformBlock.vert",":/fragment_UniformBlock.frag");
  glUseProgram(program);

  GLuint uboIndex;
  GLint  uboSize;
  GLuint ubo;
  GLvoid *buffer;

  uboIndex = glGetUniformBlockIndex(program, "Uniforms");
  glGetActiveUniformBlockiv(program, uboIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &uboSize);

  buffer = malloc(uboSize);

  if(buffer == NULL)
  {
      fprintf(stderr, "Unable to allocate buffer\n");
      exit(EXIT_FAILURE);
  }
  else
  {
      enum {Translation, Scale, Rotation, Enabled, NumUniforms};
      GLfloat scale = 0.5;
      GLfloat translation[] = {0.1, 0.1, 0.0};
      GLfloat rotation[] = {90, 0.0, 0.0, 1.0};
      GLboolean enabled = GL_TRUE;

      const char* names[NumUniforms] = {
          "translation",
          "scale",
          "rotation",
          "enabled"
      };

      GLuint indices[NumUniforms];
      GLint  size[NumUniforms];
      GLint  offset[NumUniforms];
      GLint  type[NumUniforms];

      glGetUniformIndices(program,NumUniforms, names, indices);
      glGetActiveUniformsiv(program,NumUniforms,indices,GL_UNIFORM_OFFSET, offset);
      glGetActiveUniformsiv(program,NumUniforms,indices,GL_UNIFORM_SIZE, size);
      glGetActiveUniformsiv(program,NumUniforms,indices,GL_UNIFORM_TYPE, type);

      memcpy( (GLchar*)buffer + offset[Translation], &translation, size[Translation] * GLHelper::TypeSize(type[Translation]) );
      memcpy( (GLchar*)buffer + offset[Scale],       &scale,       size[Scale] * GLHelper::TypeSize(type[Scale]) );
      memcpy( (GLchar*)buffer + offset[Rotation],    &rotation,    size[Rotation] * GLHelper::TypeSize(type[Rotation]) );
      memcpy( (GLchar*)buffer + offset[Enabled],     &enabled,     size[Enabled] * GLHelper::TypeSize(type[Enabled]) );

      glGenBuffers(1, &ubo);
      glBindBuffer(GL_UNIFORM_BUFFER, ubo);
      glBufferData(GL_UNIFORM_BUFFER, uboSize, buffer, GL_STATIC_DRAW);
      glBindBufferBase(GL_UNIFORM_BUFFER, uboIndex, ubo);

      glGenVertexArrays(NumVAOs, VAOs);
      glBindVertexArray(VAOs[Triangles]);
      GLfloat vertices[NumVertices][2] = {
          {-0.90, -0.90},
          { 0.85, -0.90},
          {-0.90,  0.85},
          { 0.90, -0.85},
          { 0.90,  0.90},
          {-0.85,  0.90},
      };

      glGenBuffers(NumBuffers,VBuffers);
      glBindBuffer(GL_ARRAY_BUFFER, VBuffers[ArrayBuffer]);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

      glVertexAttribPointer(vPos,2,GL_FLOAT,GL_FALSE,0,BUFF_OFFSET(0));
      glEnableVertexAttribArray(vPos);
  }

buffer BufferObject {
    int     mode;
    vec4    points[];    // 该数组的大小可以在渲染之前确定
};

out Lighting {
    vec3 normal;
    vec2 bumpCoord;
}
in Lighting {
    vec3 normal;
    vec2 bumpCoord;
};

subroutine (LightFunc) vec4 ambient(vec3 n)
{
    return Materials.ambient;
}
subroutine (LightFunc) vec4 diffuse(vec3 n)
{
    return Materials.diffuse*max(dot(normalize(n),LightVec.xyz),0.0);
}

subroutine void Type_1();
subroutine void Type_2();

subroutine (Type_1) Func_1();
subroutine (Type_2) Func_2();
subroutine (Type_1,Type_2) Func_12();

subroutine uniform Type_1 func_1;  // 可以使用 Func_1 Func_12
subroutine uniform Type_2 func_2;  // 可以使用 Func_2 Func_12

GLint materialShaderLoc;
GLuint ambientIndex;
GLuint diffuseIndex;

glUseProgram(program);

materialShaderLoc = glGetSubroutineUniformLocation(program,GL_VERTEX_SHADER,"materialShader");

if (materialShaderLoc < 0)
{
    // Error
}
ambientIndex = glGetSubroutineIndex(program,GL_VERTEX_SHADER,"ambient");
diffuseIndex = glGetSubroutineIndex(program,GL_VERTEX_SHADER,"diffuse");
if(ambientIndex==GL_INVALID_INDEX || diffuseIndex==GL_INVALID_INDEX)
{
    //
}
else
{
    GLsizei n;
    glGetIntegerv(GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS, &n);

    GLuint* indices = new GLuint[n];
    indices[materialShaderLoc] = ambientIndex;

    glUniformSubroutinesuiv(GL_VERTEX_SHADER, n, indices);

    delete [] indices;
}

// 默认情况下 face=GL_FRONT_AND_BACK mode=GL_FILL
// 设置多边形渲染模式
void glPolygonMode(GLenum face, GLenum mode);
// face = GL_FRONT_AND_BACK
// mode = GL_POINT GL_LINE GL_FILL

// Tips： 貌似不能为 FRONT 和 BACK 指定不同的 mode？
// 该特性已经从 opengl 3.2 版本开始，被标记为 deprecated，所以 face 的枚举值只能为 GL_FRONT_AND_BACK
// https://stackoverflow.com/questions/19672014/why-is-gl-front-and-gl-back-deprecated-in-opengl-3-2-onwards

// 指定正面
void glFrontFace(GLenum mode);
//GL_CCW counterclockwise
//GL_CW  clockwise

// 指定剔除的面
void glCullFace(GLenum mode);
// GL_FRONT GL_BACK GL_FRONT_AND_BACK
void glEnable(GL_CULL_FACE);

// mode
// GL_TRIANGLES, GL_LINE_LOOP, GL_LINES, and GL_POINTS.
// GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_LINE_STRIP_ADJACENCY, GL_LINES_ADJACENCY, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_TRIANGLE_STRIP_ADJACENCY, GL_TRIANGLES_ADJACENCY and GL_PATCHES
// 从第 first 个顶点数据开始，取 count 个顶点数据来绘制 mode 类型的几何图元
void glDrawArrays(GLenum mode,GLint first, GLsizei count);

// type
// GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT
// 从 GL_ELEMENT_ARRAY_BUFFER 缓冲区对象中，偏移 indices 字节开始，取 count 个 type 类型的索引值，依据索引值指定的顶点数据来绘制 mode 类型的几何图元
void glDrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid* indices);

// basevertex 指定偏移多少个索引数据 (indices 指定偏移字节数)
// 对 glDrawElements 的一个改进。增加了 GLint basevertex 参数，称为索引基数，所有的 index 数值都要加上这个数值后再进行绘制。
// 例如：GLushort vetex_indices[] = {0,1,2,3,4}; 下面的函数取的索引数据为{2,3,4}
// glDrawElementsBaseVertex(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, NULL, 2);
void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,const GLvoid *indices, GLint basevertex);

// start 指定最小的索引值 end 指定最大的索引值
// 如果 获取到的索引值不在[start end]范围内，在我自己的 PC 电脑上也没有任何影响，几何图元依然可以渲染出来
// https://stackoverflow.com/questions/7549991/questions-about-gldrawrangeelements
void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,GLenum type,const GLvoid *indices);

void glDrawRangeElementsBaseVertex(GLenum mode,GLuint start, GLuint end,GLsizei count, GLenum type,const GLvoid *indices, GLint basevertex);

// indirect 指定 GL_DRAW_INDIRECT_BUFFER 缓冲区的偏移，绘制命令的参数保存在 GL_DRAW_INDIRECT_BUFFER 缓冲区对象中
void glDrawArraysIndirect(GLenum mode,const GLvoid *indirect);

void glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid * indirect);

// primcount 指定几何图元的个数 first 和 count 都是包含 primcount 个元素的数组
// 一次函数调用绘制多个几何图元
void glMultiDrawArrays(GLenum mode, const GLint * first, const GLint * count, GLsizei primcount);

void glMultiDrawElements(GLenum mode, const GLint * count, GLenum type,const GLvoid * const * indices, GLsizei primcount);

void glMultiDrawElementsBaseVertex(GLenum mode, const GLint * count,GLenum type,const GLvoid * const * indices, GLsizei primcount,const GLint * baseVertex);

void glMultiDrawArraysIndirect(GLenum mode, const void * indirect,GLsizei drawcount, GLsizei stride);

void glMultiDrawElementsIndirect(GLenum mode, GLenum type,const void * indirect, GLsizei drawcount, GLsizei stride);
// 下面的结构体用于存储每个DrawCall的参数
typedef struct DrawArraysIndirectCommand_t
{
    GLuint count;
    GLuint primCount;
    GLuint first;
    GLuint baseInstance;
} DrawArraysIndirectCommand;

typedef struct DrawElementsIndirectCommand_t
{
    GLuint count;
    GLuint primCount;
    GLuint firstIndex;
    GLuint baseVertex;
    GLuint baseInstance;
} DrawElementsIndirectCommand;

void glPrimitiveRestartIndex(GLuint index);
//设置 primitive_restart_index,使用 glDrawElements 系列的绘图命令时，当获取顶点的索引和 primitive_restart_index 相等时，会忽略当前索引，并且以下一个索引为新图元的第一个顶点。

void glGenFramebuffers(GLsizei n,GLuint* ids);
void glBindFramebuffer(GLenum target, GLuint framebuffer);
/* target - GL_FRAMEBUFFER */
void glDeleteFramebuffers(GLsizei n, const GLuint *ids);
GLboolean glIsFramebuffer(GLuint framebuffer);
void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
/* pname */
/* GL_FRAMEBUFFER_DEFAULT_WIDTH */
/* GL_FRAMEBUFFER_DEFAULT_HEIGHT */
/* GL_FRAMEBUFFER_DEFAULT_LAYERS */
/* GL_FRAMEBUFFER_DEFAULT_SAMPLES */
/* GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS */

void glGenRenderbuffers(GLsizei n, GLuint *ids);
void glDeleteRenderbuffers(GLsizei n, const GLuint *ids);
void glIsRenderbuffer(GLuint renderbuffer);
void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
//target 必须为 GL_RENDERBUFFER

void glRenderbufferStorage(GLenum target, GLenum internalformat,GLsizei width, GLsizei height);
void glRenderbufferStorageMultisample(GLenum target,GLsizei samples, GLenum internalformat, GLsizei width,GLsizei height);
/* target 必须为 GL_RENDERBUFFER */
/* internalformat */
/* 对于 color-renderable buffer 为 GL_RED GL_R8 GL_R16 ... */
/* 对于 depth-renderable buffer 为 GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT16 ... */
/* 对于 stencil buffer 为 GL_STENCIL_INDEX, GL_STENCIL_INDEX1 ... */
/* 对于 packed depth-stencil 为 GL_DEPTH_STENCIL */

void glFramebufferRenderbuffer(GLenum target, GLenum attachment,GLenum renderbuffertarget, GLuint renderbuffer);
/* target GL_READ_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER, or GL_FRAMEBUFFER */
/* attachment GL_COLOR_ATTACHMENTi, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT, or GL_DEPTH_STENCIL_ATTACHMENT */
/* renderbuffertarget GL_RENDERBUFFER */
/* renderbuffer 为 0 时移除当前关联的 attachment */

GLenum glCheckFramebufferStatus(GLenum target);
/* target GL_READ_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER, or GL_FRAMEBUFFER */
/* 有任何错误时返回 0 */

glClear(GL_COLOR_BUFFER_BIT);
void glClearBuffer{fi ui}v(GLenum buffer, GLint drawbuffer, const TYPE *value);
void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
//buffer GL_COLOR, GL_DEPTH, or GL_STENCIL

OpenGL 提供了一种机制来标记一个区域或整个帧缓冲区不再使用了，即可以释放了。
void glInvalidateFramebuffer(GLenum target,GLsizei numAttachments,const GLenum *attachments);
void glInvalidateSubFramebuffer(GLenum target,GLsizei numAttachmens, const GLenum *attachments,
GLint x, GLint y,GLsizei width, GLsizei height);

void glDrawBuffer(GLenum mode);
void glDrawBuffers(GLsizei n, const GLenum *buffers);
// FRONT BACK 对应于窗口程序申请的render buffer
// LEFT RIGHT 用于VR等立体画面绘制时申请的 render buffer
// GL_COLOR_ATTACHMENTi 对应于自己申请的render buffer可用于离屏渲染
/* mode -  */
/* GL_NONE */
/* GL_FRONT */
/* GL_FRONT_LEFT */
/* GL_BACK */
/* GL_FRONT_RIGHT */
/* GL_LEFT */
/* GL_BACK_LEFT */
/* GL_RIGHT */
/* GL_BACK_RIGHT */
/* GL_FRONT_AND_BACK */
/* GL_COLOR_ATTACHMENTi */
void glReadBuffer(GLenum mode);

/* capability */
/* 只有下面的 capability 支持指定index
  GL_BLEND
  GL_SCISSOR_TEST
  index < GL_MAX_DRAW_BUFFERS
*/
void glEnablei(GLenum capability, GLuint index);
void glDisablei(GLenum capability, GLuint index);
GLboolean glIsEnabledi(GLenum capability, GLuint index);

  mat3x4 m;
  vec4 v = m[1]; // v 是矩阵 m 的第二列向量

// lookAt 函数返回一个矩阵，可以实现世界坐标到视觉坐标的转换
glm::mat4 CameraMatrix = glm::LookAt(
    cameraPosition, // the position of your camera, in world space
    cameraTarget,   // where you want to look at, in world space
    upVector        // probably glm::vec3(0,1,0), but (0,-1,0) would make you looking upside-down, which can be great too
);

//将当前绑定的缓冲区对象和索引为 index 的 tfbo 关联
void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset,GLsizeiptr size);
//-target- GL_TRANSFORM_FEEDBACK_BUFFER

// example initialization of a Transform Feedback Buffer
GLuint buffer;
glGenBuffers(1, &buffer);

glBindBuffer(GL_TRANSFORM_FEEDBACK, buffer);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024*1024, NULL, GL_DYNAMIC_COPY);

glBindBufferRange(
                  GL_TRANSFORM_FEEDBACK_BUFFER,
                  0,
                  buffer,
                  0,
                  512*1024
                  );
glBindBufferRange(
                  GL_TRANSFORM_FEEDBACK_BUFFER,
                  0,
                  buffer,
                  512*1024,
                  512*1024
                  );

void glTransformFeedbackVaryings(GLuint program, GLsizei count,const GLchar ** varyings, GLenum bufferMode);
//-bufferMode-
// GL_INTERLEAVED_ATTRIBS
// GL_SEPARATE_ATTRIBS
//注意上面的代码需要在 glLinkProgram()之前调用。
//
// gl_SkipComponents1, gl_SkipComponents2, gl_SkipComponents3, gl_SkipComponents4, and gl_NextBuffer.

// example 指定需要反馈变换的变量
// 如果 bufferMode = GL_INTERLEAVED_ATTRIBS,那么 foo,bar,baz 的值将会紧挨着记录到 TF 缓冲区对象中。
// 如果 bufferMode = GL_SEPARATE_ATTRIBS,那么 foo,bar,baz 的值将会分别被记录在各自的 TF 缓冲区对象中。
static const char* const vars[] = {"foo", "bar", "baz"};
glTransformFeedbackVaryings(
                            prog,
                            sizeof(vars)/sizeof(vars[0]),
                            varyings,
                            GL_INTERLEAVED_ATTRIBS
                            );
glTransformFeedbackVaryings(
                            prog,
                            sizeof(vars)/sizeof(vars[0]),
                            varyings,
                            GL_SEPARATE_ATTRIBS
                            );
glLinkProgram(prog);

// example 在 TF 缓冲区对象中留下间隙
static const char* const vars[] = {
    "foo",
    "gl_SkipComponents2",
    "bar",
    "gl_SkipComponents3"
    "baz"
};
glTransformFeedbackVaryings(
                            prog,
                            sizeof(vars)/sizeof(vars[0]),
                            varyings,
                            GL_INTERLEAVED_ATTRIBS
                            );

// example Declare the transform feedback varying names
static const char * const vars[] =
{
    // Record foo, a gap of 1 float, bar, and then two floats
    "foo", "gl_SkipComponents1", "bar", "gl_SkipComponents2"
    // Move to binding point 1
    "gl_NextBuffer",
    // Leave a gap of 4 floats, then record baz, then leave
    // another gap of 2 floats
    "gl_SkipComponents4" "baz", "gl_SkipComponents2"
    // Move to binding point 2
    "gl_NextBuffer",
    // Move directly to binding point 3 without directing anything
    // to binding point 2
    "gl_NextBuffer",
    // Record iron and copper with a 3 component gap between them
    "iron", "gl_SkipComponents3", "copper"
};
// Set the varyings
glTransformFeedbackVaryings(prog,
                            sizeof(vars) / sizeof(vars[0]),
                            varyings,
                            GL_INTERLEAVED_ATTRIBS);
// Remember to link the program object
glLinkProgram(prog);

void glBeginTransformFeedback(GLenum primitiveMode);
-primitiveMode
GL_POINTS
GL_LINES
GL_TRIANGLES
void glPauseTransformFeedback(void);
void glResumeTransformFeedback(void);
void glEndTransformFeedback(void);

void glBindTexture(GLenum target, GLuint texture);
//-target-
// GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_ARRAY, GL_TEXTURE_RECTANGLE,
// GL_TEXTURE_BUFFER, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY
// 判断纹理名称是否为纹理对象
GLboolean glIsTexture(GLuint texture);

void glTexStorage1D(GLenum target, GLsizei levels,GLenum internalFormat, GLsizei width);
    target 必须为 GL_TEXTURE_1D
    internalFormat 为 OpenGL 用于存储内部贴图数据的格式
void glTexStorage2D(GLenum target, GLsizei levels,GLenum internalFormat, GLsizei width, GLsizei height);
void glTexStorage3D(GLenum target, GLsizei levels,GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
void glTexStorage2DMultisample(GLenum target, GLsizei samples,GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void glTexStorage3DMultisample(GLenum target, GLsizei samples,GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

// 尽管最好的实践是声明不变的贴图存储，但是允许贴图对象改变尺寸以及格式是可以支持的。
// 下面的方法指定了可变的纹理
void glTexImage1D(GLenum target, GLint level,GLint internalFormat, GLsizei width,GLint border, GLenum format, GLenum type, const void *data);
// format 为 应用程序提供的数据的格式
void glTexImage2D(GLenum target, GLint level,GLint internalFormat, GLsizei width,GLsizei height, GLint border, GLenum format, GLenum type, const void *data);
void glTexImage3D(GLenum target, GLint level,GLint internalFormat, GLsizei width,GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *data);
void glTexImage2DMultisample(GLenum target, GLenum samples,GLint internalFormat,GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void glTexImage3DMultisample(GLenum target, GLenum samples,GLint internalFormat,GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

void glGetTexImage(GLenum target, GLint lod, GLenum format, GLenum type, GLvoid* image);
// target - GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_ARRAY, GL_TEXTURE_CUBE_MAP_ARRAY,
// GL_TEXTURE_RECTANGLE. GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
// GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, and GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
// 读入 image 中的数据大小是由 target、format 和 type 决定的。

void glPixelStorei(GLenum pname, GLint param);
void glPixelStoref(GLenum pname, GLfloat param);
//pname - GL_UNPACK_ROW_LENGTH, GL_UNPACK_SWAP_BYTES, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_IMAGES,
//GL_UNPACK_ALIGNMENT, GL_UNPACK_IMAGE_HEIGHT, or GL_UNPACK_LSB_FIRST
//GL_PACK_ROW_LENGTH, GL_PACK_SWAP_BYTES, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS, GL_PACK_SKIP_IMAGES,
//GL_PACK_ALIGNMENT, GL_PACK_IMAGE_HEIGHT, or GL_PACK_LSB_FIRST
//unpack  参数用来指定 OpenGL 如何从应用程序内存或绑定到 GL_PIXEL_UNPACK_BUFFER 的缓冲区读取数据（glTexSubImage2D）。
//packing 参数用来指定 OpenGL 如何将贴图数据写入内存（glGetTexImage）.

void glBindSampler(GLuint unit, GLuint sampler);
// unit 为 sampler 单元的索引。如果 sampler 为 0，则清除 sampler 单元上绑定的所有 sampler 对象
GLboolean glIsSampler(GLenum id);
// glBindTexture 和 glBindSampler 的不同之处： //void glBindTexture(GLenum target, GLuint texture);
// --1-- glBindSampler 没有 target 参数。因为 sampler 对象没有维度一说，所以没必要区别不同类型的 sampler 对象类型。
// --2-- glBindSampler 有 unit 参数，没有对应的 glActiveSampler 函数。glActiveTexture 的参数为 GL_TEXTURE0-GLTEXTURi 的常数，i 的最大值是由实现定义的。
// unit 是一个无符号整数，允许任意数目的 sampler 单元。

// e.g:
// Buffer to be used as the data store
GLuint buf;
// Texture to be used as a buffer texture
GLuint tex;
// Data is located somewhere else in this program extern const GLvoid* data;
// Generate, bind, and initialize a buffer object
// using the GL_TEXTURE_BUFFER binding. Assume we’re
// going to use one megabyte of data here.
glGenBuffers(1, &buf);
glBindBuffer(GL_TEXTURE_BUFFER,  buf);
glBufferData(GL_TEXTURE_BUFFER,  1024 * 1024,
             data, GL_STATIC_DRAW);
// Now create the buffer texture and associate it
// with the buffer object.
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_BUFFER, tex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, buf);

#version 330 core
uniform samplerBuffer buf
in int buf_tex_coord;
layout (location = 0) out vec4 color;
void main(void)
{
    color = texelFetch(buf, tex_coord);
}

----------------------- Vertex Shader -------------------------
// Vertex shader with no lighting
#version 330 core
uniform mat4 MVPMatrix; // model-view-projection transform
in vec4 VertexColor;    // sent from the application, includes alpha
in vec4 VertexPosition; // pre-transformed position
out vec4 Color;         // sent to the rasterizer for interpolation
void main()
{
    Color = VertexColor;
    gl_Position = MVPMatrix * VertexPosition;
}
---------------------- Fragment Shader ------------------------
// Fragment shader with no lighting
#version 330 core
in vec4 Color;          // interpolated between vertices
out vec4 FragColor;     // color result for this fragment
void main()
{
    FragColor = Color;
}

//--------------------------- Vertex Shader -----------------------------
// Vertex shader for ambient light
#version 330 core
uniform mat4 MVPMatrix;
in vec4 VertexColor;
in vec4 VertexPosition;
out vec4 Color;
void main()
{
     Color = VertexColor;
     gl_Position = MVPMatrix * VertexPosition;
}
//-------------------------- Fragment Shader ----------------------------
// Fragment shader for global ambient lighting
#version 330 core
uniform vec4 Ambient; // sets lighting level, same across many vertices
in vec4 Color;
out vec4 FragColor;
void main()
{
//    vec4 scatteredLight = Ambient; // this is the only light
//    // modulate surface color with light, but saturate at white
//    FragColor = min(Color * scatteredLight, vec4(1.0));
    vec3 scatteredLight = vec3(Ambient);
    vec3 rgb = min(Color.rgb*scatteredLight,vec3(1.0));
    FragColor = vec4(rgb,Color.a);
}

//Directional Light Source Lighting
//--------------------------- Vertex Shader -----------------------------
// Vertex shader for a directional light computed in the fragment shader
#version 330 core
uniform mat4 MVPMatrix;
uniform mat3 NormalMatrix; // to transform normals, pre-perspective
in vec4 VertexColor;
in vec3 VertexNormal;
in vec4 VertexPosition;
out vec4 Color;
out vec3 Normal;
void main() {
    Color = VertexColor;
    // we now need a surface normal
    // interpolate the normalized surface normal
    // transform the normal, without perspective, and normalize it
    Normal = normalize(NormalMatrix * VertexNormal);
    gl_Position = MVPMatrix * VertexPosition;
}
-------------------------- Fragment Shader ----------------------------
// Fragment shader computing lighting for a directional light
#version 330 core
uniform vec3 Ambient;
uniform vec3 LightColor;
uniform vec3 LightDirection; // direction toward the light
uniform vec3 HalfVector;
uniform float Shininess;
uniform float Strength;
// surface orientation for shiniest spots
// exponent for sharping highlights
// extra factor to adjust shininess
in vec4 Color;
in vec3 Normal; // surface normal, interpolated between vertices
out vec4 FragColor;
void main()
{
    // compute cosine of the directions, using dot products,
    // to see how much light would be reflected
    float diffuse = max(0.0, dot(Normal, LightDirection));
    float specular = max(0.0, dot(Normal, HalfVector));
    // surfaces facing away from the light (negative dot products)
    // won’t be lit by the directional light
    if (diffuse == 0.0)
    {
        specular = 0.0;
    }
    else
    {
        specular = pow(specular, Shininess); // sharpen the highlight
    }
    vec3 scatteredLight = Ambient + LightColor * diffuse;
    vec3 reflectedLight = LightColor * specular * Strength;
     // don’t modulate the underlying color with reflected light,
     // only with scattered light
    vec3 rgb = min(Color.rgb * scatteredLight + reflectedLight, vec3(1.0));
    FragColor = vec4(rgb, Color.a);
}

//Point-Light Source Lighting
//--------------------------- Vertex Shader -----------------------------
// Vertex shader for a point-light (local) source, with computation
// done in the fragment shader.
#version 330 core
uniform mat4 MVPMatrix;
uniform mat4 MVMatrix;
uniform mat3 NormalMatrix;
in vec4 VertexColor;
in vec3 VertexNormal;
in vec4 VertexPosition;
// now need the transform, minus perspective
out vec4 Color;
out vec3 Normal;
out vec4 Position; // adding position, so we know where we are
void main() {
    Color = VertexColor;
    Normal = normalize(NormalMatrix * VertexNormal);
    Position = MVMatrix * VertexPosition;     // pre-perspective space
    gl_Position = MVPMatrix * VertexPosition; // includes perspective
}
//-------------------------- Fragment Shader ----------------------------
// Fragment shader computing a point-light (local) source lighting.
#version 330 core
uniform vec3 Ambient;
uniform vec3 LightColor;
uniform vec3 LightPosition;
uniform float Shininess;
uniform float Strength;
// location of the light, eye space
uniform vec3 EyeDirection;
uniform float ConstantAttenuation; // attenuation coefficients
uniform float LinearAttenuation;
uniform float QuadraticAttenuation;
in vec4 Color;
in vec3 Normal;
in vec4 Position;
out vec4 FragColor;
void main()
{
    // find the direction and distance of the light,
    // which changes fragment to fragment for a local light
    vec3 lightDirection = LightPosition - vec3(Position);
    float lightDistance = length(lightDirection);
    // normalize the light direction vector, so
    // that a dot products give cosines
    lightDirection = lightDirection / lightDistance;
    // model how much light is available for this fragment
    float attenuation = 1.0 / (ConstantAttenuation + LinearAttenuation * lightDistance +
    QuadraticAttenuation * lightDistance * lightDistance);
     // the direction of maximum highlight also changes per fragment
    vec3 halfVector = normalize(lightDirection + EyeDirection);
    float diffuse = max(0.0, dot(Normal, lightDirection));
    float specular = max(0.0, dot(Normal, halfVector));
    if (diffuse == 0.0)
    {
        specular = 0.0;
    }
    else
    {
        specular = pow(specular, Shininess) * Strength;
    }
    vec3 scatteredLight = Ambient + LightColor * diffuse * attenuation;
    vec3 reflectedLight = LightColor * specular * attenuation;
    vec3 rgb = min(Color.rgb * scatteredLight + reflectedLight, vec3(1.0));
    FragColor = vec4(rgb, Color.a);
}

//Spotlight Lighting
//--------------------------- Vertex Shader -----------------------------
// Vertex shader for spotlight computed in the fragment shader
#version 330 core
uniform mat4 MVPMatrix;
uniform mat4 MVMatrix;
uniform mat3 NormalMatrix;
in vec4 VertexColor;
in vec3 VertexNormal;
in vec4 VertexPosition;
out vec4 Color;
out vec3 Normal;
out vec4 Position;
void main() {
    Color = VertexColor;
    Normal = normalize(NormalMatrix * VertexNormal);
    Position = MVMatrix * VertexPosition;
    gl_Position = MVPMatrix * VertexPosition;
}
//-------------------------- Fragment Shader ----------------------------
// Fragment shader computing a spotlight’s effect
#version 330 core
uniform vec3 Ambient;
uniform vec3 LightColor;
uniform vec3 LightPosition;
uniform float Shininess;
uniform float Strength;
uniform vec3 EyeDirection;
uniform float ConstantAttenuation;
uniform float LinearAttenuation;
uniform float QuadraticAttenuation;
uniform vec3 ConeDirection;
uniform float SpotCosCutoff;
uniform float SpotExponent;
in vec4 Color;
in vec3 Normal;
in vec4 Position;
out vec4 FragColor;
void main()
{
    // adding spotlight attributes
    // how wide the spot is, as a cosine
    // control light fall-off in the spot
    vec3 lightDirection = LightPosition - vec3(Position);
    float lightDistance = length(lightDirection);
    lightDirection = lightDirection / lightDistance;
    float attenuation = 1.0 / (ConstantAttenuation + LinearAttenuation * lightDistance +
    QuadraticAttenuation * lightDistance * lightDistance);
    // how close are we to being in the spot?
    float spotCos = dot(lightDirection, -ConeDirection);
    // attenuate more, based on spot-relative position
    if (spotCos < SpotCosCutoff)
    {
        attenuation = 0.0;
    }
    else
    {
        attenuation *= pow(spotCos, SpotExponent);
    }

    vec3 halfVector = normalize(lightDirection + EyeDirection);
    float diffuse = max(0.0, dot(Normal, lightDirection));
    float specular = max(0.0, dot(Normal, halfVector));
    if (diffuse == 0.0)
    {
        specular = 0.0;
    }
    else
    {
        specular = pow(specular, Shininess) * Strength;
    }
    vec3 scatteredLight = Ambient + LightColor * diffuse * attenuation;
    vec3 reflectedLight = LightColor * specular * attenuation;
    vec3 rgb = min(Color.rgb * scatteredLight + reflectedLight, vec3(1.0));
    FragColor = vec4(rgb, Color.a);
}

struct LightProperties {
bool isEnabled; // true to apply this light in this invocation
bool isLocal;   // true for a point light or a spotlight, false for a positional light
bool isSpot;    // true if the light is a spotlight
vec3 ambient;   // light’s contribution to ambient light
vec3 color;     // color of light
vec3 position;  // location of light, if is Local is true, otherwise the direction toward the light
vec3 halfVector;        // direction of highlights for directional light vec3 coneDirection;
float spotCosCutoff;    // spotlight attributes
float spotExponent;
float constantAttenuation; // local light attenuation coefficients
float linearAttenuation;
float quadraticAttenuation;
// other properties you may desire
};

struct MaterialProperties {
vec3 emission;  // light produced by the material
vec3 ambient;   // what part of ambient light is reflected
vec3 diffuse;   // what part of diffuse light is scattered
vec3 specular;  // what part of specular light is scattered
float shininess; // exponent for sharpening specular reflection
// other properties you may desire
};

//Shaders for Image-based Lighting
//--------------------- Vertex Shader ---------------------
// Vertex shader for image-based lighting
#version 330 core
uniform mat4 MVMatrix;
uniform mat4 MVPMatrix;
uniform mat3 NormalMatrix;
in vec4 VertexPosition;
in vec3 VertexNormal;
out vec3 ReflectDir;
out vec3 Normal;
void main() {
    Normal = normalize(NormalMatrix * VertexNormal);
    vec4 pos = MVMatrix * VertexPosition;
    vec3 eyeDir = pos.xyz;
    ReflectDir = reflect(eyeDir, Normal);
    gl_Position = MVPMatrix * VertexPosition;
}
//-------------------- Fragment Shader --------------------
// Fragment shader for image-based lighting
#version 330 core
uniform vec3 BaseColor;
uniform float SpecularPercent;
uniform float DiffusePercent;
uniform samplerCube SpecularEnvMap;
uniform samplerCube DiffuseEnvMap;
in vec3 ReflectDir; in vec3 Normal;
out vec4 FragColor;
void main() {
    // Look up environment map values in cube maps
    vec3 diffuseColor = vec3(texture(DiffuseEnvMap, normalize(Normal)));
    vec3 specularColor = vec3(texture(SpecularEnvMap, normalize(ReflectDir)));
    // Add lighting to base color and mix
    vec3color=mix(BaseColor,diffuseColor*BaseColor,DiffusePercent);
    color = mix(color, specularColor + color, SpecularPercent);
    FragColor = vec4(color, 1.0);
}

// Shaders for Spherical Harmonics Lighting
// --------------------- Vertex Shader ---------------------
// Vertex shader for computing spherical harmonics
#version 330 core
uniform mat4 MVMatrix;
uniform mat4 MVPMatrix;
uniform mat3 NormalMatrix;
uniform float ScaleFactor;
const float C1 = 0.429043;
const float C2 = 0.511664;
const float C3 = 0.743125;
const float C4 = 0.886227;
const float C5 = 0.247708;
// Constants for Old Town Square lighting
const vec3 L00 = vec3( 0.871297, 0.875222, 0.864470);
const vec3 L1m1 = vec3( 0.175058, 0.245335, 0.312891);
const vec3 L10 = vec3( 0.034675, 0.036107, 0.037362);
const vec3 L11 = vec3(-0.004629, -0.029448, -0.048028);
const vec3 L2m2 = vec3(-0.120535, -0.121160, -0.117507);
const vec3 L2m1 = vec3( 0.003242, 0.003624, 0.007511);
const vec3 L20 = vec3(-0.028667, -0.024926, -0.020998);
const vec3 L21 = vec3(-0.077539, -0.086325, -0.091591);
const vec3 L22 = vec3(-0.161784, -0.191783, -0.219152);

in vec4 VertexPosition;
in vec3 VertexNormal;
out vec3 DiffuseColor;
void main()
{
vec3 tnorm = normalize(NormalMatrix * VertexNormal);
DiffuseColor =  C1 * L22 *(tnorm.x * tnorm.x - tnorm.y * tnorm.y) +
                C3 * L20 * tnorm.z * tnorm.z +
                C4 * L00 -
                C5 * L20 +
                2.0 * C1 * L2m2 * tnorm.x * tnorm.y +
                2.0 * C1 * L21 * tnorm.x * tnorm.z +
                2.0 * C1 * L2m1 * tnorm.y * tnorm.z +
                2.0 * C2 * L11 * tnorm.x +
                2.0 * C2 * L1m1 * tnorm.y +
                2.0 * C2 * L10 * tnorm.z;
DiffuseColor *= ScaleFactor;
gl_Position = MVPMatrix * VertexPosition;
}
// -------------------- Fragment Shader --------------------
// Fragment shader for lighting with spherical harmonics
#version 330 core
in vec3 DiffuseColor;
out vec4 FragColor;
void main()
{
FragColor = vec4(DiffuseColor, 1.0);
}