OpenGL FrameBufferObject 基础 (1)

最新推荐文章于 2024-07-31 23:00:27 发布
最新推荐文章于 2024-07-31 23:00:27 发布
阅读量1.1k 收藏
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulinxx/article/details/53827050
版权



参考:

http://learnopengl-cn.readthedocs.io/zh/latest/04%20Advanced%20OpenGL/05%20Framebuffers/





**********************************************************************************************************************************************************************

main.cpp


#include <string>

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

#include <GLFW/glfw3.h>

#include "Shader.h"
#include "Camera.h"

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <SOIL/SOIL.h>

#include <vector>

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glew32s.lib")
#pragma comment (lib, "glfw3.lib") 
#pragma comment (lib, "glfw3dll.lib") 
#pragma comment (lib, "glew32mxs.lib")
#pragma comment (lib, "assimp.lib")
#pragma comment(lib, "SOIL.lib")


GLuint WIDTH = 800, HEIGHT = 600;

void key_callback(GLFWwindow* pWnd, int key, int scancode, int action, int mode);
void scroll_callback(GLFWwindow* pWnd, double xoffset, double yoffset);
void mouse_callback(GLFWwindow* pWnd, double xpos, double ypos);
void Do_Movement();
GLuint loadTexture(GLchar* path, GLboolean alpha = false);
GLuint generateAttachmentTexture(GLboolean depth, GLboolean stencil);

// Camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
bool keys[1024];
GLfloat lastX = 400, lastY = 300;
bool firstMouse = true;

GLfloat deltaTime = 0.0f;
GLfloat lastFrame = 0.0f;

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

	GLFWwindow* pWnd = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed
	glfwMakeContextCurrent(pWnd);

	glfwSetKeyCallback(pWnd, key_callback);
	glfwSetCursorPosCallback(pWnd, mouse_callback);
	glfwSetScrollCallback(pWnd, scroll_callback);

	//glfwSetInputMode(pWnd, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	glewExperimental = GL_TRUE;
	glewInit();

	glViewport(0, 0, WIDTH, HEIGHT);

	glDepthFunc(GL_LESS);

	// 立方体
	GLfloat cubeVertices[] = {
		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,		0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 1.0f,		0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
		-0.5f,  0.5f,  0.5f,  0.0f, 1.0f,		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,		-0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		0.5f, -0.5f, -0.5f,  0.0f, 1.0f,		0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		0.5f, -0.5f,  0.5f,  0.0f, 0.0f,		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,		0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
		-0.5f,  0.5f,  0.5f,  0.0f, 0.0f,		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f
	};

	// 地面
	GLfloat floorVertices[] = {
		5.0f,  -0.5f,  5.0f,  2.0f, 0.0f,
		-5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
		-5.0f, -0.5f, -5.0f,  0.0f, 2.0f,

		5.0f,  -0.5f,  5.0f,  2.0f, 0.0f,
		-5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
		5.0f,  -0.5f, -5.0f,  2.0f, 2.0f
	};

	

	GLfloat quadVertices[] = {
		-1.0f,  1.0f,  0.0f, 1.0f,
		-1.0f, -1.0f,  0.0f, 0.0f,
		1.0f, -1.0f,  1.0f, 0.0f,

		-1.0f,  1.0f,  0.0f, 1.0f,
		1.0f, -1.0f,  1.0f, 0.0f,
		1.0f,  1.0f,  1.0f, 1.0f
	};

	// 数据处理
	// 盒子
	GLuint cubeVAO, cubeVBO;
	glGenVertexArrays(1, &cubeVAO);
	glGenBuffers(1, &cubeVBO);
	glBindVertexArray(cubeVAO);
	glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
	glBindVertexArray(0);

	// 地面
	GLuint floorVAO, floorVBO;
	glGenVertexArrays(1, &floorVAO);
	glBindVertexArray(floorVAO);

	{
		glGenBuffers(1, &floorVBO);
		glBindBuffer(GL_ARRAY_BUFFER, floorVBO);
		glBufferData(GL_ARRAY_BUFFER, sizeof(floorVertices), floorVertices, GL_STATIC_DRAW);

		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void*)0);
		glEnableVertexAttribArray(0);

		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
		glEnableVertexAttribArray(1);
	}
	glBindVertexArray(0);
	
	GLuint quadVAO, quadVBO;
	glGenVertexArrays(1, &quadVAO);
	glBindVertexArray(quadVAO);

	{
		glGenBuffers(1, &quadVBO);
		glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
		glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);

		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GL_FLOAT), (void*)0);
		glEnableVertexAttribArray(0);

		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GL_FLOAT), (void*)(2 * sizeof(GL_FLOAT)));
		glEnableVertexAttribArray(1);
	}
	glBindVertexArray(0);

	// Shader
	Shader shader("./Shader/advanced_vertex", "./Shader/advanced_fragement");
	Shader screenShader("./Shader/screen_vertex", "./Shader/screen_fragement");

	// 纹理
	GLuint textCube = loadTexture("./Img/cube.jpg");
	GLuint textFloor = loadTexture("./Img/floor.jpg");
	
	// 缓冲
	GLuint frameBufferObj;
	glGenFramebuffers(1, &frameBufferObj);	// 创建一个帧缓冲对象FBO
	// 创建一个空纹理
	GLuint textureColorBuffer = generateAttachmentTexture(GL_FALSE, GL_FALSE);
	glBindFramebuffer(GL_FRAMEBUFFER, frameBufferObj);

	{
		// 把创建的空纹理附加到帧缓冲上
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureColorBuffer, 0);

		GLuint renderBufferObj;
		glGenRenderbuffers(1, &renderBufferObj);	// 创建一个渲染缓冲对象 RenderBufferObject
		glBindRenderbuffer(GL_RENDERBUFFER, renderBufferObj);	// 把渲染缓冲对象绑定，后续渲染缓冲将在此RBO上操作
		// 创建一个深度和模板渲染缓冲对象    24位的深度和8位的模板缓冲
		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, WIDTH, HEIGHT);
		glBindRenderbuffer(GL_RENDERBUFFER, 0);

		// 将创建的RBO附加到FBO上
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, renderBufferObj);

		if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)	// 检查FBO是否正确
		{
			std::cout << "glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE" << std::endl;
		}
	}
	glBindFramebuffer(GL_FRAMEBUFFER, 0);	// 解绑帧缓冲

	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // 使用线框模式绘制
	// 绘制
	while (!glfwWindowShouldClose(pWnd))
	{
		GLfloat currentFrame = glfwGetTime();
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;

		glfwPollEvents();

		Do_Movement();

		glBindFramebuffer(GL_FRAMEBUFFER, frameBufferObj);	// 绑定到之前创建的FBO上, 并在此上绘制

		{
			glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

			glEnable(GL_DEPTH_TEST);

			shader.useShaderPrograme();

			glm::mat4 model = glm::mat4();
			glm::mat4 view = camera.GetViewMatrix();	 // 获取视变换矩阵
			// 投影矩阵
			glm::mat4 projection =
				glm::perspective(camera.Zoom, (float)WIDTH / (float)HEIGHT, 0.1f, 10.0f);

			glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "view"), 
				1, GL_FALSE, glm::value_ptr(view));

			glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "projection"), 1,
				GL_FALSE, glm::value_ptr(projection));

			// 绘制地面
			glBindVertexArray(floorVAO);
			glBindTexture(GL_TEXTURE_2D, textFloor);

			{
				model = glm::mat4();
				glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"),
					1, GL_FALSE, glm::value_ptr(model));
				glDrawArrays(GL_TRIANGLES, 0, 6);
			}
			glBindTexture(GL_TEXTURE_2D, 0);
			glBindVertexArray(0);

			// 绘制立方体
			glBindVertexArray(cubeVAO);
			glBindTexture(GL_TEXTURE_2D, textCube);

			{
				//model = glm::mat4();
				model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
				glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"),
					1, GL_FALSE, glm::value_ptr(model));
				glDrawArrays(GL_TRIANGLES, 0, 36);	// 第一个立方体

				model = glm::mat4();
				model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
				glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"),
					1, GL_FALSE, glm::value_ptr(model));
				glDrawArrays(GL_TRIANGLES, 0, 36);	// 第二个立方体
			}
			glBindTexture(GL_TEXTURE_2D, 0);
			glBindVertexArray(0);

			// 恢复默认FBO	在矩形上绘制FBO的纹理
			// 普通绘制
			glBindFramebuffer(GL_FRAMEBUFFER, 0);	// 解绑帧缓冲

			{
				glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
				glClear(GL_COLOR_BUFFER_BIT);
				glDisable(GL_DEPTH_TEST);

				screenShader.useShaderPrograme();

				glBindVertexArray(quadVAO);	// 像使用普通纹理一样需要绑定 注释掉即恍然大悟
				glBindTexture(GL_TEXTURE_2D, textureColorBuffer);
				{
					glDrawArrays(GL_TRIANGLES, 0, 6);
				}
				glBindVertexArray(0);
			}
		}
		//glBindFramebuffer(GL_FRAMEBUFFER, 0);	// 解绑帧缓冲

		glfwSwapBuffers(pWnd);	 // 交换缓存
	}

	// While 循环之后  清理资源,退出程序
	glDeleteVertexArrays(1, &cubeVAO);
	glDeleteVertexArrays(1, &floorVAO);
	glDeleteVertexArrays(1, &quadVAO);
	glDeleteBuffers(1, &cubeVBO);
	glDeleteBuffers(1, &floorVBO);
	glDeleteBuffers(1, &quadVBO);
	glDeleteFramebuffers(1, &frameBufferObj);

	glfwTerminate();
	return 0;
}


// 加载纹理
// 当把一个纹理附加到帧缓冲上的时候，所有渲染命令会写入到纹理上，就像它是一个普通的颜色/深度或者模板缓冲一样
GLuint loadTexture(GLchar* path, GLboolean alpha /*= false*/)
{
	int nPicW = 0, nPicH = 0;
	unsigned char* pChImg =
		SOIL_load_image(path, &nPicW, &nPicH, 0, alpha ? SOIL_LOAD_RGBA : SOIL_LOAD_RGB);

	GLuint textureID = 0;
	glGenTextures(1, &textureID);
	glBindTexture(GL_TEXTURE_2D, textureID);
	glTexImage2D(GL_TEXTURE_2D, 0, alpha ? GL_RGBA : GL_RGB, nPicW, nPicH, 0,
		alpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, pChImg);
	glGenerateMipmap(GL_TEXTURE_2D);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glBindTexture(GL_TEXTURE_2D, 0);
	SOIL_free_image_data(pChImg);
	return textureID;
}



// 添加纹理附件
GLuint generateAttachmentTexture(GLboolean depth, GLboolean stencil)
{
	GLenum eAttachType = 0;
	if ((!depth) && (!stencil))
	{
		eAttachType = GL_RGB;
	}
	else if (depth && (!stencil))
	{
		eAttachType = GL_DEPTH_COMPONENT;
	}
	else if ((!depth) && stencil)
	{
		eAttachType = GL_STENCIL_INDEX;
	}

	GLuint textureID = 0;
	glGenTextures(1, &textureID);	// 创建一个纹理对象
	glBindTexture(GL_TEXTURE_2D, textureID);	// 绑定纹理对象
	{
		// 将纹理对象创建一个空内存
		// 纹理设置为屏幕大小 不用关心环绕方式或者Mipmap，因为在大多数时候都不会需要它们的
		if ((!depth) && (!stencil))
		{
			glTexImage2D(GL_TEXTURE_2D, 0, eAttachType, WIDTH, HEIGHT, 0, 
				eAttachType, GL_UNSIGNED_BYTE, nullptr);
		}
		else
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, WIDTH, HEIGHT, 0,
				GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
		}
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}
	glBindTexture(GL_TEXTURE_2D, 0);
	return textureID;
}


void Do_Movement()
{
	// Camera controls
	if (keys[GLFW_KEY_W])
		camera.ProcessKeyboard(FORWARD, deltaTime);
	if (keys[GLFW_KEY_S])
		camera.ProcessKeyboard(BACKWARD, deltaTime);
	if (keys[GLFW_KEY_A])
		camera.ProcessKeyboard(LEFT, deltaTime);
	if (keys[GLFW_KEY_D])
		camera.ProcessKeyboard(RIGHT, deltaTime);
}


// Is called whenever a key is pressed/released via GLFW
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, GL_TRUE);

	if (action == GLFW_PRESS)
		keys[key] = true;
	else if (action == GLFW_RELEASE)
		keys[key] = false;
}


void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	if (firstMouse)
	{
		lastX = xpos;
		lastY = ypos;
		firstMouse = false;
	}

	GLfloat xoffset = xpos - lastX;
	GLfloat yoffset = lastY - ypos;

	lastX = xpos;
	lastY = ypos;

	camera.ProcessMouseMovement(xoffset, yoffset);
}


void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
	camera.ProcessMouseScroll(yoffset);
}


**********************************************************************************************************************************************************************

Camera.h


//Camera.h 

#pragma once

// Std. Includes
#include <vector>

// GL Includes
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>


// 摄像机移动方向  程序中用WSAD控制
enum Camera_Movement {
	FORWARD,
	BACKWARD,
	LEFT,
	RIGHT
};

// Default camera values
const GLfloat YAW = -90.0f;
const GLfloat PITCH = 0.0f;
const GLfloat SPEED = 3.0f;
const GLfloat SENSITIVTY = 0.25f;
const GLfloat ZOOM = 45.0f;


class Camera
{
public:
	// Camera Attributes
	glm::vec3 Position;
	glm::vec3 Front;
	glm::vec3 Up;
	glm::vec3 Right;
	glm::vec3 WorldUp;
	// Eular Angles
	GLfloat Yaw;
	GLfloat Pitch;
	// Camera options
	GLfloat MovementSpeed;
	GLfloat MouseSensitivity;
	GLfloat Zoom;

	// Constructor with vectors
	Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), 
		glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), GLfloat yaw = YAW, 
		GLfloat pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), 
		MovementSpeed(SPEED), MouseSensitivity(SENSITIVTY), Zoom(ZOOM)
	{
		this->Position = position;
		this->WorldUp = up;
		this->Yaw = yaw;
		this->Pitch = pitch;
		this->updateCameraVectors();
	}
	// Constructor with scalar values
	Camera(GLfloat posX, GLfloat posY, GLfloat posZ, GLfloat upX, GLfloat upY, 
		GLfloat upZ, GLfloat yaw, GLfloat pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), 
		MovementSpeed(SPEED), MouseSensitivity(SENSITIVTY), Zoom(ZOOM)
	{
		this->Position = glm::vec3(posX, posY, posZ);
		this->WorldUp = glm::vec3(upX, upY, upZ);
		this->Yaw = yaw;
		this->Pitch = pitch;
		this->updateCameraVectors();
	}

	// Returns the view matrix calculated using Eular Angles and the LookAt Matrix
	glm::mat4 GetViewMatrix()
	{
		return glm::lookAt(this->Position, this->Position + this->Front, this->Up);
	}

	// 按键处理
	void ProcessKeyboard(Camera_Movement direction, GLfloat deltaTime)
	{
		GLfloat velocity = this->MovementSpeed * deltaTime;
		if (direction == FORWARD)
			this->Position += this->Front * velocity;
		if (direction == BACKWARD)
			this->Position -= this->Front * velocity;
		if (direction == LEFT)
			this->Position -= this->Right * velocity;
		if (direction == RIGHT)
			this->Position += this->Right * velocity;
	}

	// 鼠标移动处理
	void ProcessMouseMovement(GLfloat xoffset, GLfloat yoffset, 
		GLboolean constrainPitch = true)
	{
		xoffset *= this->MouseSensitivity;
		yoffset *= this->MouseSensitivity;

		this->Yaw += xoffset;
		this->Pitch += yoffset;

		// Make sure that when pitch is out of bounds, screen doesn't get flipped
		if (constrainPitch)
		{
			if (this->Pitch > 89.0f)
				this->Pitch = 89.0f;
			if (this->Pitch < -89.0f)
				this->Pitch = -89.0f;
		}

		// Update Front, Right and Up Vectors using the updated Eular angles
		this->updateCameraVectors();
	}

	// Processes input received from a mouse scroll-wheel event. 
	//		Only requires input on the vertical wheel-axis
	void ProcessMouseScroll(GLfloat yoffset)
	{
		if (this->Zoom >= 1.0f && this->Zoom <= 45.0f)
			this->Zoom -= yoffset;
		if (this->Zoom <= 1.0f)
			this->Zoom = 1.0f;
		if (this->Zoom >= 45.0f)
			this->Zoom = 45.0f;
	}

private:
	// Calculates the front vector from the Camera's (updated) Eular Angles
	void updateCameraVectors()
	{
		// Calculate the new Front vector
		glm::vec3 front;
		front.x = cos(glm::radians(this->Yaw)) * cos(glm::radians(this->Pitch));
		front.y = sin(glm::radians(this->Pitch));
		front.z = sin(glm::radians(this->Yaw)) * cos(glm::radians(this->Pitch));
		this->Front = glm::normalize(front);
		// Also re-calculate the Right and Up vector
		// Normalize the vectors, because their length gets closer to 0 the more 
		//		you look up or down which results in slower movement.
		this->Right = glm::normalize(glm::cross(this->Front, this->WorldUp));  
		this->Up = glm::normalize(glm::cross(this->Right, this->Front));
	}
};


**********************************************************************************************************************************************************************

Shader.h



//Shader.h 
#pragma once

#ifndef TEXTURE_SHADER_H_
#define TEXTURE_SHADER_H_

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include <gl/glew.h>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include <GL/glew.h>

class Shader
{
public:
	Shader(const GLchar* vertexPath, const GLchar* fragmentPath);
	~Shader();

public:
	void useShaderPrograme();

	GLuint getPrograme() {
		return this->m_nProgram;
	}

private:
	GLuint  m_nProgram;
};

Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath)
{
	std::string vertexCode;
	std::string fragmentCode;
	std::ifstream vertexShaderF;
	std::ifstream fragementShaderF;

	vertexShaderF.exceptions(std::ifstream::badbit);
	fragementShaderF.exceptions(std::ifstream::badbit);

	try
	{
		vertexShaderF.open(vertexPath);		// 打开文件
		fragementShaderF.open(fragmentPath);

		std::stringstream vertexShaderStream, fragementShaderStream;
		vertexShaderStream << vertexShaderF.rdbuf();	// 读取文件至stringstream中
		fragementShaderStream << fragementShaderF.rdbuf();

		vertexShaderF.close();
		fragementShaderF.close();

		vertexCode = vertexShaderStream.str();		// 转换成string类型
		fragmentCode = fragementShaderStream.str();
	}
	catch (std::ifstream::failure e)
	{
		std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ:" << std::endl;
	}

	const GLchar* pVertexCode = vertexCode.c_str();	// string 转 char*
	const GLchar* pFragementCode = fragmentCode.c_str();

	GLuint nVertexShader, nFragementShader;
	GLint nRes = 0;
	GLchar chLogInfo[512] = { '\0' };

	// 创建顶点着色器
	nVertexShader = glCreateShader(GL_VERTEX_SHADER);
	// 将顶点着色程序的源代码字符数组绑定到顶点着色器对象
	glShaderSource(nVertexShader, 1, &pVertexCode, nullptr);
	glCompileShader(nVertexShader); // compile shader 编译着色器

	// 获取编译结果
	glGetShaderiv(nVertexShader, GL_COMPILE_STATUS, &nRes);
	if (!nRes)
	{
		glGetShaderInfoLog(nVertexShader, 512, nullptr, chLogInfo);
		std::cout << "ERROR::SHADEF::VERTEX::COMPILATION_FAILED:" << chLogInfo << std::endl;
	}

	// 创建片断着色器
	nFragementShader = glCreateShader(GL_FRAGMENT_SHADER);
	// 将片段着色程序的源代码字符数组绑定到片段着色器对象
	glShaderSource(nFragementShader, 1, &pFragementCode, nullptr);
	glCompileShader(nFragementShader);
	glGetShaderiv(nFragementShader, GL_COMPILE_STATUS, &nRes);
	if (!nRes)
	{
		glGetShaderInfoLog(nFragementShader, 512, nullptr, chLogInfo);
		std::cout << "ERROR::SHADEF::FRAGEMENT::COMPILATION_FAILED:" << chLogInfo << std::endl;
	}

	this->m_nProgram = glCreateProgram();	// 创建GLSL程序
	glAttachShader(this->m_nProgram, nVertexShader);	// 绑定shader到program
	glAttachShader(this->m_nProgram, nFragementShader);

	// glLinkProgram操作产生最后的可执行程序，它包含最后可以在硬件上执行的硬件指令
	glLinkProgram(this->m_nProgram);		// 链接
	glGetProgramiv(this->m_nProgram, GL_LINK_STATUS, &nRes);
	if (!nRes)
	{
		glGetProgramInfoLog(this->m_nProgram, 512, nullptr, chLogInfo);
		std::cout << "ERROR::SHADEF::FRAGEMENT::LINK_FAILED:" << chLogInfo << std::endl;
	}

	glDeleteShader(nVertexShader);
	glDeleteShader(nFragementShader);
}

Shader::~Shader()
{
}

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

void Shader::useShaderPrograme()
{
	glUseProgram(this->m_nProgram);	// 使用porgram
}

#endif



**********************************************************************************************************************************************************************

***********************************************************************************


GLSL Shader 部分



**********************************************************************************************************************************************************************

advanced_vertex


// Vertex shader:
// ================
#version 330 core
layout (location = 0) in vec3 position;
layout (location = 1) in vec2 texCoords;

out vec2 TexCoords;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0f);
    TexCoords = texCoords;
}



**********************************************************************************************************************************************************************

advanced_fragement


// Fragment shader:
// ================
#version 330 core

in vec2 TexCoords;

out vec4 color;

uniform sampler2D ourTexture;

void main()
{
    color = texture(ourTexture, TexCoords);
}



**********************************************************************************************************************************************************************

screen_vertex


// Vertex shader:
// ================
#version 330 core

layout(location = 0) in vec2 position;
layout(location = 1) in vec2 textCoord;


uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;

out vec2 TextCoord;

void main()
{
	gl_Position = vec4(position.x, position.y, 0.0, 1.0);
	TextCoord = textCoord;
}

**********************************************************************************************************************************************************************

screen_fragement


// Fragment shader:
// ================
#version 330 core

in vec2 TextCoord;
uniform sampler2D text;

out vec4 color;

void main()
{
	color = texture(text, TextCoord);
}



glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // 使用线框模式绘制  

效果:








源码下载: VS2015

http://download.csdn.net/detail/yulinxx/9719073


advanced_fragement  中 , 修改如下红色一行, 则可以实现反色:

#version 330 core


in vec2 TexCoords;


out vec4 color;


uniform sampler2D ourTexture;


void main()
{
    color =1-texture(ourTexture, TexCoords);
}



cmake.EXE
关注
专栏目录
OpenGL学习脚印: 帧缓冲对象(Frame Buffer Object)
王定桥的专栏
09-03 1万+
写在前面 一直以来，我们在使用OpenGL渲染时，最终的目的地是默认的帧缓冲区，实际上OpenGL也允许我们创建自定义的帧缓冲区。使用自定义的帧缓冲区，可以实现镜面，离屏渲染，以及很酷的后处理效果。本节将学习帧缓存的使用，文中示例代码均可以在我的github下载。 本节内容整理自 1.OpenGL Frame Buffer Object (FBO) 2.www.learn
OpenGL学习（九）阴影映射（shadowMapping）
AKGWSB 's blog
01-02 4522
目录写在前面阴影映射原理简介 写在前面 今天是 2021 年的第一天，不管 2020 怎么说，都翻篇了，需要看向一个前方。新年快乐！ 书接上文：OpenGL学习（八）phong光照模型 上次我们讲到通过 phong 光照模型进行简单光照特效的绘制。今天我们使用阴影映射技术，来进一步绘制阴影，使得场景的光照效果更加逼真。 事实上，这是我第 n 次写这个内容了。。。 第一次是：从零开始编写minecraft光影包（1）基础阴影绘制 第二次是：深大计算机图形学大作业之虚拟场景建模 第 3 到 n-1 次是帮别人
Android OpenGL ES->Frame Buffer Object
mapdigit
06-24 167
Frame Buffer 对象的概念可以参见前面文章Android OpenGL ES 开发教程(23)：FrameBuffer。 简单的和2D图像类比，Frame Buffer 如果 对应到二维图形环境中，就是一个2D的内存数组空间，缺省情况为屏幕的显存，也可以创建Offscreen 内存空间，此时Frame Buffer 可以是一个二维数组，数组每个元素代表一个像素颜色。 对于三维图形来说...
QML之QQuickFramebufferObject
最新发布
Roads
07-31 375
在大多数平台上，渲染将在专用线程上进行。在以QML和C++混合编程的项目开发中遇到涉及到视频播放的需求，预研过程中发现如果直接使用QML中Image来一帧帧显示图像，导致帧率相当感人，在嵌入式ARM-Linux环境中可能仅有2-3帧/秒。在寻找相关解决方法时偶然看到Qt中QQuickFramebufferObject类可以结合QOpenglFunctions来显示图片解决该问题，实际开发完成后测试基于上述解决方法在同样嵌入式环境中可以达到15帧/秒以上的显示，效果达到目标设计。
【OpenGL】OpenGL帧缓存对象(FBO：Frame Buffer Object)
热门推荐
计算机专业同学的充电站。
02-22 6万+
翻译的，如果不正确，敬请谅解和指正。 OpenGL Frame BufferObject(FBO) Overview:     在OpenGL渲染管线中，几何数据和纹理经过多次转化和多次测试，最后以二维像素的形式显示在屏幕上。OpenGL管线的最终渲染目的地被称作帧缓存（framebuffer）。帧缓冲是一些二维数组和OpenG所使用的存储区的集合：颜色缓存、深度缓存、模板缓存和累计缓存。一
frame buffer object (fbo)整理
weixin_34198583的博客
12-07 181
FBO: frame buffer object主要用来render-to-texture,进行off-screen rendering. 以下是使用步骤： 1,初始化glewInit(),然后检测 GPU是否支持GL_EXT_FRAMEBUFFER_OBJECT扩展 2,创建FBO , GLuint fbo, color; // Create an FBO glGenFramebu...
OpenGL编程指南第十章：Frame buffer
weixin_30606461的博客
01-11 323
OpenGL在图元rasterazation之后，得到的是fragment，fragment不是最后的像素数据，但和像素对应；fragment需要经过一写了的处理，blend，texture，lighting...，才会得到最后的像素。用来缓存fragment数据的缓冲区，就是frame buffer。 fragment相关的数据有color，sten...
FrameBufferObject 基础
12-23
OpenGL FrameBufferObject（FBO）是图形编程中的一个重要概念，特别是在3D渲染和离屏处理中。FBO允许开发者创建自定义的渲染目标，而不仅仅是屏幕。在OpenGL中，FBO用于实现复杂的图像处理，例如多重采样抗锯齿、...
Deferred Shading延迟渲染.zip
05-31
Exercise 9：Deferred ...1.在练习8的基础上，实现Deferred Shading算法； 考察目的： 1.阅读文献，理解并实现文献中算法； 2.通过FrameBufferObject实现render-to-texture技术； 3.实现multiple-render-targets技术；
webgl编程指南及源码1/2
05-08
示例程序（FramebufferObject.js） 382 创建帧缓冲区对象（gl.createFramebuffer()） 385 创建纹理对象并设置其尺寸和参数 385 创建渲染缓冲区对象（gl.createRenderbuffer()） 386 绑定渲染缓冲区并设置其尺寸...
Android平台美颜相机/Camera实时滤镜/视频编解码/影像后期/人脸技术探索——2.1 GPUImage结构简析
Martin的博客
02-17 5818
Github项目地址回到目录说到基于GPU的图像处理和实时滤镜，大家肯定会想到鼎鼎大名的GPUImage，这个项目确实为后续开发提供了很多方便，基本的图像处理工具一应俱全。IOS版的项目比较活跃，Android的好像已经被遗弃好久了，一堆bug没人解决。但是学习借鉴GPUImage的项目结构，可以为我们提供不小的帮助。GPUImage项目结构GPUImage的项目结构其实很简单，Android版本就
OpenGL3.3_FrameBuffer_RenderToTexture.rar
08-28
OpenGL3.3_FrameBuffer_RenderToTexture.rar
Framebuffer Object
杨德龙的专栏
03-27 4386
 很久以前我介紹過OpenGL的Pixel Buffer，那是一種可以在一張不會被顯示出來的畫布上畫圖的技術(off-screen rendering)。但是此技術已提出很久了，而且非常多限制！第一，它只能在視窗化的系統上使用；第二，Pixel Buffer與原來的Frame Buffer資源完全獨立，實作上會浪費不少空間。另外還有一些使用上不方便的因素。因此OpenGL在2003年提供了一個
OpenGL Frame Buffer Object
杨德龙的专栏
06-27 2680
 IntroductionIn the last OpenGL Framebuffer object article we covered the basic usage of an FBO for rendering to a single texture and then applying that texture some where else. However this isn’t
FrameBufferObject.cpp
让阳光照进心里
10-08 1911
帧缓冲区对象,Frame Buffer Object.创建渲染缓冲区,将渲染管线的输出可指定到渲染缓冲区,同时可以读渲染缓冲区.这些都是通过绑定帧缓冲区来做的.代码中将颜色输出分别写到两个渲染缓冲区中,再将这两个缓冲区的内容分别写到默认帧缓冲区中,效果就是左右颜色明暗不一样.书上的代码很复杂,我又实现了一个简单版的.加油吧,抓紧学习渲染,目前的进度比自己预想的慢太多太多了. // FrameBu
帧缓存对象 Frame Buffer Object
u014767384的博客
08-18 3755
1. 概述 2. 创建FBO 3. 创建 帧缓存附加图像 (framebuffer-attachable image) 3.1. 创建 纹理图像 (texture images) 3.2. 创建 Renderbuffer图像 (Renderbuffer images) 4. 绘制到纹理（Render to texture） 5. 使用后处理效果(postprocessing) ...
OpenGL使用Frame Buffer Object（FBO）来进行离屏渲染
Yilian9990的博客
04-26 2110
/ 颜色缓冲区对象的句柄。// 深度缓冲区对象的句柄。// 生成的纹理对象的句柄。GLuint fbo;// FBO对象的句柄。// 2、创建颜色缓冲区对象并附加到FBO。// 3、创建深度缓冲区对象并附加到FBO。// 4、创建纹理对象并附加到FBO。// 解绑FBO并恢复默认帧缓冲区。// 1、创建FBO对象。// 检查FBO是否完整。// 绘制场景到FBO。// 渲染场景 ...
【OpenGL帧缓存对象(FBO：Frame Buffer Object)】
xuexi23456的博客
07-26 1154
OpenGL帧缓存对象(FBO：Frame Buffer Object)
OpenGL Framebuffer Object (FBO)
techx的专栏
03-05 2094
在OpenGL中， OpenGL Context有一个默认的FBO用来绘制图像, 但是我们也可以创建新的用户定义的Framebuffers, 这样我们可以绘制到自定义的framebuffer, 而不会影响到窗口系统。关键词定义 Image: 本文中， Image是包含像素的二维数组，这些像素具有特定的存储格式。 Layered Image: 具有某一特定尺寸和格式的一套images, 对应于tex
OpenGL入门：从基础到实践
这个PDF教程是为初学者设计的，旨在引导读者逐步了解并掌握OpenGL的基础知识，从而进入图形编程的世界。OpenGL与C语言紧密集成，因此对于熟悉C语言的人来说，学习起来相对容易。 1. **与C语言的结合** OpenGL的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值