OpenGL —— 2.9、摄像机之模拟CS鼠标视角转动（附源码，glfw+glad）

news2024/11/18 22:32:01
源码效果

 

C++源码

 
     纹理图片
在这里插入图片描述

     
     需下载stb_image.h这个解码图片的库，该库只有一个头文件。

在这里插入图片描述
 
     具体代码：

          vertexShader.glsl

#version 330 core

layout(location = 0) in vec3 aPos;
layout(location = 1) in vec2 aUV;

out vec2 outUV;

uniform mat4 _modelMatrix;
uniform mat4 _viewMatrix;
uniform mat4 _projMatrix;

void main()
{
	gl_Position = _projMatrix* _viewMatrix *  _modelMatrix * vec4(aPos.x, aPos.y, aPos.z, 1.0);

	outUV = aUV;
}

          vertexShader.glsl

#version 330 core

out vec4 FragColor;

in vec2 outUV;

uniform sampler2D ourTexture;

void main()
{
	// 使用图片纹理及色彩混合
	FragColor = texture(ourTexture, outUV);
}

          OpenGLClass.cpp

#include "OpenGLClass.h"

Camera _camera;

void OpenGLClass::bck_GLFWframebuffersizefun(GLFWwindow* window, int width, int height)
{
	// 在窗口中定义一个像素矩形,最终的图形将映射到个矩形中
	glViewport(0, 0, width, height);
}

OpenGLClass::OpenGLClass()
{
	// 初始化glfw上下文
	if (glfwInit() == GLFW_FALSE) { std::cout << "glfwInit fail!\n"; return; }
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);					// 3.3版本
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);	// 使用OpenGL核心模式

	// 创建OpenGL窗体
	GLFWwindow *window = glfwCreateWindow(windowWidth, windowHeight, "OpenGL Core", nullptr, nullptr);
	if (!window) { std::cout << "glfwCreateWindow fail!\n"; return; }

	// 当前OpenGL上下文绑定窗口
	glfwMakeContextCurrent(window);

	// 加载所有OpenGL函数指针
	if (GL_FALSE == gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { std::cout << "gladLoadGLLoader fail!\n"; return; }

	// 在窗口中定义一个像素矩形,最终的图形将映射到个矩形中
	glViewport(0, 0, windowWidth, windowHeight);

	// 窗口大小调整回调
	glfwSetFramebufferSizeCallback(window, OpenGLClass::bck_GLFWframebuffersizefun);

	// 摄像机控制
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);	// 鼠标不可见
	glfwSetCursorPosCallback(window, mouse_callback);				// 鼠标移动回调
	_camera.setSpeed(0.02f);
	_camera.lookAt(glm::vec3(0.0f, 0.0f, 3.0f), glm::vec3(0.0f, 0.0f, -1.0f), glm::vec3(0.0f, 1.0f, 0.0f));

	// 初始化VAO/VBO
	initModel();

	// 初始化纹理
	if (!initTexture()) { std::cout << "initTexture fail!\n"; system("pause"); return; }

	// 初始化shader
	if (!initShader("vertexShader.glsl", "fragmentShader.glsl")) { std::cout << "initShader fail!\n"; system("pause"); return; }

	// 窗口标志是否是关闭
	while (!glfwWindowShouldClose(window))
	{
		// 输入按键处理
		ProcessKeyPInput(window);

#if 0
		// 使用红，绿，蓝以及alpha值来清除颜色缓冲区
		glClearColor(0.328125f, 0.35156f, 0.82421f, 1.0f);

		// 将从窗口中清除最后一次所绘制的图形
		/*
			GL_COLOR_BUFFER_BIT:    当前可写的颜色缓冲
			GL_DEPTH_BUFFER_BIT:    深度缓冲
			GL_ACCUM_BUFFER_BIT:	累积缓冲
　　			GL_STENCIL_BUFFER_BIT:	模板缓冲
		*/
		glClear(GL_COLOR_BUFFER_BIT);
#endif

		FlushRender();

		// 双缓冲,使用OpenGL或OpenGL ES进行渲染
		glfwSwapBuffers(window);

		// glfw事件循环
		glfwPollEvents();

		// 睡眠10ms,防止造成GPU疯狂消耗。实际具体调整
		Sleep(10);
	}

	// 释放窗口
	glfwDestroyWindow(window);

	// 释放资源,终止GLFW库
	glfwTerminate();
}

OpenGLClass::~OpenGLClass()
{
	// 释放
	if (glIsProgram(shaderProgram)) { glDeleteProgram(shaderProgram); }shaderProgram = 0;
	if (glIsBuffer(VAO)) { glDeleteBuffers(1, &VAO); } VAO = 0;
	if (glIsBuffer(VBO)) { glDeleteBuffers(1, &VBO); } VBO = 0;
}

void OpenGLClass::ProcessKeyPInput(GLFWwindow *window)
{
	if (window)
	{
		if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)		// 获取窗口按键是否ESC
		{
			// 设置窗口关闭标志
			glfwSetWindowShouldClose(window, true);
		}



		if (glfwGetKey(window, GLFW_KEY_LEFT_BRACKET) == GLFW_PRESS)
		{
			_camera.setSpeed(_camera.getSpeed() - 0.005);
			std::cout << "已按'[' 减速键：速度-0.005,当前速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_RIGHT_BRACKET) == GLFW_PRESS)
		{
			_camera.setSpeed(_camera.getSpeed() + 0.005);
			std::cout << "已按']' 增速键：速度+0.005,当前速度为:" << _camera.getSpeed() << std::endl;
		}

		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_FRONT);
			std::cout << "已按'w'键：向(前)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_BACK);
			std::cout << "已按's'键：向(后)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_LEFT);
			std::cout << "已按'a'键：向(左)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_RIGHT);
			std::cout << "已按'd'键：向(右)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_UP);
			std::cout << "已按'↑'键：向(上)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_DOWN);
			std::cout << "已按'↓'键：向(上)运动,速度为:" << _camera.getSpeed() << std::endl;
		}
		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
		{
			_camera.move(CAMERA_MOVE::MOVE_InitialPosition);
			std::cout << "********** 已按' ' (空格)恢复初始位置! **********" << std::endl;
		}
	}
	window = nullptr;
}

void OpenGLClass::mouse_callback(GLFWwindow *window, double xpos, double ypos)
{
	_camera.onMouseMove(xpos, ypos);
}

void OpenGLClass::setMatrix(const std::string &_name, glm::mat4 _matrix) const
{
	// 获得指定shader程序中uniform变量的位置
	int shaderNameId = glGetUniformLocation(shaderProgram, _name.c_str());


	/*
	将4x4的矩阵数据传递给着色器
		location：指定要更改的uniform变量的位置。
		count：指定要更改的矩阵的数量。如果只更改一个矩阵，该值为1。
		transpose：指定是否需要将矩阵进行转置。一般情况下，设为GL_FALSE即可。
		value：指向包含矩阵数据的指针。
	*/
	glUniformMatrix4fv
	(
		shaderNameId,
		1,
		GL_FALSE,
		glm::value_ptr(_matrix)
	);
}

void OpenGLClass::FlushRender()
{
	// 判断VAO是否被删除
	if (glIsVertexArray(VAO))
	{
		// 使用红，绿，蓝以及alpha值来清除颜色缓冲区
		glClearColor(0.328125f, 0.35156f, 0.82421f, 1.0f);
		// 将从窗口中清除最后一次所绘制的图形,GL_DEPTH_BUFFER_BIT将深度信息也清除
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		// 开启深度检测
		glEnable(GL_DEPTH_TEST);

		///		// 模型平移数据
		glm::vec3 modelVecs[] =
		{
			glm::vec3(0.0f,0.0f,0.0f),
			glm::vec3(2.0f, 5.0f, -15.0f),
			glm::vec3(-1.5f, -2.2f, -2.5f),
			glm::vec3(-3.8f, -2.0f, -12.3f),
			glm::vec3(2.4f, -0.4f, -3.5f),
			glm::vec3(-1.7f, 3.0f, -7.5f),
			glm::vec3(1.3f, -2.0f, -2.5f),
			glm::vec3(1.5f, 2.0f, -2.5f),
			glm::vec3(1.5f, 0.2f, -1.5f),
			glm::vec3(-1.3f, 1.0f, -1.5f)
		};
		///

		///
		// 观察者/摄像机矩阵
#if 0
		glm::mat4 _viewMatrix = glm::lookAt
		(
			glm::vec3(0.0f, 0.0f, 2.4f),	// 摄像机位置
			glm::vec3(0.0f, 0.0f, 0.0f),	// 摄像机看向的位置
			glm::vec3(0.0f, 1.0f, 0.0f)		// 摄像机顶部的位置
		);
#else
		_camera.update();
#endif

		// 投影矩阵
		glm::mat4 _projMatrix = glm::perspective
		(
			glm::radians(45.0f),
			(float)windowWidth / (float)(windowHeight),
			0.1f, 100.0f
		);
		///

#if 0
		// 使用程序
		glUseProgram(shaderProgram);

		///
		setMatrix("_viewMatrix", _viewMatrix);
		setMatrix("_projMatrix", _projMatrix);
		///

		// 绑定纹理
		glBindTexture(GL_TEXTURE_2D, _texture);

		// 绑定VAO
		glBindVertexArray(VAO);

		// 绘制三角形
		glDrawArrays(GL_TRIANGLES, 0, 36);

		// 关闭使用程序
		glUseProgram(0);
#else
		// 使用程序
		glUseProgram(shaderProgram);

		// 绘制10个立方体
		for (unsigned short index = 0; index < 10; ++index)
		{
			glm::mat4 _modelMatrix(1.0f);
			_modelMatrix = glm::translate(_modelMatrix, modelVecs[index]);
			_modelMatrix = glm::rotate(_modelMatrix, glm::radians((float)glfwGetTime()*(index + 1) * 10), glm::vec3(0.5f, 1.0f, 0.0f));

			///
			setMatrix("_modelMatrix", _modelMatrix);
			setMatrix("_viewMatrix", _camera.getMatrix());
			setMatrix("_projMatrix", _projMatrix);
			///

			// 绑定纹理
			glBindTexture(GL_TEXTURE_2D, _texture);

			// 绑定VAO
			glBindVertexArray(VAO);

			// 绘制矩形
			glDrawArrays(GL_TRIANGLES, 0, 36);
		}

		// 关闭使用程序
		glUseProgram(0);
#endif
	}
}

bool OpenGLClass::initTexture()
{
	// 读取图片相关信息
	ffImage *pImage = ffImage::readFromFile("./rec/wall.jpeg");
	if (!pImage) { return false; }

	// 生成纹理
	glGenTextures(1, &_texture);

	// 以2D方式绑定纹理
	// 将当前绑定的纹理对象替换为参数中指定的纹理对象
	glBindTexture(GL_TEXTURE_2D, _texture);

	// 设置纹理属性
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// 读取图片数据,完成数据绑定
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pImage->getWidth(), pImage->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, pImage->getData());

	if (pImage) { delete pImage; }pImage = nullptr;
	return true;
}

void OpenGLClass::initModel()
{
	// 坐标、纹理位置
	float vertices[]
	{
		-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
	};

	/****************************************************/	// VAO
	// 创建VAO
	glGenVertexArrays(1, &VAO);

	// 绑定指定的顶点数组对象（Vertex Array Object, VAO）
	glBindVertexArray(VAO);
	/****************************************************/


	/****************************************************/	// VBO
	// 生成缓冲区对象
	glGenBuffers(1, &VBO);

	// 绑定命名缓冲区对象
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	// 缓冲对象（VBO，IBO 等）分配空间并存储数据
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	/*
		指定顶点属性在顶点缓冲对象中的布局，并将其与顶点着色器中的顶点属性进行关联
			参数1:第n个layout (对应glsl中顶点着色器的layout)
			参数2:顶点属性的组成元素的数量,例如3表示顶点属性是由3个浮点数组成
			参数3:顶点属性的数据类型
			参数4:是否将非浮点型的数据归一化到[-1, 1]或[0, 1]范围内
			参数5:相邻两个顶点属性之间的字节数,通常为0或属性类型大小乘以数量
			参数6:顶点属性在顶点缓冲对象中的偏移量或者数据的首地址
	*/
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(sizeof(float) * 3));

	// 激活锚点(参数:第n个layout)
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);

	// 解绑VAO/VBO
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	/****************************************************/
}

std::string OpenGLClass::ReadGlslContext(const char *sPath)
{
	std::string strContext;
	if (!sPath) { return strContext; }

	std::ifstream sFile;
	sFile.open(sPath);
	if (sFile.is_open())
	{
		std::stringstream sStream;
		sStream << sFile.rdbuf();
		strContext = sStream.str();
	}
	return strContext;
}

bool OpenGLClass::initShader(const char *_vertexPath, const char *_fragPath)
{
	char infoLog[512] = { 0 };
	int successFlag = 0;

	/*********************************************************/	// vertex编译
	std::string vertexContext = ReadGlslContext(_vertexPath); if (vertexContext.empty()) { return false; }
	const char *cVertexContext = vertexContext.c_str();

	// 创建顶点着色器对象
	unsigned int iVertexID = glCreateShader(GL_VERTEX_SHADER);

	// 为顶点着色器指定源码(参数2:传过去几个)
	glShaderSource(iVertexID, 1, &cVertexContext, nullptr);

	// 编译顶点着色器源码
	glCompileShader(iVertexID);

	// 查看编译顶点着色器源码结果
	glGetShaderiv(iVertexID, GL_COMPILE_STATUS, &successFlag);
	if (!successFlag)	// 编译失败
	{
		// 获取编译失败原因
		glGetShaderInfoLog(iVertexID, 512, nullptr, infoLog);
		std::cout << "glGetShaderiv GL_VERTEX_SHADER" << iVertexID << " fail:" << infoLog << std::endl; return false;
	}
	cVertexContext = nullptr;
	/*********************************************************/


	/*********************************************************/	// fragment编译
	std::string fragmentContext = ReadGlslContext(_fragPath); if (fragmentContext.empty()) { return false; }
	const char *cFragmentContext = fragmentContext.c_str();

	// 创建片段着色器对象
	unsigned int iFragmentID = glCreateShader(GL_FRAGMENT_SHADER);

	// 为片段着色器指定源码(参数2:传过去几个)
	glShaderSource(iFragmentID, 1, &cFragmentContext, nullptr);

	// 编译片段着色器源码
	glCompileShader(iFragmentID);

	// 查看编译片段着色器源码结果
	glGetShaderiv(iFragmentID, GL_COMPILE_STATUS, &successFlag);
	if (!successFlag)	// 编译失败
	{
		// 获取编译失败原因
		glGetShaderInfoLog(iFragmentID, 512, nullptr, infoLog);
		std::cout << "glGetShaderiv GL_FRAGMENT_SHADER" << iFragmentID << " fail:" << infoLog << std::endl; return false;
	}
	cFragmentContext = nullptr;
	/*********************************************************/


	/*********************************************************/	// 链接
	// 创建一个空的程序对象
	shaderProgram = glCreateProgram();
	if (shaderProgram == 0) { std::cout << "glCreateProgram fail!\n"; return false; }

	// 将着色器对象附加到程序对象上（注:glDetachShader为移除程序对象中的指定着色器对象）
	glAttachShader(shaderProgram, iVertexID);
	glAttachShader(shaderProgram, iFragmentID);

	// 进行链接程序对象
	glLinkProgram(shaderProgram);

	// 查看链接状态
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &successFlag);
	if (!successFlag)	// 链接失败
	{
		// 获取链接失败原因
		glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
		std::cout << "glGetProgramiv " << shaderProgram << " fail:" << infoLog << std::endl; return false;
	}
	/*********************************************************/


	/* 在链接完成后,将编译shader相关删除。仅留下链接ID */
	if (glIsShader(iVertexID)) { glDeleteShader(iVertexID); }
	if (glIsShader(iFragmentID)) { glDeleteShader(iFragmentID); }
	return true;
}

          OpenGLClass.h

#pragma once

#include "Global.h"
#include "ffImage.h"
#include "Camera.h"

class OpenGLClass
{
public:
	OpenGLClass();
	~OpenGLClass();

protected:
	// 初始化纹理
	bool initTexture();

	// 初始化模型VAO/VBO
	void initModel();

	// 初始化shader文件
	bool initShader(const char *_vertexPath, const char *_fragPath);

	// 读取glsl文件内容
	std::string ReadGlslContext(const char *sPath);

	// 刷新Render
	void FlushRender();

	// 回调 - 窗口尺寸变化回调
	static void bck_GLFWframebuffersizefun(GLFWwindow* window, int width, int height);

	// 处理按键输入
	void ProcessKeyPInput(GLFWwindow *window);

	// 设置矩阵
	void setMatrix(const std::string &_name, glm::mat4 _matrix)const;

	// 回调 - 摄像机旋转
	static void mouse_callback(GLFWwindow *window, double xpos, double ypos);

private:
	unsigned short windowWidth = 800, windowHeight = 600;

	unsigned int shaderProgram = 0;		// 链接程序对象
	unsigned int VBO = 0, VAO = 0, _texture = 0;
};

          Camera.cpp

#include "Camera.h"

Camera::Camera()
{
}

Camera::~Camera()
{
}

void Camera::setSpeed(float _spped)
{
	if (_spped > 0 && _spped < 0.5)
	{
		m_speed = _spped;
	}
}

float Camera::getSpeed()
{
	return m_speed;
}

void Camera::lookAt(glm::vec3 _pos, glm::vec3 _front, glm::vec3 _up)
{
	InitialPosition = _pos;

	m_position = _pos;
	m_front = glm::normalize(_front);
	m_up = _up;

	m_vMatrix = glm::lookAt(m_position, m_position + m_front, m_up);
}

void Camera::update()
{
	m_vMatrix = glm::lookAt(m_position, m_position + m_front, m_up);
}

glm::mat4 Camera::getMatrix()
{
	return m_vMatrix;
}

void Camera::move(CAMERA_MOVE _mode)
{
	switch (_mode)
	{
	case CAMERA_MOVE::MOVE_LEFT:
		m_position -= glm::normalize(glm::cross(m_front, m_up)) * m_speed;
		break;
	case CAMERA_MOVE::MOVE_RIGHT:
		m_position += glm::normalize(glm::cross(m_front, m_up)) * m_speed;
		break;
	case CAMERA_MOVE::MOVE_FRONT:
		m_position += m_speed * m_front;
		break;
	case CAMERA_MOVE::MOVE_BACK:
		m_position -= m_speed * m_front;
		break;
	case CAMERA_MOVE::MOVE_UP:
		m_position += glm::normalize(glm::cross(glm::vec3(1.0f, 0.0f, 0.0f), m_front))*m_speed;
		break;
	case CAMERA_MOVE::MOVE_DOWN:
		m_position -= glm::normalize(glm::cross(glm::vec3(1.0f, 0.0f, 0.0f), m_front))*m_speed;
		break;
	case CAMERA_MOVE::MOVE_InitialPosition:
		m_position = InitialPosition;
		break;
	default:
		break;
	}
}

void Camera::pitch(float _yOffset)
{
	m_pitch += _yOffset * m_sensitivity;
	
	// 约定俗成,俯仰角度必须在范围内
	m_pitch = m_pitch > 89.0f ? 89.0f : m_pitch;
	m_pitch = m_pitch < -89.0f ? -89.0f : m_pitch;

	m_front.y = sin(glm::radians(m_pitch));
	m_front.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
	m_front.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
	m_front = glm::normalize(m_front);

	update();
}

void Camera::yaw(float _xOffset)
{
	m_yaw += _xOffset * m_sensitivity;

	m_front.y = sin(glm::radians(m_pitch));
	m_front.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
	m_front.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
	m_front = glm::normalize(m_front);

	update();
}

void Camera::setSentitivity(float _m_sensitivity)
{
	m_sensitivity = _m_sensitivity;
}

void Camera::onMouseMove(double _xpos, double _ypos)
{
	if (m_firstMove)
	{
		m_xpos = _xpos;
		m_ypos = _ypos;
		m_firstMove = false;
		return;
	}

	float _xOffset = _xpos - m_xpos;
	float _yOffset = -(_ypos - m_ypos);
	pitch(_yOffset);
	yaw(_xOffset);
	m_xpos = _xpos;
	m_ypos = _ypos;
}

          Camera.h

#pragma once

#include "Global.h"

enum class CAMERA_MOVE
{
	MOVE_LEFT,
	MOVE_RIGHT,
	MOVE_FRONT,
	MOVE_BACK,
	MOVE_UP,
	MOVE_DOWN,
	MOVE_InitialPosition
};

class Camera
{
public:
	Camera();
	~Camera();

	void setSpeed(float);
	float getSpeed();

	void lookAt(glm::vec3 _pos, glm::vec3 _front, glm::vec3 _up);
	void update();

	glm::mat4 getMatrix();

	// 摄像机平移
	void move(CAMERA_MOVE);

	// 摄像机旋转相关
	void pitch(float);
	void yaw(float);
	void setSentitivity(float);
	void onMouseMove(double _xpos, double _ypos);

private:
	glm::vec3 m_position = glm::vec3(1.0f), InitialPosition = glm::vec3(1.0f);
	glm::vec3 m_front = glm::vec3(1.0f);
	glm::vec3 m_up = glm::vec3(1.0f);
	float m_speed = 0.01f;

	// 旋转模型,达到俯仰效果
	float m_pitch = 0.0;
	float m_yaw = -90;					// 由于初始时看向了z的负方向
	float m_sensitivity = 0.05f;			// 鼠标位移变化值
	float m_xpos = 0.0f, m_ypos = 0.0f;	// 鼠标上一次位置
	bool m_firstMove = true;

	glm::mat4 m_vMatrix = glm::mat4(1.0f);
};

 

完整源码下载

      源码下载

 

关注

Wx GZH：码农总动员

笔者 - jxd

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1124767.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

臻献光芒女性，延续「美」的力量

臻献光芒女性，延续「美」的力量

随着现代女性力量的觉醒和刻板印象的打破&#xff0c;我们看到了越来越多的社会角色由女性扮演&#xff0c;女性力量不但在于不被定义的人生和对于自我的肯定&#xff0c;也有对美的选择。面对紧凑的生活节奏&#xff0c;现代女性也要应对越来越多的各种压力&#xff0c;珮肌就…
阅读更多...
【C语言易错点】循环结构

【C语言易错点】循环结构

文章目录 &#x1f354;什么是循环结构&#x1f38d;易错点⭐概述✨具体实例 &#x1f354;什么是循环结构 C语言的循环结构是一种控制结构&#xff0c;用于重复执行一段代码&#xff0c;直到满足某个条件为止。C语言提供了三种主要的循环结构&#xff1a;for循环、while循环和…
阅读更多...
谷歌真的不喜欢 Node.js ?

谷歌真的不喜欢 Node.js ?

有人在 Quora 上提问&#xff0c;为什么谷歌不喜欢 Node.js 呢&#xff0c;Google 的 UX 工程师和来自 Node.js 团队的开发者分别回答了他们对这个问题的看法&#xff0c;对于编程语言来说&#xff0c;每一门语言都有它自己的优势&#xff0c;重要的是如何用它去解决问题。 谷…
阅读更多...
目标检测算法改进系列之嵌入动态蛇形卷积模块DySnakeConv

目标检测算法改进系列之嵌入动态蛇形卷积模块DySnakeConv

动态蛇形卷积模块DySnakeConv 血管、道路等拓扑管状结构的精确分割在各个领域都至关重要&#xff0c;确保下游任务的准确性和效率。 然而&#xff0c;许多因素使任务变得复杂&#xff0c;包括薄的局部结构和可变的全局形态。在这项工作中&#xff0c;我们注意到管状结构的特殊…
阅读更多...
【万字长文】向 AI 提问的艺术

【万字长文】向 AI 提问的艺术

向 AI 提问的艺术 本文是我在学习 Prompt Engineering 过程中&#xff0c;总结出来的一些经验和方法。里边包含一些自己的心得和验证有效的技巧。这些技巧在很多其他文章中也有介绍&#xff0c;这里可以当作是一个集大成的汇总。 我会按照“道——法——术”三个层面来介绍向 …
阅读更多...
微信公众号自动回复消息中添加网页链接和小程序链接

微信公众号自动回复消息中添加网页链接和小程序链接

微信公众号自动回复消息中添加网页链接和小程序链接 1.添加网页链接2.添加小程序链接3.配置案例4.效果展示5.其他说明6.总结 1.添加网页链接 <a href"https://sejoos.com">SEJOOS</a>2.添加小程序链接 <a href"https://sejoos.com" data-…
阅读更多...
云安全—docker原理

云安全—docker原理

0x00 前言 因为要学习docker相关的检测技术&#xff0c;所以需要对docker的原理进行基本的原因&#xff0c;不求彻底弄懂&#xff0c;但求懂点皮毛&#xff0c;如有不妥之处&#xff0c;还请斧正。 0x01 docker概述 docker起源 docker公司是在旧金山&#xff0c;由法裔美籍…
阅读更多...
凡哥说机丨双十一网络电视盒子哪个品牌好？目前最强电视盒子

凡哥说机丨双十一网络电视盒子哪个品牌好？目前最强电视盒子

跟平时相比&#xff0c;双十一的价格更低&#xff0c;近来我的后台也收到了超级多的私信咨询电视盒子的问题&#xff0c;凡哥这期将盘点的是目前最强的电视盒子&#xff0c;双十一想买电视盒子不知道网络电视盒子哪个品牌好&#xff0c;那一定不能错过这篇文章了。 推荐一&…
阅读更多...
本地FTP YUM源报错处理

本地FTP YUM源报错处理

一、问题描述 某次OS升级到Anolis 8.6后&#xff0c;但是还需要centos 6.5的yum源&#xff0c;恢复回去后&#xff0c;yum更新&#xff0c;报如下错误&#xff1a; Errors during downloading metadata for repository ‘base’: Curl error (8): Weird server reply for ftp…
阅读更多...
基于springboot小区团购管理系统

基于springboot小区团购管理系统

基于springboot小区团购管理系统的设计与实现 摘要 小区团购管理系统是一款基于Spring Boot框架的Web应用&#xff0c;为小区居民提供了一个方便的平台&#xff0c;以协调和管理各种团购活动。该系统的主要目标是促进小区居民之间的互助合作&#xff0c;通过集中采购来降低商品…
阅读更多...
c进阶测试题

c进阶测试题

选择题 1.请问该程序的输出是多少&#xff08;C&#xff09; #include<stdio.h> int main(){unsigned char i 7;int j 0;for(;i > 0;i - 3){ j;} printf("%d\n", j);return 0; }A. 2 B. 死循环 C. 173 D. 172 首先unsigned char型是不会为负数&#xff…
阅读更多...
分享一个逻辑题_一眼望去无法下手

分享一个逻辑题_一眼望去无法下手

1. 这道题的答案是 A.A B.B C.C D.D 2. 第 5 题的答案是 A.C B.D C.A D.B 3. 以下选项中哪一题的答案与其他三项不同 A. 第 3 题 B. 第 6 题 C. 第 2 题 D. 第 4 题 4. 以下选项中哪两题的答案相同 A. 第 1&#xff0c;5 题 B. 第 2&#xff0c;7 题 C. 第 1&#xff0c…
阅读更多...
基于springboot实现基于Java的超市进销存系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现基于Java的超市进销存系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现基于Java的超市进销存系统演示 摘要 随着信息化时代的到来&#xff0c;管理系统都趋向于智能化、系统化&#xff0c;超市进销存系统也不例外&#xff0c;但目前国内仍都使用人工管理&#xff0c;市场规模越来越大&#xff0c;同时信息量也越来越庞大&#x…
阅读更多...
Visa股票仍然值得投资

Visa股票仍然值得投资

来源&#xff1a;猛兽财经 作者&#xff1a;猛兽财经 总结&#xff1a; &#xff08;1&#xff09;尽管Visa(V)的估值高于市场平均水平&#xff0c;但仍值得买入。 &#xff08;2&#xff09;Visa拥有强劲的基本面&#xff0c;销售额和每股收益一直在稳定增长&#xff0c;股息…
阅读更多...
践行国策，男性生育力保护与修复新启航

践行国策，男性生育力保护与修复新启航

金秋送爽&#xff0c;丹桂飘香&#xff01;值2023年男性健康日即将到来之时&#xff0c;10月22日&#xff0c;由中国优生优育协会生育力保护与修复专业委员会、南京大学医学院附属鼓楼医院联合举办的“首届男性生育力保护与修复诊疗技术培训班”暨“中国优生优育男性生育力保护…
阅读更多...
一分钟带你了解什么是0day攻击什么是Nday攻击

一分钟带你了解什么是0day攻击什么是Nday攻击

1. 什么是零日漏洞 零日攻击是指利用零日漏洞对系统或软件应用发动的网络攻击。 零日漏洞也称零时差漏洞&#xff0c;通常是指还没有补丁的安全漏洞。由于零日漏洞的严重级别通常较高&#xff0c;所以零日攻击往往也具有很大的破坏性。目前&#xff0c;任何安全产品或解决方案…
阅读更多...
工业交换机的三个重要指标，你知道吗？

工业交换机的三个重要指标，你知道吗？

网管型交换机产品提供了多种网络管理方式&#xff0c;包括终端控制口&#xff08;Console&#xff09;、Web页面以及支持Telnet远程登录网络。所以&#xff0c;网络管理员能够通过本地或远程方式实时监控该交换机的工作状态和网络运行状况&#xff0c;并全面管理所有交换端口的…
阅读更多...
springcloud笔记 (8) -网关 Gateway

springcloud笔记 (8) -网关 Gateway

网关 出国需要过海关 网关&#xff1a;网络的关卡 网关的作用 1&#xff1a;路由转发 2&#xff1a;安全控制 保护每个服务&#xff0c;不需要将每个暴露出去 3&#xff1a;负载均衡 1.没有网关&#xff1a;客户端直接访问我们的微服务&#xff0c;会需要在客户端配置很多…
阅读更多...
Mysql第三篇---响应太慢？数据库卡顿？如何优化？

Mysql第三篇---响应太慢？数据库卡顿？如何优化？

Mysql第三篇—响应太慢&#xff1f;数据库卡顿&#xff1f;如何优化&#xff1f; 统计SQL的查询成本&#xff1a;last_query_cost 一条SQL查询语句在执行前需要确定查询执行计划&#xff0c;如果存在多种执行计划的话&#xff0c;MySQL会计算每个执行计划所需要的成本&#x…
阅读更多...
联盟认证 | 聚铭网络正式成为中国反网络病毒联盟成员

联盟认证 | 聚铭网络正式成为中国反网络病毒联盟成员

近日&#xff0c;聚铭网络凭借强劲的技术实力和产品优势&#xff0c;被认证为中国反网络病毒联盟&#xff08;以下简称“ANVA联盟”&#xff09;成员单位。作为国内领先的安全运营商&#xff0c;聚铭网络一直致力于网络安全智能分析和检测&#xff0c;提供全面的信息安全防护&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023