Qt OpenGL相机的使用

最新推荐文章于 2024-04-24 16:18:49 发布
最新推荐文章于 2024-04-24 16:18:49 发布
阅读量504 收藏 1
点赞数
分类专栏： OpenGL 文章标签： qt opengl 相机 动画
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wb175208/article/details/125492786
版权

先看效果：
在这里插入图片描述
顶点着色器：

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTextureCoord;
out vec3 outColor;
out vec2 textureCoord;

//矩阵必须初始化，初始化单位矩阵，否则GLSL语言中默认矩阵是0矩阵
uniform mat4 trans = mat4(1.0);

uniform mat4 model = mat4(1.0);
uniform mat4 view = mat4(1.0);
uniform mat4 projection = mat4(1.0);

void main(){
	//gl_Position = trans * vec4(aPos.x, aPos.y, aPos.z, 1.0);//在矩阵乘法中是右乘左，与显实的乘法不同
	gl_Position = projection * view * model * vec4(aPos, 1.0);
	textureCoord = aTextureCoord;
}

片段着色器：

#version 330 core
out vec4 fragColor;
in vec3 outColor;//从顶点着色器中传过来的颜色
in vec2 textureCoord;
uniform sampler2D textureImg;
uniform sampler2D textureCpp;
void main(){
	//fragColor = texture(textureImg, textureCoord);
	 fragColor = mix(texture(textureImg,textureCoord), texture(textureCpp,textureCoord), 0.5);
}

相机类：

#pragma once

#include <QVector3D>
#include <qmatrix4x4.h>

// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
enum Camera_Movement {
	FORWARD,
	BACKWARD,
	LEFT,
	RIGHT,
	UP,
	DOWN
};

// Default camera values
const float YAW = -90.0f;
const float PITCH = 0.0f;
const float SPEED = 2.5f;
const float SENSITIVITY = 0.005f;
const float ZOOM = 45.0f;


class Camera {
public:
	// camera Attributes
	QVector3D Position;
	QVector3D Front;
	QVector3D Up;
	QVector3D Right;
	QVector3D WorldUp;
	// euler Angles
	float Yaw;
	float Pitch;
	// camera options
	float MovementSpeed;
	float MouseSensitivity;
	float Zoom;

	// constructor with vectors
	Camera(QVector3D position = QVector3D(0.0f, 0.0f, 0.0f), QVector3D up = QVector3D(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(QVector3D(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
		Position = position;
		WorldUp = up;
		Yaw = yaw;
		Pitch = pitch;
		updateCameraVectors();
	}
	// constructor with scalar values
	Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(QVector3D(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
		Position = QVector3D(posX, posY, posZ);
		WorldUp = QVector3D(upX, upY, upZ);
		Yaw = yaw;
		Pitch = pitch;
		updateCameraVectors();
	}
	~Camera();

	// returns the view matrix calculated using Euler Angles and the LookAt Matrix
	QMatrix4x4 GetViewMatrix() {
		QMatrix4x4 view;
		view.lookAt(Position, Position + Front, Up);
		return view;
	}

	// processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
	void ProcessKeyboard(Camera_Movement direction, float deltaTime) {
		float velocity = MovementSpeed * deltaTime;
		if (direction == FORWARD)
			Position += Front * velocity;
		if (direction == BACKWARD)
			Position -= Front * velocity;
		if (direction == LEFT)
			Position -= Right * velocity;
		if (direction == RIGHT)
			Position += Right * velocity;
		if (direction == UP)
			Position += WorldUp * velocity;
		if (direction == DOWN)
			Position -= WorldUp * velocity;
		//updateCameraVectors();
	}

	// processes input received from a mouse input system. Expects the offset value in both the x and y direction.
	void ProcessMouseMovement(float xoffset, float yoffset, bool constrainPitch = true) {
		xoffset *= MouseSensitivity;
		yoffset *= MouseSensitivity;

		Yaw += xoffset;
		Pitch += yoffset;

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

		// update Front, Right and Up Vectors using the updated Euler angles
		updateCameraVectors();
	}

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

private:
	// calculates the front vector from the Camera's (updated) Euler Angles
	void updateCameraVectors() {
		// calculate the new Front vector
		QVector3D front;
		front.setX(cos(Yaw) * cos(Pitch));
		front.setY(sin(Pitch));
		front.setZ(sin(Yaw) * cos(Pitch));
		Front = front.normalized();
		// also re-calculate the Right and Up vector
		Right = QVector3D::crossProduct(Front, WorldUp).normalized();
		Up = QVector3D::crossProduct(Right, Front).normalized();
	}
};

界面类：

#pragma once

#include <QOpenGLWindow>

#include <QOpenGLWidget>
#include <QOpenGLExtraFunctions>
#include <QDebug>
#include <QOpenGLTexture>
#include <QElapsedTimer>
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>

#include "camera.h"
class CameraWnd : public QOpenGLWindow {
	Q_OBJECT

public:
	CameraWnd();
	~CameraWnd();

protected:
	virtual void initializeGL();
	virtual void resizeGL(int w, int h);
	virtual void paintGL();

	void keyPressEvent(QKeyEvent *event);
	void mouseMoveEvent(QMouseEvent *event);
	void wheelEvent(QWheelEvent *event);
	void mousePressEvent(QMouseEvent *event);
	void mouseReleaseEvent(QMouseEvent *event);
private:
	class QOpenGLTexture *_texture1;
	class QOpenGLTexture *_texture2;
	QElapsedTimer m_time;

	Camera m_camera;
	float m_lastX;
	float m_lastY;
	float m_deltaTime = 0.0f;
	float m_lastFrame = 0.0f;
	bool m_firstMouse = true;
	bool m_isMousePress = false;
	class QOpenGLFunctions_3_3_Core* _openGLCore;
	QOpenGLShaderProgram _shaderProgram;//着色器程序，所里系统所有的着色器
};


#include "CameraWnd.h"
#include <QKeyEvent>
#include <QMouseEvent>
#include <QWheelEvent>
#include <QOpenGLFunctions_3_3_Core>

static GLuint VBO, VAO = 0;
// world space positions of our cubes
static QVector3D cubePositions[] = {
	QVector3D(0.0f,  0.0f,  0.0f),
	QVector3D(2.0f,  5.0f, -15.0f),
	QVector3D(-1.5f, -2.2f, -2.5f),
	QVector3D(-3.8f, -2.0f, -12.3f),
	QVector3D(2.4f, -0.4f, -3.5f),
	QVector3D(-1.7f,  3.0f, -7.5f),
	QVector3D(1.3f, -2.0f, -2.5f),
	QVector3D(1.5f,  2.0f, -2.5f),
	QVector3D(1.5f,  0.2f, -1.5f),
	QVector3D(-1.3f,  1.0f, -1.5f)
};

CameraWnd::CameraWnd() {
	m_camera.Position = QVector3D(0.0f, 0.0f, 3.0f);
	m_lastX = width() / 2;
	m_lastY = height() / 2;
}

CameraWnd::~CameraWnd() {
}

void CameraWnd::initializeGL() {
	_openGLCore = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();

	_openGLCore->glEnable(GL_DEPTH_TEST);

	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
	};
	_openGLCore->glGenVertexArrays(1, &VAO);
	_openGLCore->glGenBuffers(1, &VBO);

	_openGLCore->glBindVertexArray(VAO);

	_openGLCore->glBindBuffer(GL_ARRAY_BUFFER, VBO);
	_openGLCore->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	// position attribute
	_openGLCore->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
	_openGLCore->glEnableVertexAttribArray(0);
	// texture coord attribute
	_openGLCore->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
	_openGLCore->glEnableVertexAttribArray(1);

	//垂直镜像mirrored
	_texture1 = new QOpenGLTexture(QImage("E:/Projects/QtGuiTest/OPenGLApp/shader/1.jpg").mirrored());
	if (!_texture1->isCreated()) {
		qDebug() << "Failed to load texture";
	}
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	_texture1->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	_texture1->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);

	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	_texture1->setMinificationFilter(QOpenGLTexture::Linear);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	_texture1->setMagnificationFilter(QOpenGLTexture::Linear);
	_texture2 = new QOpenGLTexture(QImage("E:/Projects/QtGuiTest/OPenGLApp/shader/2.png").mirrored());
	if (!_texture2->isCreated()) {
		qDebug() << "Failed to load texture";
	}
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	_texture2->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	_texture2->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);

	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	_texture2->setMinificationFilter(QOpenGLTexture::Linear);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	_texture2->setMagnificationFilter(QOpenGLTexture::Linear);

	//设置纹理单元编号
	_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex, "E:/Projects/QtGuiTest/OPenGLApp/shader/Camera.vert");
	_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment, "E:/Projects/QtGuiTest/OPenGLApp/shader/Camera.frag");

	_shaderProgram.link();


	//如果是一张图片就不用绑定，默认绑定。如果是多于1张就需要主动绑定，
	_shaderProgram.bind();
	/*
	** textureImg：对应的片元着色器的 uniform sampler2D textureImg;
	** textureCpp：对应的片元着色器的 uniform sampler2D textureCpp;
	*/
	_shaderProgram.setUniformValue("textureImg", 0);
	_shaderProgram.setUniformValue("textureCpp", 1);

	m_time.start();
}

void CameraWnd::resizeGL(int w, int h) {
	_openGLCore->glViewport(0, 0, w, h);
}

void CameraWnd::paintGL() {
	_openGLCore->glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
	_openGLCore->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	float currentFrame = (float)m_time.elapsed() / 100;
	m_deltaTime = currentFrame - m_lastFrame;
	m_lastFrame = currentFrame;

	//激活纹理单元0
	_openGLCore->glActiveTexture(GL_TEXTURE0);
	_texture1->bind();
	_openGLCore->glActiveTexture(GL_TEXTURE1);
	_texture2->bind();

	// render container
	_shaderProgram.bind();
	QMatrix4x4 view = m_camera.GetViewMatrix();
	QMatrix4x4 projection;

	view.translate(QVector3D(0.0f, 0.0f, -3.0f));
	projection.perspective(m_camera.Zoom, (float)width() / (float)height(), 0.1f, 100.0f);

	for (unsigned int i = 0; i < 10; i++) {
		QMatrix4x4 model;
		model.translate(cubePositions[i]);
		float angle;
		if (i % 3 == 0) {
			angle = (float)m_time.elapsed() / 10;
		} else {
			angle = i * 20.0f;
		}
		model.rotate(angle, QVector3D(1.0f, 0.3f, 0.5f));
		_shaderProgram.setUniformValue("model", model);
		_shaderProgram.setUniformValue("view", view);
		_shaderProgram.setUniformValue("projection", projection);
		_openGLCore->glDrawArrays(GL_TRIANGLES, 0, 36);
	}
	update();
}

void CameraWnd::keyPressEvent(QKeyEvent *event) {
	if (event->key() == Qt::Key_A) {
		m_camera.ProcessKeyboard(Camera_Movement::LEFT, m_deltaTime);
	} else if (event->key() == Qt::Key_D) {
		m_camera.ProcessKeyboard(Camera_Movement::RIGHT, m_deltaTime);
	} else if (event->key() == Qt::Key_W) {
		m_camera.ProcessKeyboard(Camera_Movement::FORWARD, m_deltaTime);
	} else if (event->key() == Qt::Key_S) {
		m_camera.ProcessKeyboard(Camera_Movement::BACKWARD, m_deltaTime);
	} else if (event->key() == Qt::Key_E) {
		m_camera.ProcessKeyboard(Camera_Movement::UP, m_deltaTime);
	} else if (event->key() == Qt::Key_Q) {
		m_camera.ProcessKeyboard(Camera_Movement::DOWN, m_deltaTime);
	}
}

void CameraWnd::mouseMoveEvent(QMouseEvent *event) {
	float xpos = static_cast<float>(event->pos().x());
	float ypos = static_cast<float>(event->pos().y());
	if (!m_isMousePress)
		return;

	if (m_firstMouse) {
		m_lastX = xpos;
		m_lastY = ypos;
		m_firstMouse = false;
	}

	float xoffset = xpos - m_lastX;
	float yoffset = m_lastY - ypos; // reversed since y-coordinates go from bottom to top

	m_lastX = xpos;
	m_lastY = ypos;

	m_camera.ProcessMouseMovement(xoffset, yoffset);
}

void CameraWnd::wheelEvent(QWheelEvent *event) {
	m_camera.ProcessMouseScroll((float)event->angleDelta().y() / 60.0f);
}

void CameraWnd::mousePressEvent(QMouseEvent *event) {
	if (event->button() == Qt::LeftButton)
		m_isMousePress = true;
}

void CameraWnd::mouseReleaseEvent(QMouseEvent *event) {
	if (event->button() == Qt::LeftButton) {
		m_isMousePress = false;
		m_firstMouse = true;
	}
}

aaa

wb175208
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
在Qt中使用OpenGL（七）
Ninsun的博客
01-27 4120
在Qt中使用OpenGL模拟光照
Qt OpenGL教程
weixin_34258838的博客
11-05 1725
Qt OpenGL教程 最近一段时间除了学习Qt，翻译Qt文档之外，由于工作和兴趣的原因，开始着手看Qt OpenGL编程。在网上搜索了有关OpenGL的教程，发现NeHe的OpenGL教程的还很不错，作者是NeHe。上面有很多种语言的实现，但是没有Qt和Gtk的，所以我就想着手写这个Qt OpenGL教程，每课的内容和NeHe是一样的。另外，介绍NeHe的一个中文翻译站点CSDN-CKer翻译...
利用QOpenGLWidget实现鼠标控制相机的平移缩放等操作
10-19
具体介绍：https://blog.csdn.net/yangfahe1/article/details/120811649
QT之OpenGL摄像机
weixin_41111116的博客
11-20 1066
QT之OpenGL摄像机
Qt实现OpenGL的经典教程⑦——摄像机
最新发布
qq_45233572的博客
04-24 1043
Qt版本：6.7操作系统：Windows10。
QT中学习Opengl---（摄像机2）
比卡丘不皮的博客
08-03 685
本文的代码是中对应代码，这里提供学习，大家喜欢的可去官方网站去看看:本章讲解摄像机的移动。欧拉角欧拉角是表示3D空间中可以表示任何旋转的三个值， 由莱昂哈德·欧拉在18世纪提出。有三种欧拉角： 俯仰角(Pitch)、 偏航角(Yaw)和滚转角(Roll)， 下面的图片展示了它们的含义：下面看看添加鼠标，键盘，视角的变化吧。......
QT+OpenGL初学实现摄像机在3D场景自由移动
FonlinCSDN的博客
03-23 892
QT+OpenGL初学实现摄像机在3D场景自由移动
OpenGL之相机
qq_44632658的博客
09-23 250
OpenGL本身没有(Camera)的概念，但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机，产生一种在移动的感觉，而不是场景在移动。本节我们将会讨论如何在OpenGL中配置一个摄像机，并且将会讨论FPS风格的摄像机，让你能够在3D场景中自由移动。我们也会讨论键盘和鼠标输入，最终完成一个自定义的摄像机类。
Qt openGL 透视投影例题
02-05
在本文中，我们将深入探讨如何在Qt环境中使用OpenGL进行透视投影。Qt是一个强大的跨平台应用程序开发框架，而OpenGL则是一个用于渲染2D和3D图形的开放标准库。结合这两者，我们可以创建出功能丰富的图形用户界面应用...
基于QT使用OpenGL，加载obj模型，进行鼠标交互
11-09
基于QT的QOpenGLWidget类进行派生，对鼠标事件进行重载，使用OpenGL可编程渲染模式开发，涉及着色器程序的编写，并进行了相机、渲染器、物体类的抽象。还编写了obj文件解析类，同时还可以基于本框架进行stl文件类的...
用Qt和OpenGL制作的颜色立方体例子（演示程序+源代码）
07-16
此资源包含了演示程序和源代码。 ---------------------------- Qt5相比Qt4有了很大的改变，对OpenGL这一部分支持的力度加大了。如果说Qt5.0对OpenGL这部分的改变还是试验性的，那么Qt5.1中与OpenGL相关的函数和封装则是优化和一些小小的微调。早在Qt5.1还没有发布的时候，国外就有高手发布了Qt5.1对OpenGL支持的相关特性。
QT(5.9.6)+OpenGL加载显示obj模型
04-15
QT(5.9.6)结合OpenGL加载与...通过以上步骤，我们可以实现一个在Win10 64Bit环境下，使用Qt5.9.6和OpenGL加载并显示OBJ模型的应用程序。这个项目不仅展示了Qt3D的基本用法，也体现了OpenGL在现代3D图形编程中的重要性。
QT--OPENGL-串口-雷达点云图显示
05-07
1：利用 OpenGL 进行点云及直线的显示（同时使用两个着色器）； 2：可以实现串口的自动识别及操作； 3：雷达图像的显示（可以实现点云数据及点云距离的同比例缩放及显示）； 4：在OpenGL显示部分，相机矩阵与代码中...
Qt+OpenGL摄像机，移动，放大缩小
06-09
Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt+OpenGL摄像机，移动，放大缩小，Qt...
用于OpenGl的Camera类(QT实现的3D摄像机类)
Miao的博客
05-13 3054
最近在搞QT上的OPENGL,有好多库都要自己写啊 哐哧哐哧写了一大顿，已经写好了，回过头来记录一下 这篇讲的时关于opengl自由摄像机的问题 写摄像机的思路是，写一个万能的摄像机基类，可以支持各种基本操作（没有添加左右晃镜头的功能） 然后如果你需要用到什么样的摄像机，继承基类，然后重写他的移动函数和改变镜头方向函数（这两个函数为虚函数） 这样的话，你不用考虑是什么类型的摄像机，把摄像...
QT+OpenGL 摄像机
turbolove的博客
02-11 995
本篇完整工程见gitee:[QtOpenGL](https://gitee.com/turbolove/qtopengl.git) 对应点的tag，由turbolove提供技术支持，您可以关注博主或者私信博主
Learn OpenGL with Qt——完美的Qt摄像机
ItaLink
05-10 7274
摄像机 前面的教程中我们讨论了观察矩阵以及如何使用观察矩阵移动场景（我们向后移动了一点）。OpenGL本身没有摄像机(Camera)的概念，但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机，产生一种我们在移动的感觉，而不是场景在移动。 本节我们将会讨论如何在Qt中配置一个摄像机，并且将会讨论FPS风格的摄像机，让你能够在3D场景中自由移动。我们也会讨论键盘和鼠标输入，最终完成一个带有摄像机的窗口。 摄像机/观察空间 当我们讨论摄像机/观察空间(Camera/View Space)的
QT对OPenGL的封装
RaoJohn的博客
11-28 4750
QT对OPenGL的封装提起3D渲染大家应该都会想起OPenGL这个开源的图形学渲染库，它也是目前图形学领域的一个工业标准，具有广泛的应用前景。虽然OPenGL的开发也提供了大量的附属库包括GLUT等，但这些图形化界面相比与QT而言开发过程显得十分不方便，幸运的是QT目前已经提供了对于OPenGL的全方面支持，既可以直接使用OPenGL底层函数也可以运用Qt封装好的类进行实现，保证便捷性的同时不失灵
QT中学习Opengl---（摄像机）
比卡丘不皮的博客
03-16 1673
前言： 本文的代码是 LearnOpenGL 中对应代码，这里提供学习，大家喜欢的可去官方网站去看看:LearnOpenGL-CNhttps://learnopengl-cn.readthedocs.io/zh/latest/ 本章将要讲解摄像机的功效。 Camera OpenGL本身没有摄像机的概念， 但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机， 这样感觉就像我们在移动， 而不是场景在移动。 如下图： 定义一个摄像机， 我们需要一个摄像机在世界空间中...
Qt opengl assimp使用骨骼动画代码
05-20
以下是使用Qt、OpenGL和Assimp实现骨骼动画的示例代码： 首先，需要在项目中包含assimp库和Qt的OpenGL模块。可以使用以下命令将它们添加到.pro文件中： ``` LIBS += -lassimp QT += opengl ``` 然后，需要编写一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wb175208

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值