OpenGL學習（二）着色器

原創 煮雪品茶 2020-02-22 11:38

中文OpenGL學習網站：https://learnopengl-cn.github.io

一、着色器之間可以相互傳遞數據（只要類型和名稱一樣）

畫一個紅色的三角形

1.1代碼

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexShaderSource =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"out vec4 VertexColor;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos,1.0);\n"
"	VertexColor=vec4(0.5,0.0,0.0,0.0);\n"
"}\0";
const char *FragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"
"in vec4 VertexColor;\n"
"void main()\n"
"{\n"
"	FragColor=VertexColor;\n"
"}\n\0";
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to  create window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	//着色器
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexShaderSource, NULL);
	glCompileShader(VertexShader);
	int Success;
	char InfoLog[512];
	glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(VertexShader, 512, NULL, InfoLog);
		std::cout << "error::shader::vertex::compilation failed\n" << InfoLog << std::endl;
	}
	int 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 << "error::shader::fragment::compilation failed\n" << InfoLog << std::endl;
	}
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
	if (!Success)
	{
		glGetProgramInfoLog(ShaderProgram, 512, NULL, InfoLog);
		std::cout << "error::shader::program::linking failed\n" << InfoLog << std::endl;
	}
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	//數據
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,
		-0.5f,0.0f,0.0f,
		0.5f,0.0f,0.0f
	};
	unsigned int VAO, VBO;
	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, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1,&VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}

1.2 結果

 

二、利用uniform傳遞參數

繪製顏色有綠變黑然後由黑變綠的三角形，其中顏色的值使用uniform傳遞

2.1代碼

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
const char *VertexsShaderSource1 =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos,1.0f);\n"
"}\n\0";
const char *FragmentShaderSource1 =
"#version 330 core\n"
"out vec4 FragColor;\n"
"uniform vec4 OurColor;\n"
"void main()\n"
"{\n"
"	FragColor=OurColor;\n"
"}\n\0";

//着色器使用uniform傳遞數據
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialze glad" << std::endl;
		return -1;
	}
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexsShaderSource1, NULL);
	glCompileShader(VertexShader);
	int Success;
	char InfoLog[512];
	glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(VertexShader, 512, NULL, InfoLog);
		std::cout << "error::shader::vertex::compilation failed\n" << InfoLog << std::endl;
	}
	int FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader, 1, &FragmentShaderSource1, NULL);
	glCompileShader(FragmentShader);
	glGetShaderiv(FragmentShader, GL_COMPILE_STATUS, &Success);
	if (!Success)
	{
		glGetShaderInfoLog(FragmentShader, 512, NULL, InfoLog);
		std::cout << "error::shader::fragment::compilation failed\n" << InfoLog << std::endl;
	}
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
	if (!Success)
	{
		glGetProgramInfoLog(ShaderProgram, 512, NULL, InfoLog);
		std::cout << "error::shader::program::linking failed\n" << InfoLog << std::endl;
	}
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,
		-0.5f,0.0f,0.0f,
		0.5f,0.0f,0.0f
	};
	unsigned int VAO, VBO;
	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, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		float TimeValue = glfwGetTime();
		float GreenValue = sin(TimeValue) / 2.0f + 0.5f;
		int ColorLocation = glGetUniformLocation(ShaderProgram, "OurColor");
		glUniform4f(ColorLocation, 0.0f, GreenValue, 0.0f, 1.0f);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1,&VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}

 

2.2結果

跟隨時間由綠變黑，然後又由黑變綠

三、利用頂點數據傳遞更多的屬性

畫一個每個頂點帶顏色的三角形

3.1代碼

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}

const char *VertexShaderSource2 =
"#version 330 core\n"
"layout (location=0) in vec3 aPos;\n"
"layout (location=1) in vec3 Color;\n"
"out vec4 OurColor;\n"
"void main()\n"
"{\n"
"	gl_Position=vec4(aPos,1.0f);\n"
"	OurColor=vec4(Color,1.0f);\n"
"}\n\0";
const char *FragmentShaderSource2 =
"#version 330 core\n"
"out vec4 FragColor;\n"
"in vec4 OurColor;\n"
"void main()\n"
"{\n"
"	FragColor=OurColor;\n"
"}\n\0";

//頂點屬性在頂點數據裏面
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	int VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(VertexShader, 1, &VertexShaderSource2, NULL);
	glCompileShader(VertexShader);
	int FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(FragmentShader, 1, &FragmentShaderSource2, NULL);
	glCompileShader(FragmentShader);
	int ShaderProgram = glCreateProgram();
	glAttachShader(ShaderProgram, VertexShader);
	glAttachShader(ShaderProgram, FragmentShader);
	glLinkProgram(ShaderProgram);
	glDeleteShader(VertexShader);
	glDeleteShader(FragmentShader);
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,1.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f,0.0f,1.0f,0.0f,
		0.5f,0.0f,0.0f,0.0f,0.0f,1.0f
	};
	unsigned int VAO, VBO;
	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, 6 * sizeof(float), (void*)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glUseProgram(ShaderProgram);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1,&VBO);
	glfwTerminate();
	return 0;
}

 

3.2結果

設置頂點帶顏色，OpenGL會對片元進行插值，所以會出現漸變的顏色。

 

四、創建着色器類，方便以後使用

畫一個頂點帶顏色的三角形，和上面一樣

4.1代碼

//着色器類
#pragma once
#include <glad/glad.h>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class CShader
{
public:
	unsigned int m_ShaderId;
	CShader(const char* VertexPath, const char* FragmentPath)
	{
		std::string VertexCode, FragmentCode;
		//着色器文件
		std::ifstream VertexShaderFile, FragmentShaderFile;
		//確保可以拋出異常
		VertexShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
		FragmentShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
		try
		{
			//打開文件
			VertexShaderFile.open(VertexPath);
			FragmentShaderFile.open(FragmentPath);
			//讀取文件緩衝區的內容到stream流中
			std::stringstream VertexShaderStream, FragmentShaderStream;
			VertexShaderStream << VertexShaderFile.rdbuf();
			FragmentShaderStream << FragmentShaderFile.rdbuf();
			//關閉文件
			VertexShaderFile.close();
			FragmentShaderFile.close();
			//將stream流的內容轉換成字符串類型，得到着色器代碼
			VertexCode = VertexShaderStream.str();
			FragmentCode = FragmentShaderStream.str();
		}
		catch (std::ifstream::failure e)
		{
			std::cout << "error::shader failed to open shader file" << std::endl;
		}
		const char *VertexShaderCode = VertexCode.c_str();
		const char *FragmentShaderCode = FragmentCode.c_str();
		//編譯着色器
		unsigned int VertexShader, FragmentShader;
		//編譯頂點着色器
		VertexShader = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(VertexShader, 1, &VertexShaderCode,NULL);
		glCompileShader(VertexShader);
		checkCompileErrors(VertexShader, "VERTEX");
		//編譯片段着色器
		FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(FragmentShader, 1, &FragmentShaderCode, NULL);
		glCompileShader(FragmentShader);
		checkCompileErrors(FragmentShader, "FRAGMENT");
		//編譯着色器程序
		m_ShaderId = glCreateProgram();
		glAttachShader(m_ShaderId, VertexShader);
		glAttachShader(m_ShaderId, FragmentShader);
		glLinkProgram(m_ShaderId);
		checkCompileErrors(m_ShaderId, "PROGRAM");
		glDeleteShader(VertexShader);
		glDeleteShader(FragmentShader);
	}
	void useProgram()
	{
		glUseProgram(m_ShaderId);
	}

	void setBool(const std::string &vName, bool Value) const
	{
		glUniform1i(glGetUniformLocation(m_ShaderId, vName.c_str()), (int)Value);
	}
	void setInt(const std::string &vName, int Value) const
	{
		glUniform1i(glGetUniformLocation(m_ShaderId, vName.c_str()), Value);
	}
	void setFloat(const std::string &vName, float Value) const
	{
		glUniform1f(glGetUniformLocation(m_ShaderId, vName.c_str()), Value);
	}

private:
	void checkCompileErrors(unsigned int vShader, std::string vType)
	{
		int Success;
		char InfoLog[1024];
		if (vType != "PROGRAM")
		{
			glGetShaderiv(vShader, GL_COMPILE_STATUS, &Success);
			if (!Success)
			{
				glGetShaderInfoLog(vShader, 1024, NULL, InfoLog);
				std::cout << "error::shader::complie "<<vType<<"\n" << InfoLog << std::endl;
			}
		}
		else
		{
			glGetProgramiv(m_ShaderId, GL_LINK_STATUS, &Success);
			if (!Success)
			{
				glGetProgramInfoLog(m_ShaderId, 1024, NULL, InfoLog);
				std::cout << "error::shader::link " << vType << "\n" << InfoLog << std::endl;
			}
		}
	}
};

//main函數
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "CShader.h"


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}

//自己創建一個Shader類，方便以後使用
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	CShader ShaderProgram("Shader/Vertex/VertexSource1.glsl", "Shader/Fragment/FragmentSource1.glsl");
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,1.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f,0.0f,1.0f,0.0f,
		0.5f,0.0f,0.0f,0.0f,0.0f,1.0f
	};
	unsigned int VAO, VBO;
	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, 6 * sizeof(float), (void*)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		ShaderProgram.useProgram();
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}
//頂點着色器文件
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 Color;
out vec4 OurColor;
void main()
{
	gl_Position = vec4(aPos, 1.0f);
	OurColor = vec4(Color, 1.0f);
}
//片段着色器文件
#version 330 core
out vec4 FragColor;
in vec4 OurColor;
void main()
{
	FragColor = OurColor;
}

4.2結果

五、修改頂點着色器讓三角形上下顛倒

畫一個顛倒的三角形

5.1代碼

CShader類使用上面抽象的類，以後直接使用，着色器程序需要用文本保存，注意路徑！

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "CShader.h"


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
//修改頂點着色器讓三角形上下顛倒
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,1.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f,0.0f,1.0f,0.0f,
		0.5f,0.0f,0.0f,0.0f,0.0f,1.0f
	};
	unsigned int VAO, VBO;
	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, 6 * sizeof(float), (void*)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	CShader ShaderProgram("Shader/Vertex/VertexSource2.glsl", "Shader/Fragment/FragmentSource1.glsl");
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		ShaderProgram.useProgram();
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1,&VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;

}
//頂點着色器部分
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 Color;
out vec4 OurColor;
void main()
{
	gl_Position = vec4(aPos.x,-aPos.y,aPos.z, 1.0f);
	OurColor = vec4(Color, 1.0f);
}
//片段着色器部分
#version 330 core
out vec4 FragColor;
in vec4 OurColor;
void main()
{
	FragColor = OurColor;
}

5.2結果

六、使用uniform定義一個水平偏移量，在頂點着色器中使用這個偏移量把三角形移動到屏幕右側

6.1代碼

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "CShader.h"


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
//使用uniform定義一個水平偏移量，在頂點着色器中使用這個偏移量把三角形移動到屏幕右側
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	float Vertices[] =
	{
		0.0f,0.5f,0.0f,1.0f,0.0f,0.0f,
		-0.5f,0.0f,0.0f,0.0f,1.0f,0.0f,
		0.5f,0.0f,0.0f,0.0f,0.0f,1.0f
	};
	unsigned int VAO, VBO;
	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, 6 * sizeof(float), (void*)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	CShader ShaderProgram("Shader/Vertex/VertexSource3.glsl", "Shader/Fragment/FragmentSource1.glsl");
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		ShaderProgram.useProgram();
		ShaderProgram.setFloat("Distance", 0.5f);
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}
//頂點着色器
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 Color;
uniform float Distance;
out vec4 OurColor;
void main()
{
	gl_Position = vec4(aPos.x + Distance, aPos.y, aPos.z, 1.0f);
	OurColor = vec4(Color, 1.0f);
}
//片段着色器
#version 330 core
out vec4 FragColor;
in vec4 OurColor;
void main()
{
	FragColor = OurColor;
}

6.2結果

七、使用out關鍵字把頂點位置輸出到片段着色器，並將片段的顏色設置爲與頂點位置相等（來看看連頂點位置值都在三角形中被插值的結果）

7.1代碼

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "CShader.h"


const unsigned int WIDTH = 800;
const unsigned int HEIGHT = 600;
void callbackFramebufferSize(GLFWwindow *vWindow, int vWidth, int vHeight)
{
	glViewport(0, 0, vWidth, vHeight);
}
void processInput(GLFWwindow *vWindow)
{
	if (glfwGetKey(vWindow, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(vWindow, true);
	}
}
//使用out關鍵字把頂點位置輸出到片段着色器，並將片段的顏色設置爲與頂點位置相等
//（來看看連頂點位置值都在三角形中被插值的結果）
int main()
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	GLFWwindow *Window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL);
	if (Window == NULL)
	{
		std::cout << "failed to create glfw window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(Window);
	glfwSetFramebufferSizeCallback(Window, callbackFramebufferSize);
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "failed to initialize glad" << std::endl;
		return -1;
	}
	float Vertices[] =
	{
		0.1f,0.5f,0.0f,
		-0.5f,0.1f,0.0f,
		0.5f,0.1f,0.0f
	};
	unsigned int VAO, VBO;
	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, 6 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
	CShader ShaderProgram("Shader/Vertex/VertexSource4.glsl", "Shader/Fragment/FragmentSource2.glsl");
	while (!glfwWindowShouldClose(Window))
	{
		processInput(Window);
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		ShaderProgram.useProgram();
		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		glfwSwapBuffers(Window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}
//頂點着色器
#version 330 core
layout(location = 0) in vec3 aPos;
out vec3 Dis;
void main()
{
	gl_Position = vec4(aPos, 1.0f);
	Dis = aPos;
}
//片段着色器
#version 330 core
out vec4 FragColor;
in vec3 Dis;
void main()
{
	FragColor = vec4(Dis, 1.0f);
}

7.2結果

 

 

 

 

 

 

 

 

 

煮雪品茶
發佈了37 篇原創文章 · 獲贊 3 · 訪問量 1萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

計算機圖形學定義

1.在計算機上生成圖形的工具 2.與圖形交互的工具 3.快速繪製圖形的硬件 4.圖形真實感的顯示 5.仿真物理現象的算法 6.可視化複雜數學的工具   計算機圖形學 -對非圖形信息產生圖形 模式識別 -對圖像提取特徵，予以分類和描述關係，

小猴子编程 2020-07-07 13:45:03

計算機圖形學-----畫直線

#include<GL/glut.h>void init(void){    glClearColor(1.0,1.0,1.0,0.0);    glMatrixMode(GL_PROJECTION);    gluOrtho2D(0.

gz_gy 2020-07-07 11:50:17

角度離散法畫畫弧和橢圓

角度離散法可以利用已有的直線算法來分段繪製圓弧、橢圓弧。這種方法的優點在於可以自由控制所繪製的弧的角度範圍。 完整代碼： #include<GL/glut.h> #include<windows.h> #include<math

AbornCommander 2020-07-06 10:30:08

Games101--Assignment2

Gams101的Assignment2的要求如下： 修改函數rasterize_triangle(const Triangle& t)。 該函數的內部工作流程如下： 創建三角形的2 維bounding box。 遍歷此bound

Enterprise_ 2020-07-06 09:13:44

《高級計算機圖形學》大作業的報告

《高級計算機圖形學》大作業報告 1 圖形學與圖形系統簡述 計算機圖形學是一種使用數學算法將二維或三維圖形轉化爲計算機顯示器的柵格形式的科學。它的主要研究內容就是研究如何在計算機中表示圖形、以及利用計算機進行圖形的計算、處理和顯示的相關原理

未来信使 2020-07-06 08:04:21

OpenGL錯誤解決方案

今天寫了個最簡單的Opengl程序，可是發現怎麼都有錯誤，一直提示 /tmp/ccQSf6CG.o:7.cpp:function display(): error: undefined reference to 'gluLook 首先從網

zhouzhouzf 2020-07-06 06:46:26

OpenGL中簡單動畫之矩形旋轉

OpenGL動畫生成最基本的方式就是，利用ilde函數進行重新繪製 那麼很簡單就是利用glutPostRedisplay();函數進行搞定 廢話不多說，看程序 #include <GL/glut.h> #include <math.h>

zhouzhouzf 2020-07-06 06:46:26

跟我一起從零基礎開始學OpenGL-01

爲什麼想學OpenGL,厭煩了業務代碼，厭煩了學習使用各種框架，厭煩了碼蟻一樣的生活，房租，水電，面試，工作…… 人總是要有理想的，以前學算法，學組原，也是人云亦云，必須要學這個。後面學前端也是，從HTML到JS到React到放棄。 我本

香辣素毛肚 2020-07-06 06:32:05

【圖形學與遊戲編程】開發筆記-基礎篇6:緩衝區與混合

（本系列文章由pancy12138編寫，轉載請註明出處：http://blog.csdn.net/pancy12138） 上一次的教程大家瞭解了最簡單的着色方法，那麼這一節我們來講解一些與着色無關的渲染管線流程。雖然在上一次的教程中我們成

pancy12138 2020-07-05 19:20:24

畫線算法的實現

衆所周知，VC++中畫圖算法封裝在一個重要的類CDC中。。。基本的像LineTo();MoveTo()等， 要說到畫線，其實底層的算法也不是很難。。。在這裏貼幾個代碼分享一下!(這裏只在MFC的view類OnDraw函數實現) 1、DD

blueboy82006 2020-07-05 17:22:48

計算機圖形學複習0

由於需要準備計算機圖形學的考試，開始複習計算機圖形學，這裏將持續爲大家帶來圖形學的基礎內容更新和一些例題講解。希望能夠更新完成吧。喜歡的小夥伴可以先關注博主，以免找不到。 重點內容，已加粗 計算機圖形學的基本概念 什麼是計算機圖形

暖风吹起云 2020-07-05 08:07:34

GAMES101-現代計算機圖形學入門-閆令琪 - lecture15 光線追蹤3 - 輻射度量學、渲染方程(Ray Tracing 3) - 課後筆記

光線追蹤3 - 輻射度量學、渲染方程和全局光照 內容： 輻射度量學 光線傳輸（Light transport） 反射方程（The reflection equation） 渲染方程（The rendering equation

教宗沙立van 2020-07-03 23:27:12

deepin gcc編譯glfw需要的依賴

-lGLEW -lglfw3 -lGL -lX11 -lXxf86vm -lpthread -ldl -lXrandr -lXinerama -lXcursor 折騰一下午總算能用了

天亮就睡觉 2020-07-03 14:26:41

計算機圖形學OpenGL學習實驗二——Bresenham畫線算法的模擬

寫在開頭： 相關實驗是學校開設課程的相關實驗，本人所作較爲粗淺，若有同校師弟瀏覽，望看懂借鑑而非照搬全抄。 實驗目的： 理解Bresenham畫線算法 實驗內容： 用Bresenham畫線算法實現水平、垂直、斜率大於1、斜率小於1、斜率爲

临风浅吟 2020-07-03 07:43:07

光柵圖形學(三)——梁友棟-Barskey剪裁算法

光柵圖形學(三)——梁友棟-Barskey剪裁算法 一、問題轉換 直線的參數方程 x=x1+u(x2−x1)y=y1+u(y2−y1) \begin{aligned} &amp;x = x_1+u(x_2-x_1) \\ &am

HachiLin 2020-07-03 00:33:26