OGLStencil深度测试 模板测试 以及 Alpha混合_VS2015

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

参考:

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


修正:    

通过绑定为0来使默认帧缓冲被激活

glBindFramebuffer(GL_FRAMEBUFFER, 0);   // 通过绑定为0来使默认帧缓冲被激活



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

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 screenWidth = 800, screenHeight = 600;

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void Do_Movement();

GLuint loadTexture(GLchar* path, GLboolean bAlpha = GL_FALSE);

Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));

GLfloat lastX = 400, lastY = 300;

bool keys[1024];
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* window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", nullptr, nullptr);
	glfwMakeContextCurrent(window);

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

	// Options
	//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

	glewExperimental = GL_TRUE;
	glewInit();

	glViewport(0, 0, screenWidth, screenHeight);

	glEnable(GL_DEPTH_TEST);		// 开启深度测试
	glDepthFunc(GL_LESS);
	glEnable(GL_STENCIL_TEST);		// 开启模板测试
	glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
	// 先开启模板测试，设置模板、深度测试通过或失败时才采取动作
	// 1 保持现有模板值, 2 若模板测试通过,深度测试失败,保持现有模板值 
	//	3 深度与模板均通过,将模板值用 glStencilFunc函数设置的ref值替换
	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

	// Shader 源码
	Shader shader("./Shader/advanced_vertex", "./Shader/advanced_fragement");
	Shader shaderSingleColor("./Shader/advanced_vertex", "./Shader/single_color_fragement");

	// 立方体数据
	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 planeVertices[] = {
		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 grassVertices[] = {
		0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
		0.0f, -0.5f,  0.0f,  0.0f,  1.0f,
		1.0f, -0.5f,  0.0f,  1.0f,  1.0f,

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

	// 草的位置
	std::vector<glm::vec3> grassPos;
	grassPos.push_back(glm::vec3(-1.5f, 0.0f, -0.48f));
	grassPos.push_back(glm::vec3(1.5f, 0.0f, 0.51f));
	grassPos.push_back(glm::vec3(0.0f, 0.0f, 0.7f));
	grassPos.push_back(glm::vec3(-0.3f, 0.0f, -2.3f));
	grassPos.push_back(glm::vec3(0.5f, 0.0f, -0.6f));

	// 立方体
	GLuint cubeVAO, cubeVBO;
	glGenVertexArrays(1, &cubeVAO);
	glBindVertexArray(cubeVAO);

	glGenBuffers(1, &cubeVBO);
	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 planeVAO, planeVBO;
	glGenVertexArrays(1, &planeVAO);

	glGenBuffers(1, &planeVBO);
	glBindVertexArray(planeVAO);

	glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, 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 grassVAO, grassVBO;
	glGenVertexArrays(1, &grassVAO);
	glBindVertexArray(grassVAO);

	glGenBuffers(1, &grassVBO);
	glBindBuffer(GL_ARRAY_BUFFER, grassVBO);

	glBufferData(GL_ARRAY_BUFFER, sizeof(grassVertices), &grassVertices, 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);


	// 纹理ID
	GLuint cubeTexture = loadTexture("./Img/a.jpg");
	GLuint floorTexture = loadTexture("./Img/b.jpg");
	GLuint grassTexture = loadTexture("./Img/grass.png", GL_TRUE);

	while (!glfwWindowShouldClose(window))
	{
		GLfloat currentFrame = glfwGetTime();
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;

		glfwPollEvents();
		Do_Movement();

		glClearColor(0.1f, 0.1f, 0.41f, 1.0f);		// 偏蓝色背景 当天空
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

		// 视图设置
		glm::mat4 model;
		glm::mat4 view = camera.GetViewMatrix();
		glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth / (float)screenHeight, 0.1f, 100.0f);

		shaderSingleColor.useShaderPrograme();
		glUniformMatrix4fv(glGetUniformLocation(shaderSingleColor.getPrograme(), "view"), 1, GL_FALSE, glm::value_ptr(view));
		glUniformMatrix4fv(glGetUniformLocation(shaderSingleColor.getPrograme(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));

		shader.useShaderPrograme();
		glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "view"), 1, GL_FALSE, glm::value_ptr(view));
		glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));
		
		// 绘制草地  此时模板缓冲区不可写
		glStencilMask(0x00);// 位遮罩	0x00，所有写入深度缓冲最后都是0 // 0x00 == 0b00000000 == 0 //此时，模板值与它进行按位与运算结果是0，模板缓冲不可写
		
		glBindVertexArray(grassVAO);
		glBindTexture(GL_TEXTURE_2D, grassTexture);
		for (GLuint i = 0; i < grassPos.size(); i++)
		{
			model = glm::mat4();
			model = glm::translate(model, grassPos[i]);
			glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"), 1, GL_FALSE, glm::value_ptr(model));
			glDrawArrays(GL_TRIANGLES, 0, 6);
		}
		glBindVertexArray(0);


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

		// 模板缓冲先清空模板缓冲设置所有片段的模板值为0，然后开启矩形片段用1填充
		// 所有片段都要写入模板缓冲    在绘制物体前，把模板方程设置为GL_ALWAYS，用1更新物体将被渲染的片段。
		glStencilFunc(GL_ALWAYS, 1, 0xFF);

		// 模板缓冲区可写
		// 位遮罩	模板值进行按位与(AND)运算决定缓冲是否可写, //此时，模板值与它进行按位与运算结果是模板值，模板缓冲可写	
		glStencilMask(0xFF);

		// 绘制两个立方体 写入模板缓冲 绘制之处，模板缓冲更新为1
		glBindVertexArray(cubeVAO);
		glBindTexture(GL_TEXTURE_2D, cubeTexture);
		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);
		glBindVertexArray(0);

		// == =============
		// 2nd. Render pass, now draw slightly scaled versions of the objects, this time disabling stencil writing.
		// Because stencil buffer is now filled with several 1s. The parts of the buffer that are 1 are now not drawn, thus only drawing 
		// the objects' size differences, making it look like borders.

		glStencilFunc(GL_NOTEQUAL, 1, 0xFF);	// 只绘制前面绘制的箱子外围的那部分
		// 关闭模板写入
		glStencilMask(0x00);
		// 关闭深度测试
		glDisable(GL_DEPTH_TEST);
		shaderSingleColor.useShaderPrograme();
		GLfloat scale = 1.02;	// 放大
		// 渲染物体，更新模板缓冲
		// 使用一个不同的片段着色器用来输出一个纯颜色。
		glBindVertexArray(cubeVAO);
		glBindTexture(GL_TEXTURE_2D, cubeTexture);
		model = glm::mat4();
		model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
		model = glm::scale(model, glm::vec3(scale, scale, scale));
		glUniformMatrix4fv(glGetUniformLocation(shaderSingleColor.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));
		model = glm::scale(model, glm::vec3(scale, scale, scale));
		glUniformMatrix4fv(glGetUniformLocation(shaderSingleColor.getPrograme(), "model"), 1, GL_FALSE, glm::value_ptr(model));
		glDrawArrays(GL_TRIANGLES, 0, 36);
		glBindVertexArray(0);

		// 开启模板写入和深度测试
		glStencilMask(0xFF);
		glEnable(GL_DEPTH_TEST);

		glfwSwapBuffers(window);
	}

	glfwTerminate();
	return 0;
}

void DrawScene()
{

}

// 纹理数据加载
GLuint loadTexture(GLchar* path, GLboolean bAlpha)
{
	GLuint textureID;
	glGenTextures(1, &textureID);
	int width, height;
	unsigned char* image = SOIL_load_image(path, &width, &height, 0, bAlpha?SOIL_LOAD_RGBA:SOIL_LOAD_RGB);

	glBindTexture(GL_TEXTURE_2D, textureID);
	glTexImage2D(GL_TEXTURE_2D, 0, bAlpha?GL_RGBA:GL_RGB, width, height, 0, bAlpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, image);
	glGenerateMipmap(GL_TEXTURE_2D);

	// Parameters
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, bAlpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, bAlpha ? 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(image);
	return textureID;

}

void Do_Movement()
{
	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);
}

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

void main()
{             
    //color = texture(texture1, TexCoords);

	vec4 texColor = texture(texture1, TexCoords);
    if(texColor.a < 0.1)
        discard;
    color = texColor;
}


single_color_fragement

// 边框颜色

#version 330 core

in vec2 TexCoords;
out vec4 color;
uniform sampler2D texture1;

void main()
{
	color = vec4(0.6, 0.18, 0.16, 1.0);
}




源码: VS2015

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

cmake.EXE
关注
专栏目录
/root/anaconda/lib/liblzma.so.5: version `XZ_5.1.2alpha‘ not found required /lib64/librpmio.so解决方案
weixin_43178406的博客
03-14 9万+
本文主要介绍了/root/anaconda3/lib/liblzma.so.5: version `XZ_5.1.2alpha’ not found (required by /lib64/librpmio.so.3)解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Alpha测试、Beta测试和验收测试的含义与区别
tectrol的专栏
03-06 3704
1、Alpha测试 Alpha测试是由用户在开发环境下进行的测试，也可以是开发机构内部的用户在模拟实际操作环境下进行的测试。开发者坐在用户旁边，这是在开发者受控的环境下进行的测试。由开发者随时记录下错误情况和使用中的问题。 2、Beta测试 Beta测试是由软件的多个用户在一个或多个用户的实际使用环境下进行的测试。开发者通常不在测试现场，这是在开发者无法控制的环境下进行的测试。由用户记录下遇到的所有问题，定期向开发者报告。beta测试是一模拟真实的使用环境从而发现缺陷的一种测试...
百人计划 3.1 深度和模板测试
Navigated的博客
09-03 434
深度和模板测试
OpenGL深度测试和模板测试
s1120080286的专栏
09-05 903
1.简介 深度缓冲就像颜色缓冲(Color Buffer)（储存所有的片段颜色：视觉输出）一样，在每个片段中储存了信息，并且（通常）和颜色缓冲有着一样的宽度和高度。 当深度测试(Depth Testing)被启用的时候，OpenGL会将一个片段的的深度值与深度缓冲的内容进行对比。OpenGL会执行一个深度测试，如果这个测试通过了的话，深度缓冲将会更新为新的深度值。如果深度测试失败了，片段将会被...
百人计划（图形）3.1深度和模板测试
qq_63133691的博客
05-23 832
模板测试位于深度测试（Depth Test）之前，透明度测试（Alpha Test）之后。它和深度测试类似，需要一个模板缓冲来存储模板值。通常这个模板值（Stencil Value）是8位的，即每个像素/片段一共能有256种不同的模板值。模板缓冲的初始值会被清除为0。模板缓冲操作允许我们在渲染片段时将模板缓冲设定为一个特定的值（如上图中将部分的值设置为1），这个值的具体意义与程序的具体应用有关。
基于模板测试实现半透明多边形运算
dizuo的专栏
03-28 3114
通过OpenGL的帧缓存实现多边形常见操作：联合、求交、做差。
OpenGL学习笔记十三（模板测试）
绿洲守望者
02-19 1821
OpenGL学习笔记十三（模板测试）需要模板测试的原因模板测试模板缓存模板测试函数glStencilFuncglStencilOp 需要模板测试的原因 在上节中，讲了深度测试，即 判断一个像素点是否能通过深度检测，显示到屏幕上，但是在实际开发中，我们可能遇到很多 需求，希望实现不是通过深度关系进行遮挡的，比如游戏里常见的透视效果，可以看到一个物体之后的东西，这种情况下，我们就不能仅仅使用深度测试...
OGLStencil深度测试 模板测试 以及 Alpha混合_VS2015.rar
12-21
OGLStencil深度测试 模板测试 以及 Alpha混合_VS2015.rar ---------------- OGLStencil深度测试 模板测试 以及 Alpha混合_VS2015.rar --------------------参考: ...
精通Direct3D图形与动画程序设计 08_第八章 深度测试与Alpha混合.rar
10-02
第8章 深度测试与Alpha混合 1、ZTest 演示深度测试的使用。程序运行时按下数字键“1”启用深度测试，按下数字键“0”,则禁用深度测试。 2、AlphaBlend 演示使用Alpha混合实现半透明效果。程序运行时按下数字键“1”,...
图形学进阶——深度与模板测试
whitebreeze的博客
06-26 1576
Z Test & Stencil Test深度测试与模板测试 百人计划学习地址：图形 3.1 深度与模板测试 传送门效果示例 一、模板测试 Stencil Test 流程： 1. 什么是模板测试 ① 从渲染管线出发 像素权限测试——》裁剪测试——》透明度测试——》模板测试——》深度测试——》混合等操作——》输出片元到帧缓冲区 ② 从逻辑上理解 就是通过一定条件判断该片元或者片元属性执行抛弃操作还是保留操作 ③ 从书面概念上理解 2 .模板测试的语法表示 具体含义需补充 referenceV
OSG+NET测试程序
06-11
1 基于OSG 3.4.0， 包含已经编译好的OSG库（Debug和Release） 2 OSG结合.Net，在Winform中集成OSG库
模板测试的细节
MonoBehaviour的博客
08-12 353
1、简介 在Unity中一个像素会有多个缓存信息，模版缓存(其实Stencil不应该被翻译成模版，但网上都这么写)是其中之一。模板缓冲区可以为屏幕上的每个像素点保存一个无符号整数值，通过一些比较来改变当前像素区域模版缓冲的值，从而改变深度关系，似乎UGUI的Mask也是通过其实现的，延迟光照中Stencil有一些限制，具体看unity的文档，这里只介绍正向光照中的使用。 Stencil所在的渲染管线中的顺序位置： Stencil的所有参数如下： Stencil ｛ R...
模板测试练习 选中效果
artisans的专栏
07-06 284
完整程序 https://github.com/WaldenPonder/opengl-test/tree/master/t004#include "stdafx.h" #include "../common/common.out.h"int _tmain(int argc, _TCHAR* argv[]) { GLfloat cubePts[180]; tools::GetCub
OSG 中 相交测试 模块 工作流程及原理
UnrealEngine4 、Delta3D、OSG
07-18 3754
OSG 中 相交测试 模块 的 工作流程及原理 分析
◮OpenGL-模板测试
whl0071的专栏
03-29 130
◮OpenGL-模板测试
OpenGL学习日志之模板测试
qq_36274965的博客
05-04 1114
模板测试根据模板缓冲区中片段的模板值与设置的引用值，进行我们设置的运算式进行比较，如果没有通过测试，则丢弃该片段。OpenGL是通过设置位遮罩来控制写操作的，当我们在准备写入模板值之前，我们会将模板值与这个位遮罩进行与运算，一般我们使用0xFF和0x00就行，如果你有特殊的需求需要控制某一位的写入和其他不一样，你也可以自己设置。由于原本绘制的正方形区域片元模板值都为1，而我们设置的模板值不等于1通过，因此放大的正方形绘制时，只有大于原本大小的正方形的片元片段才能通过模板测试，也就是我们拿来作为描边的部分。
OpenGL MSAA多采样中的蒙版（stencil）使用
Polaris
10-16 771
设置FBO中的蒙版参数，以便进行蒙版相关的操作
模板测试(Stencil Test)的基础知识
木头圈
11-05 7823
本文分享模板测试(Stencil Test)的基础知识 在渲染管线中, 模板测试发生在片元着色器处理和透明度测试之后, 深度测试之前. 模板测试最常见的应用就是各种遮罩, 特别是有形状的遮罩, 如Unity中的Mask组件, 这些遮罩的特点就是可以按照某种形状(可以是非矩形的)来渲染片元. 比如我们在游戏中经常看到的各种形状的头像 ,而Rect Mask 2D组件使用的是裁剪测试(Scissor Test), 可以指定绘制一块矩形区域内的片元. 模板测试的圆形遮罩如图所示. 模板测试基础 和深度测试类
osg 动态剖切
最新发布
xundie11的博客
04-12 961
针对场景中的活动模型进行xyz平面拖拽剪切，在osg的片元着色器中，判断片元位于切割面哪一侧(分为保留一侧、剪切一侧)，把剪切一侧的片元抛弃掉(实际场景中不显示但仍存在)，实现切割。------ 用到osg::ClipPlane；
软件测试方法：Beta与Alpha测试详解
"本文主要介绍了软件测试中的几种关键方法，包括&alpha;测试、β测试、可移植性测试以及用户界面测试，这些方法对于确保软件质量至关重要。" 在软件开发过程中，测试是一个不可或缺的环节，它确保产品在发布之前达到预期...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值