shader 着色器

shader 着色器

着色器是运行在GPU上面的小程序，这些小程序为图形渲染的某个特定部份而运行，从基本意义上来说，着色器只一种把输入转换为输出的程序。

着色器的开头声明版本，接着输入和输出变量，uniform和main函数。

一个典型的着色器有下面的结构

#version version_number

in type in_variable_name;
in type in_variable_name;

out type out_variable_name;

uniform type uniform_name;

int main()
{
// 处理输入并进行一些图形操作
...
// 输出处理过的结果到输出变量
out_variable_name = weird_stuff_we_processed;
}

顶点着色器的输入变量也叫顶点属性（Vertex Attribute）,它由硬件来决定，OpenGL确保至少有16个包含4分量的顶点属性可以用，可以用GL_MAX_VERTEX_ATTRIBS来查询

GLint nrAttributes;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
std::cout << "Maximum nr of vertex attributes supported: " << nrAttributes << std::endl;

数据类型

GLSL中包含C等其它语言大部份的默认的数据类型，如

int

,

float

,

double

,

uint

,

bool

.GLSL也有两种容器类型，矩阵（Matrix）,向量（Vector）

向量

类型	说明
vecn	包含n个float分量的的默认向量
bvecn	包含n个bool分量的向量
ivecn	包含n个int分量的向量
uvecn	包含n个unsigned int 分量的向量
dvecn	包含n个double分量的向量

输入与输出

顶点着色器接收的是一种特殊行式的输入，顶点着色器的输入特殊在，它从顶点数据中直接接收输入。为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。我们已经在前面的教程看过这个了，layout (location = 0)。顶点着色器需要为它的输入提供一个额外的layout标识，这样我们才能把它链接到顶点数据。

另一个例外是片段着色器，它需要一个vec4颜色输出变量，因为片段着色器需要生成一个最终输出的颜色。如果你在片段着色器没有定义输出颜色，OpenGL会把你的物体渲染为黑色（或白色）。

所以，如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。当类型和名字都一样的时候，OpenGL就会把两个变量链接到一起，它们之间就能发送数据了（这是在链接程序对象时完成的）。

//
//  main.cpp
//  shaders0
//
//  Created by xufan on 2017/5/16.
//  Copyright © 2017年 xufan. All rights reserved.
//

#include <iostream>
#include <math.h>

#define GLEW_STATIC
#include <GL/glew.h>

#include <GLFW/glfw3.h>

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
void display();

// Shaders

const GLchar *vertexShaderSource = " \n \
#version 330 core \n \
layout (location = 0) in vec3 position; // position变量的属性位置值为0 \n \
layout (location = 1) in vec3 color;    // 颜色变量的属性位置值为1 \n \
\n \
out vec3 ourColor; // 为片段着色器输出一个颜色输出\n \
\n \
void main() \n \
{ \n \
gl_Position = vec4(position, 1.0); // 注意我们如何把一个vec3作为vec4的构造器的参数\n \
ourColor = color; //将ourColor设置为我们从顶点数据那里得到的输入颜色\n \
}\n";

const GLchar* fragmentShaderSource = "\n \
#version 330 core \n \
in vec3 ourColor; // 从顶点着色器传来的输入变量（名称相同、类型相同）\n \
\n \
out vec4 color; // 片段着色器输出的变量名可以任意命名，类型必须是vec4\n \
//uniform vec4 ourColor; //在OpenGL程序代码中设定这个变量\n \
\n \
void main() \n \
{ \n \
color = vec4(ourColor, 1.0f); \n \
//color = ourColor; \n \
}\n";

int main()
{
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

GLFWwindow *window = glfwCreateWindow(800, 600, "learnOpenGL", nullptr, nullptr);
glfwMakeContextCurrent(window);

glfwSetKeyCallback(window, key_callback);

glewExperimental = GL_TRUE;
glewInit();

printf("%s\n",vertexShaderSource);
printf("%s\n",fragmentShaderSource);
GLint nrAttributes;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
std::cout << "Maximum nr of vertex attributes supported: " << nrAttributes << std::endl;
int width,height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);

//vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

//check
GLint success;
GLchar infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout<<"vertex shader compilation failed"<<std::endl;
}

//fragmeng shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource,NULL);
glCompileShader(fragmentShader);

glGetShaderiv(fragmentShader,GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout<<"fragment shader compilation failed"<<std::endl;
}

//create a program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

//check
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout<<"shaderPorgram failed"<<std::endl;
}

glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

//    GLfloat vertices[] = {
//        -0.5f, -0.5f, 0.0f, // Left
//        0.5f, -0.5f, 0.0f, // Right
//        0.0f,  0.5f, 0.0f  // Top
//    };
//    GLfloat vertices[] = {
//
//
//
//        // 第一个三角形
//        0.5f, 0.5f, 0.0f,   // 右上角
//        0.5f, -0.5f, 0.0f,  // 右下角
//        -0.5f, 0.5f, 0.0f,  // 左上角
//        // 第二个三角形
//        0.5f, -0.5f, 0.0f,  // 右下角
//        -0.5f, -0.5f, 0.0f, // 左下角
//        -0.5f, 0.5f, 0.0f   // 左上角
//
//    };

GLfloat vertices[] = {
// 位置              // 颜色
0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // 右下
-0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  // 左下
0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 顶部

};

GLuint VBO; // vertex buffer object,顶点缓冲对象
GLuint VAO; // vertex array object ,顶点数组对象

glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

//绑定
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);

//复制
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

//设置顶点属性指针,位置属性
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT) * 6, (GLvoid*)(0));
//启动顶点属性，位置是0
glEnableVertexAttribArray(0);

//设置颜色属性，启动
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, (GLvoid *)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);

//解绑
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);

//线框
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//GL_FILL 填充

while (!glfwWindowShouldClose(window)) {

glfwPollEvents();

display();

//激活着色器
glUseProgram(shaderProgram);

//        GLfloat timeValue = glfwGetTime();
//        GLfloat greenValue = (sin(timeValue) / 2) + 0.5;
//        GLint vertextColorLocation = glGetUniformLocation(shaderProgram, "ourColor");
//        glUniform4f(vertextColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
//
//绘制这个三角形
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, sizeof(vertices)/ (3 * sizeof(vertices[0])));
glBindVertexArray(0);

glfwSwapBuffers(window);
}

glDeleteVertexArrays(1,&VAO);
glDeleteBuffers(1, &VBO);

glfwTerminate();

return 0;
}

void display()
{
//缓冲颜色
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
//清空颜色缓冲
glClear(GL_COLOR_BUFFER_BIT);
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {

std::cout<<"enter escape";
glfwSetWindowShouldClose(window, GL_TRUE);
}
}