OPENGL添加摄像机功能练习

最新推荐文章于 2023-05-01 18:09:49 发布
最新推荐文章于 2023-05-01 18:09:49 发布
阅读量712 收藏
点赞数
分类专栏： OPENGL/CPP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szqsdq/article/details/79584409
版权 
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

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


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


const unsigned int SRC_WIDTH = 800;
const unsigned int SRC_HEIGHT = 600;

glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
glm::vec3 cameraFront = glm::vec3(0.0f,0.0f,-1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);

bool firstMouse = true;
float yaw = -90.0f;
float pitch = 0.0f;
float lastX = 800.0f / 2.0f;
float lastY = 600.0f / 2.0f;



void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void processInput(GLFWwindow *window);


const char* vertexShaderSource = "#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
"layout(location = 1) in vec2 aVtexCord;\n"
"out vec2 VtexCord;\n"
"uniform mat4 model;\n"
"uniform mat4 view;\n"
"uniform mat4 projection;\n"
"void main(){\n"
"gl_Position = projection * view * model * vec4(aPos,1.0);\n"
"VtexCord = vec2(aVtexCord.x , aVtexCord.y);\n"
"}\n"
;


const char* fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"in vec2 VtexCord;\n"
"uniform sampler2D texture1;\n"
"uniform sampler2D texture2;\n"
"void main(){\n"
"FragColor = mix( texture( texture1,VtexCord ), texture( texture2,VtexCord ), 0.5);\n"
"}\n";


int main()
{

	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
#endif

	GLFWwindow* window = glfwCreateWindow(SRC_WIDTH, SRC_HEIGHT, "Zhongqi", NULL, NULL);
	if (window == NULL)
	{
		std::cout << "Cannot Create Window\n" << std::endl;
		glfwTerminate();
		return -1;
	}

	glfwMakeContextCurrent(window);
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
	glfwSetCursorPosCallback(window, mouse_callback);
	// tell GLFW to capture our mouse
    //glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);


	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		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 << 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 << infoLog << std::endl;
	}

	//创建连接器程序
	int shaderPrograme = glCreateProgram();
	glAttachShader(shaderPrograme, vertexShader);
	glAttachShader(shaderPrograme, fragmentShader);
	glLinkProgram(shaderPrograme);
	glGetProgramiv(shaderPrograme, GL_LINK_STATUS, &success);
	if (!success)
	{
		glGetProgramInfoLog(shaderPrograme, 512, NULL, infoLog);
		std::cout << infoLog << std::endl;
	}

	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	//创建顶点
	float firstTrangles[] = {

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

	 glm::vec3 cubePositions[] = {
		 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)
	 };


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

	 glBindVertexArray(VAO);
	 glBindBuffer(GL_ARRAY_BUFFER, VBO);
	 glBufferData(GL_ARRAY_BUFFER, sizeof(firstTrangles), firstTrangles, GL_STATIC_DRAW);
	 glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(0));
	 glEnableVertexAttribArray(0);
	 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
	 glEnableVertexAttribArray(1);
	 

	 //绘制纹理
	 unsigned int texture1, texture2;
	 glGenTextures(1, &texture1);

	 glBindTexture(GL_TEXTURE_2D, texture1);
	 //设置环绕模式
	 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_MAG_FILTER, GL_LINEAR);
	 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	 //加载图片
	 int pic_width, pic_height, pic_channels;
	 stbi_set_flip_vertically_on_load(true);
	 unsigned char* data = stbi_load("container.jpg", &pic_width, &pic_height, &pic_channels, 0);
	 if (data)
	 {
		 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, pic_width, pic_height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		 glGenerateMipmap(GL_TEXTURE_2D);
	 }
	 else {
		 std::cout << "load image failed\n" << std::endl;
	 }
	 stbi_image_free(data);

	 glGenTextures(1, &texture2);
	 glBindTexture(GL_TEXTURE_2D, texture2);
	 //设置环绕模式
	 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_MAG_FILTER, GL_LINEAR);
	 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	 //加载图片
	 data = stbi_load("awesomeface.png", &pic_width, &pic_height, &pic_channels, 0);
	 if (data)
	 {
		 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, pic_width, pic_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
		 glGenerateMipmap(GL_TEXTURE_2D);
	 }
	 else {
		 std::cout << "load image failed\n" << std::endl;
	 }
	 stbi_image_free(data);

	 //绑定纹理单元
	 glUseProgram(shaderPrograme);
	 GLint firstTexPos = glGetUniformLocation(shaderPrograme, "texture1");
	 GLint secondTexPos = glGetUniformLocation(shaderPrograme, "texture2");
	 glUniform1i(firstTexPos, 0);
	 glUniform1i(secondTexPos,1);

	 //深度测试
	 glEnable(GL_DEPTH_TEST);

	 //渲染
	 while (!glfwWindowShouldClose(window))
	 {

		 processInput(window);
		 glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // also clear the depth buffer now!

															 //激活纹理单元
		 glActiveTexture(GL_TEXTURE0);
		 glBindTexture(GL_TEXTURE_2D, texture1);
		 glActiveTexture(GL_TEXTURE1);
		 glBindTexture(GL_TEXTURE_2D, texture2);

		 //创建模型矩阵--》世界坐标
		 glm::mat4 model;
		 //视野矩阵--》观察坐标
		 glm::mat4 view;
		 //透视投影矩阵
		 glm::mat4 projection;

		 //透视投影
		 projection = glm::perspective(glm::radians(45.0f), (float)SRC_WIDTH / (float)SRC_HEIGHT, 0.1f, 200.0f);

		 view = glm::lookAt(cameraPos, cameraFront + cameraPos, cameraUp);

		 glUseProgram(shaderPrograme);

		 GLint viewPosition = glGetUniformLocation(shaderPrograme, "view");
		 GLint projectionPosition = glGetUniformLocation(shaderPrograme, "projection");
		 glUniformMatrix4fv(viewPosition, 1, GL_FALSE, glm::value_ptr(view));
		 glUniformMatrix4fv(projectionPosition, 1, GL_FALSE, glm::value_ptr(projection));


		 for (int i = 0; i < 10; i++)
		 {
			 model = glm::translate(model, cubePositions[i]);
			 float angle = 20.0f * i;
			 model = glm::rotate(model, glm::radians(angle), glm::vec3(0.5f, 1.0f, 0.0f));
			 GLint modelPosition = glGetUniformLocation(shaderPrograme, "model");
			 glUniformMatrix4fv(modelPosition, 1, GL_FALSE, glm::value_ptr(model));
			 glBindVertexArray(VAO);
			 //使用EBO的时候用glDrawElements
			 //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
			 glDrawArrays(GL_TRIANGLES, 0, 36);

		 }

		 glfwSwapBuffers(window);
		 glfwPollEvents();

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

	 glfwTerminate();
	 return 0;

}

//鼠标滑动的时候X轴模仿yaw Y轴模仿pitch 获得front向量的三个方向
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	if (firstMouse)
	{
		lastX = (float)xpos;
		lastY = (float)ypos;
		firstMouse = false;
	}

	float xoff = (float)xpos - lastX;
	float yoff = (float)ypos - lastY;
	lastX = (float)xpos;
	lastY = (float)ypos;

	float sensitive = 0.1f;
	xoff *= sensitive;
	yoff *= sensitive;

	yaw += xoff;
	pitch += yoff;
	if (pitch > 89.0f)
	{
		pitch = 89.0f;
	}
	else if (pitch < -89.0f)
	{
		pitch = -89.0f;
	}

	glm::vec3 front;
	front.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
	front.y = sin(glm::radians(pitch));
	front.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
	cameraFront = glm::normalize(front);
}

void processInput(GLFWwindow *window)
{
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
				glfwSetWindowShouldClose(window, true);
}

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	glViewport(0, 0, width, height);
}


效果图



谢谢https://learnopengl-cn.github.io/02%20Lighting/01%20Colors/网站提供的资料

2359_God
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL 摄像机(Camera)类的创建
zbx727259615的博客
05-15 1231
OpenGL 摄像机类的创建 基础知识储备（参考详细描述） 欧拉角 2.三维坐标系中的Pitch和Yaw 代码 头文件Camera.h #pragma once #include <glm.hpp> #include <gtc/matrix_transform.hpp> class Camera { public: //构造函数 Camera(glm::vec3 position, float pitch, float row, glm::vec3 worldup);
Qt+OpenGL摄像机，移动，放大缩小
最新发布
06-09
Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt...
linux下使用opengL Glad + EGL问题记录
qq_19804393的博客
03-07 1799
使用glad和EGL过程中的一些问题
OPENGL中GLAD的代码实现过程
huzhifei的专栏
02-04 1225
下面的这行代码就是加载所有的OpenGL功能函数，这个任务由glad来负责完成： if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { std::cout << "Failed to initialize GLAD" << std::endl; return -1; } 一、先看下GLAD是怎么样和Opengl32.dll建立联系的 1.glfwGetProcAd...
LearnOpenGL笔记（一）入门
weixin_44683202的博客
05-01 661
learnopengl的入门简介。包括创建窗口，绘制三角形，实现FPS摄像机，纹理，着色器
opengl.rar_opengl 漫游_摄像机
09-14
在"opengl.rar_opengl 漫游_摄像机"这个资源中，重点是探讨如何在OpenGL环境下实现摄像机的漫游功能，这对于创建交互式虚拟环境或者游戏场景至关重要。在C++和Visual C++ 6.0环境下，程序员可以利用OpenGL库来构建...
OpenGL摄像机操作精讲
06-09
1.摄像机的原理2.观察矩阵和摄像机的关系3.第一人称摄像机4.第三人称摄像机5.Camera场景的操作6.Camera场景的平移7.摄像机场景的旋转(以据鼠标点击点为中心)8.摄像机场景的缩放(以据鼠标点击点为中心)9.摄像机场景的...
openGL学习摄像机自由移动demo
03-15
一个关于opengl摄像机移动的demo.......................................
OpenGL旋转摄像机方向
01-14
在这个场景中，我们关注的是如何在OpenGL环境中使用VS2015（Visual Studio 2015）实现摄像机的旋转，使得用户可以通过键盘上的WASD键来改变摄像机在3D空间中的视角。 首先，`camera.cpp`是关键文件，它包含了对摄像...
stb_image.h
03-30
适用于opengl的单头文件图像加载库，使用于绝大部分格式，且方便易使用
opengl 教程(14) 摄像机控制(1)
weixin_34281537的博客
01-15 262
原帖地址：http://ogldev.atspace.co.uk/www/tutorial14/tutorial14.html       前面一篇教程中，我们把摄像机放在三维空间的固定位置，本章我们尝试控制摄像机，在三维空间任意方向移动它。我们用键盘来控制摄像机的位置，用鼠标来改变摄像机lookat的方向，这个有点类似第一人称射击游戏中的摄像机控制。本章先来学习一下用键盘控制摄像机位置，下章来...
OpenGL(九) 摄像机
无提丶的博客
09-11 1036
摄像机 前面的教程中我们讨论了观察矩阵以及如何使用观察矩阵移动场景（我们向后移动了一点）。OpenGL本身没有摄像机(Camera)的概念，但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机，产生一种我们在移动的感觉，而不是场景在移动。 摄像机/观察空间 当我们讨论摄像机/观察空间(Camera/View Space)的时候，是在讨论以摄像机的视角作为场景原点时场景中所有的顶点坐标...
C++ opengl 放置摄像机
IT1995的博客
07-23 4297
放置摄像机 在场景绘制之前摆放摄像机 【把摄像机摆好了，才能看到东西】 gluLookAt 前3个参数为：摄像机的位置； 中间3个参数：眼睛看到的视点； 后3个参数：从头顶发出去的方向向量； 犹如人看东西一样   如下伪代码： void Draw() { glClearColor(30.0f / 255.0f, 30.0f / 255.0f, 30.0f / 255.0f, 1.0f...
OpenGL基础（17）摄像机
wangdsh的博客
07-19 1677
OpenGL本身没有摄像机的概念，但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机，这样感觉就像我们在移动，而不是场景在移动。 1 摄像机LookAt矩阵建立 定义一个摄像机，我们需要一个摄像机在世界空间中的位置、观察的方向、一个指向它的右测的向量以及一个指向它上方的向量。依据这4个信息，我们可以构建出一个LookAt矩阵。 1.1 矩阵基本信息获取 @1定义摄像机 定义摄像机的位置，一个三维向量（0，0，3），如下所示： glm::vec3 cameraPos = glm.
【分享用于学习C++图像处理的代码示例】框架
无敌三脚猫的专栏
05-31 1558
分享用于学习C++图像处理的代码示例 为了便于学习图像处理并研究图像算法， 俺写了一个适合初学者学习的小小框架。   麻雀虽小五脏俱全。   采用的加解码库:stb_image 官方:http://nothings.org/   stb_image.h用于解析图片格式: JPG, PNG, TGA, BMP, PSD, GIF, HDR, PIC stb_im
【LearnOpenGL学习笔记】——07.摄像机
qq_45974407的博客
04-10 340
文章目录1.摄像机/观察空间2.LookAt(观察矩阵)3.欧拉角练习 1.摄像机/观察空间 以摄像机为原点的右手坐标系，x轴向右，z轴从屏幕指向自己(因此摄像机方向是z轴负方向) 如何构造模拟一个摄像机： ①摄像机位置：随便设置一个，如glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f); ②摄像机方向：设置指向目标(如原点)，glm::vec3 cameraTarget = glm::vec3(0.0f, 0.0f, 0.0f); 然后计算方向camera
opengl实现摄像机
05-30
在OpenGL中，实现摄像机可以通过设置观察矩阵来实现。观察矩阵是一个4x4的矩阵，用于将场景从世界坐标系转换到相机坐标系，以便将场景渲染到屏幕上。可以按照以下步骤来实现： 1. 初始化OpenGL窗口和OpenGL上下文。 2. 创建一个摄像机类，包括摄像机的位置、旋转角度、视角等属性，并实现摄像机的移动和旋转方法。 3. 在每次渲染场景时，根据摄像机的位置和旋转角度，计算出观察矩阵，并传递给OpenGL渲染管线。 4. 在OpenGL渲染管线中，使用观察矩阵将场景从世界坐标系转换到相机坐标系，并使用投影矩阵将场景投影到屏幕上。 需要注意的是，在实现摄像机时，需要掌握矩阵运算和向量运算等数学知识，以及OpenGL的渲染管线、投影模式和坐标系等概念。同时，还需要了解如何使用OpenGL的gluLookAt函数和gluPerspective函数来设置观察矩阵和投影矩阵。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值