计算机图形学（七）——画一个可以由鼠标键盘控制的立方体

最新推荐文章于 2022-03-01 19:20:57 发布
最新推荐文章于 2022-03-01 19:20:57 发布
阅读量1.4k 收藏 8
点赞数 1
分类专栏： 计算机图形学 文章标签： 图形学 opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44018760/article/details/109133136
版权

画一个可以由鼠标键盘控制的立方体

本节将会再OpenGL中配置一个摄像机，让正方体能够再3D场景中自由移动，同时也会讨论鼠标和键盘输入。OpenGL本身没有相机的概念，我们可以通过把物体往相反的方向移动来模拟出摄像机，产生一种我们在移动的感觉，而不是场景在移动。
首先需要修改core.vs

#version 330 core
layout(location = 0) in vec3 position;
layout (location = 1) in vec3 color;
uniform mat4 transform;
uniform mat4 view;
uniform mat4 projection;

out vec3 outColor;

void main()
{
gl_Position = projection * view * transform * vec4(position,1.0f);
outColor=color;
}

片源着色器core.fs不用作修改

#version 330 core
in vec3 outColor;
out vec4 color;
void main()
{
color = vec4(outColor,1.0f);
}

接下来定义头文件Camera.h

#pragma once
#include<vector>
#define GLFW_STATIC
#include<GL/glew.h>

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

enum Camera_Movement
{
	FOWARD,
	BACKWARD,
	LEFT,
	RIGHT
};

//6个自由度

const GLfloat YAW = -90.0f;//
const GLfloat PITCH = 0.0f;
const GLfloat SPEED = 6.0f;
const GLfloat SENSITIVITY = 0.25f;//灵敏度
const GLfloat ZOOM = 45.0f;

class Camera
{
public:
	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(SENSITIVITY), zoom(ZOOM)
	{
		this->position = position;
		this->worldUp = up;
		this->yaw = yaw;
		this->pitch = pitch;
		this->updateCameraVectors();
	}
	Camera(GLfloat posX,GLfloat posY,GLfloat posZ,GLfloat upX,GLfloat upY,GLfloat upZ,
		GLfloat yaw = YAW, GLfloat pitch = PITCH) :front(glm::vec3(0.0f, 0.0f, -1.0f)), movementSpeed(SPEED),
		mouseSensitivity(SENSITIVITY), zoom(ZOOM)
	{
		this->position = glm::vec3(posX,posY,posZ);
		this->worldUp = glm::vec3(upX,upY,upZ);
		this->yaw = yaw;
		this->pitch = pitch;
		this->updateCameraVectors();
	}
	void ProcessKeyboard(Camera_Movement direction, GLfloat deltaTime)//时间控制速度
	{
		GLfloat velocity = this->movementSpeed * deltaTime;

		if (direction == FOWARD) {
			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)
	{
		xOffset *= this->mouseSensitivity;
		yOffset *= this->mouseSensitivity;

		this->yaw += xOffset;
		this->pitch += yOffset;

		this->updateCameraVectors();
	}
	void ProcessScroll(GLfloat yOffset)
	{
		this->zoom += yOffset;
	}
	GLfloat GetZoom()
	{
		return this->zoom;
	}
	glm::mat4 GetViewMatrix()
	{//视角矩阵
		return glm::lookAt(this->position, this->position + this->front, this->up);
	}
private:
	GLfloat yaw;
	GLfloat pitch;
	GLfloat movementSpeed;
	GLfloat mouseSensitivity;
	GLfloat zoom;

	glm::vec3 position;
	glm::vec3 front;
	glm::vec3 up;
	glm::vec3 right;
	glm::vec3 worldUp;
	void updateCameraVectors()
	{
		//相机的位置和朝向（前、上、右）
		glm::vec3 front;
		front.x = cos(glm::radians(this->pitch)) * cos(glm::radians(this->yaw));
		front.y = sin(glm::radians(this->pitch));
		front.z = cos(glm::radians(this->pitch)) * sin(glm::radians(this->yaw));

		this->front = glm::normalize(front);
		//normalize取单位化
		this->right = glm::normalize(glm::cross(this->front, this->worldUp));
		this->up = glm::normalize(glm::cross(this->right, this->front));
	}
};

欧拉角

欧拉角可以表示3D空间中任何旋转的3个值，由莱昂哈德·欧拉(Leonhard Euler)在18世纪提出。一共有3种欧拉角：俯仰角(Pitch)、偏航角(Yaw)和滚转角(Roll)，下面的图片展示了它们的含义：
在这里插入图片描述
俯仰角是描述我们如何往上或往下看的角，可以在第一张图中看到。第二张图展示了偏航角，偏航角表示我们往左和往右看的程度。滚转角代表我们如何翻滚摄像机，通常在太空飞船的摄像机中使用。每个欧拉角都有一个值来表示，把三个角结合起来我们就能够计算3D空间中任何的旋转向量了。

对于我们的摄像机系统来说，我们只关心俯仰角和偏航角，所以我们不会讨论滚转角。给定一个俯仰角和偏航角，我们可以把它们转换为一个代表新的方向向量的3D向量。
Shader.h不做改动

#pragma once

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

#include <GL/glew.h>

class Shader
{
	GLuint vertex, fragment;
public:
	GLuint Program;
	Shader(const GLchar* vertexPath, const GLchar* fragmentPath)
	{
		std::string vertexCode;
		std::string fragmentCode;
		std::ifstream vShaderFile;
		std::ifstream fShaderFile;

		vShaderFile.exceptions(std::ifstream::badbit);
		fShaderFile.exceptions(std::ifstream::badbit);

		try
		{
			vShaderFile.open(vertexPath);
			fShaderFile.open(fragmentPath);

			std::stringstream vShaderStream, fShaderStream;
			vShaderStream << vShaderFile.rdbuf();
			fShaderStream << fShaderFile.rdbuf();

			vShaderFile.close();
			fShaderFile.close();

			vertexCode = vShaderStream.str();
			fragmentCode = fShaderStream.str();

		}
		catch (std::ifstream::failure e)
		{
			std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ" << std::endl;
		}
		const GLchar* vShaderCode = vertexCode.c_str();
		const GLchar* fShaderCode = fragmentCode.c_str();

		//compile Shaders
		GLint success;
		GLchar infoLog[512];
		vertex = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertex, 1, &vShaderCode, NULL);
		glCompileShader(vertex);

		glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
		if (!success) {
			glGetShaderInfoLog(vertex, 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n"
				<< infoLog << std::endl;
		}

		fragment = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment, 1, &fShaderCode, NULL);
		glCompileShader(fragment);

		glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
		if (!success) {
			glGetShaderInfoLog(fragment, 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n"
				<< infoLog << std::endl;
		}

		this ->Program = glCreateProgram();
		glAttachShader(this->Program, vertex);
		glAttachShader(this->Program, fragment);
		glLinkProgram(this->Program);

		glGetProgramiv(this->Program, GL_LINK_STATUS, &success);
		if (!success) {
			glGetProgramInfoLog(this->Program, 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::PROGRAM::LINK_FAILED\n"
				<< infoLog << std::endl;
		}
	}
	~Shader() {
		glDetachShader(this->Program, vertex);
		glDetachShader(this->Program, fragment);
		glDeleteShader(vertex);
		glDeleteShader(fragment);
		glDeleteProgram(this->Program);
	}
	void Use()
	{
		glUseProgram(this->Program);
	}
};

main.cpp

#include <iostream>
#define GLEW_STATIC
#include <GL/glew.h>
#include<GLFW/glfw3.h>
#include "Shader.h"
#include "Camera.h"

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

const GLint WIDTH = 800, HEIGHT = 600;

void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mode);

void MouseCallback(GLFWwindow* window, double xPos, double yPos);
void ScrollCallback(GLFWwindow* window, double xOffset, double yOffset);
void DoMovement();

GLfloat lastX = 0.0f;
GLfloat lastY = 0.0f;
bool firstMouse = true;

bool keys[1024];

Camera camera(glm::vec3(0.0f, 0.0f, 2.0f));
GLfloat deltaTime = 0.0f;
GLfloat lastTime = 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_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

	GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
	int screenWidth, screenHeight;
	glfwGetFramebufferSize(window, &screenWidth, &screenHeight);

	if (window == nullptr) {
		std::cout << "Failed to create GLFW window" <<
			std::endl;
		glfwTerminate();
		return  -1;
	}

	glfwMakeContextCurrent(window);

	glfwSetKeyCallback(window, KeyCallback);
	glfwSetCursorPosCallback(window, MouseCallback);
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	glfwSetScrollCallback(window,ScrollCallback);

	glewExperimental = GL_TRUE;

	if (glewInit() != GLEW_OK) {
		std::cout << "Failed to initialize GLEW" <<
			std::endl;
		glfwTerminate();
		return -1;
	}

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	//允许深度测试
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);//深度信息小的覆盖信息大的

	Shader shader = Shader("res/shaders/core.vs","res/shaders/core.fs");
	Shader lightShader = Shader("res/shaders/light.vs", "res/shaders/light.fs");
	//Cube
	GLfloat vertices[] =
	{
		//position			//color
		//back
		-0.5,-0.5f,-0.5f,   1.0f,0.0f,0.0f,
		0.5f,-0.5f,-0.5f,   1.0f,0.0f,0.0f,
		0.5f,0.5f,-0.5f,    1.0f,0.0f,0.0f,
		0.5f,0.5f,-0.5f,    1.0f,0.0f,0.0f,
		-0.5f,0.5f,-0.5f,   1.0f,0.0f,0.0f,
		-0.5f,-0.5f,-0.5f,  1.0f,0.0f,0.0f,
		//front
		-0.5,-0.5f,0.5f,   0.0f,1.0f,0.0f,
		0.5f,-0.5f,0.5f,   0.0f,1.0f,0.0f,
		0.5f,0.5f,0.5f,    0.0f,1.0f,0.0f,
		0.5f,0.5f,0.5f,    0.0f,1.0f,0.0f,
		-0.5f,0.5f,0.5f,   0.0f,1.0f,0.0f,
		-0.5f,-0.5f,0.5f,  0.0f,1.0f,0.0f,
		//left
		-0.5f,0.5f,0.5f,	0.0f,0.0f,1.0f,
		-0.5f,0.5f,-0.5f,	0.0f,0.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,0.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,0.0f,1.0f,
		-0.5f,-0.5f,0.5f,	0.0f,0.0f,1.0f,
		-0.5f,0.5f,0.5f,	0.0f,0.0f,1.0f,
		//right
		0.5f,0.5f,0.5f,		0.0f,1.0f,1.0f,
		0.5f,0.5f,-0.5f,	0.0f,1.0f,1.0f,
		0.5f,-0.5f,-0.5f,	0.0f,1.0f,1.0f,
		0.5f,-0.5f,-0.5f,	0.0f,1.0f,1.0f,
		0.5f,-0.5f,0.5f,	0.0f,1.0f,1.0f,
		0.5f,0.5f,0.5f,		0.0f,1.0f,1.0f,
		//bottom
		-0.5f,-0.5f,-0.5f,	1.0f,0.0f,1.0f,
		0.5f,-0.5f,-0.5f,	1.0f,0.0f,1.0f,
		0.5f,-0.5f,0.5f,	1.0f,0.0f,1.0f,
		0.5f,-0.5f,0.5f,	1.0f,0.0f,1.0f,
		-0.5f,-0.5f,0.5f,	1.0f,0.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	1.0f,0.0f,1.0f,
		//up
		-0.5f,0.5f,-0.5f,	1.0f,1.0f,0.0f,
		0.5f,0.5f,-0.5f,	1.0f,1.0f,0.0f,
		0.5f,0.5f,0.5f,		1.0f,1.0f,0.0f,
		0.5f,0.5f,0.5f,		1.0f,1.0f,0.0f,
		-0.5f,0.5f,0.5f,	1.0f,1.0f,0.0f,
		-0.5f,0.5f,-0.5f,	1.0f,1.0f,0.0f,
	};

	GLuint VAO, VBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);

	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
	glEnableVertexAttribArray(1);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);

	GLuint VAO1, VBO1;
	glGenVertexArrays(1, &VAO1);
	glGenBuffers(1, &VBO1);
	glBindVertexArray(VAO1);
	glBindBuffer(GL_ARRAY_BUFFER, VBO1);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);

	while (!glfwWindowShouldClose(window)) {
		GLfloat currentTime = glfwGetTime();
		deltaTime = currentTime - lastTime;
		lastTime = currentTime;

		glViewport(0, 0, screenWidth, screenHeight);
		glfwPollEvents();
		DoMovement();//在PollEvents后响应
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);//用到都要初始化
		shader.Use();
		glm::mat4 view = camera.GetViewMatrix();

		glm::mat4 projection = glm::perspective(glm::radians(camera.GetZoom()),
			static_cast<GLfloat>(screenWidth) / static_cast<GLfloat>(screenHeight), 0.1f, 100.0f);

		GLuint viewLoc = glGetUniformLocation(shader.Program, "view");
		glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));

		GLuint projectionLoc = glGetUniformLocation(shader.Program, "projection");
		glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

		glm::mat4 transform = glm::mat4(1.0f);

		//平移
		transform = glm::translate(transform, glm::vec3(0.0f, 0.4f, 0.0f));
		//旋转
		transform = glm::rotate(transform, glm::radians(20.0f)*static_cast<GLfloat>(glfwGetTime()), glm::vec3(1.0f, 1.0f, 1.0f));
		//缩放
		transform = glm::scale(transform, glm::vec3(0.5f, 0.5f, 0.5f));
		
		

		GLuint transLoc = glGetUniformLocation(shader.Program, "transform");
		glUniformMatrix4fv(transLoc, 1, GL_FALSE, glm::value_ptr(transform));

		glBindVertexArray(VAO);
		glDrawArrays(GL_TRIANGLES, 0, 36);
		glBindVertexArray(0);

		lightShader.Use();
		viewLoc = glGetUniformLocation(lightShader.Program, "view");
		glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));

		projectionLoc = glGetUniformLocation(lightShader.Program, "projection");
		glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

		transform = glm::mat4(1.0f);

		transform = glm::rotate(transform, glm::radians(20.0f) * static_cast<GLfloat>(glfwGetTime()), glm::vec3(1.0f, 1.0f, 1.0f));
		transform = glm::translate(transform, glm::vec3(0.0f, 2.0f, 0.0f));
		transform = glm::scale(transform, glm::vec3(0.1f, 0.1f, 0.1f));
		transLoc = glGetUniformLocation(lightShader.Program, "transform");
		glUniformMatrix4fv(transLoc, 1, GL_FALSE, glm::value_ptr(transform));

		glBindVertexArray(VAO1);
		glDrawArrays(GL_TRIANGLES, 0, 36);
		glBindVertexArray(0);

		glfwSwapBuffers(window);
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glfwTerminate();
	return 0;
}

void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
	{
		glfwSetWindowShouldClose(window, GL_TRUE);
	}
	if (key >= 0 && key < 1024) {
		if (action == GLFW_PRESS) {
			keys[key] = true;
		}
		else if (action == GLFW_RELEASE)
		{
			keys[key] = false;
		}
	}
}
void MouseCallback(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 DoMovement()
{
	if (keys[GLFW_KEY_W] || keys[GLFW_KEY_UP]) {
		//up
		camera.ProcessKeyboard(FOWARD,deltaTime);
	}
	if (keys[GLFW_KEY_S] || keys[GLFW_KEY_DOWN]) {
		//down
		camera.ProcessKeyboard(BACKWARD, deltaTime);
	}
	if (keys[GLFW_KEY_A] || keys[GLFW_KEY_LEFT]) {
		//left
		camera.ProcessKeyboard(LEFT, deltaTime);
	}
	if (keys[GLFW_KEY_D] || keys[GLFW_KEY_RIGHT]) {
		//right
		camera.ProcessKeyboard(RIGHT, deltaTime);
	}
}
void ScrollCallback(GLFWwindow* window, double xOffset, double yOffset)
{
	camera.ProcessScroll(yOffset);
}

运行结果

在这里插入图片描述

林 汐☜
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算机图形学 交互式项目（鼠标，键盘，菜单）
weixin_52036334的博客
11-12 542
计算机图形学交互式设计，项目可运行
计算机图形学期末答辩作业——opengl室内简单场景设计(可键盘交互、可视角漫游、有纹理贴图、实现光照)
hry1999的博客
07-13 9461
一、项目说明 这个opengl场景设计是我们的计算机图形学课程期末答辩大作业。此项目实现了一个简单的室内场景设计，此场景由沙发、茶几、桌子、水壶、地板、墙壁等元素构成，其中地板与墙壁采取了纹理贴图，并可使用键盘实现与场景的交互，可以实现视角漫游、物体旋转，控制光照等功能。另外，此场景设计简单，代码简洁，共使用430多行代码便实现了简单的场景设计与基本操作，并且每一句代码都有非常详细的注释，相信就算是一点opengl基础没有也可通过学习本项目轻松入门。 二、运行说明 1、电脑版本：win10 2、运行软件：V
OpenGl实现的光照及鼠标、键盘交互
05-20
这是我的计算机图形学实验，程序使用了NeHe的框架，通过读取一个PLY文件中的数据生成了一个兔子，有完整的鼠标和键盘交互，包括旋转、平移、光照等，不足之处是立体感不足，光照范围有限，开头的数组定义方法也很死板，哪位大侠改善后发到我邮箱吧：531252285@qq.com，先谢啦。 鉴于我搜集资料时已经花费十分的资源分了，就收一分赚个成本吧
计算机图形学——大作业
加载中.......
03-01 1万+
计算机图形学大作业 一、实验要求 绘制一个简单的三维场景，可以是室内：卧室，办公室，教室，也可以是室外：运动场，公园等，加上光照效果，简单的纹理映射，透视投影；不能过于简单；可以加动画、鼠标和键盘交互。 上交材料： project和word文档（具体内容展示，思路和心得） 二、实验思路 首先初始化窗口，定义摄像机坐标与视口坐标，利用实验二的知识内容绘制三维立体模型，定义每一个模型的坐标值以及利用变换函数实现相对位置的放置；利用实验三中的知识给整个场景进行灯光的设置；然后使用实验四中的代码实...
计算机图形学（一）——opengl实现三维立方体添加纹理光照与材质、键盘鼠标控制平移旋转和放大缩小
诶你爱我吗的博客
12-27 8293
1.实验要求： 用OpenGL和C语言编写一个带纹理和材质的一个立方体的交互式程序。 1)要求生成一个在立方体，并在立方体的六个面上并分别实现不同的纹理映射和材质。纹理的类型为BMP图片纹理，材质类型可以自己设计。例如，三个面上实现纹理映射的头像和生活照，另外三个面上实现材质(金属、塑料等)。 2)可以利用鼠标和键盘进行交互，实现该立方体的旋转、平移和缩放。 2.实验效果图如下： 正常情况下 加...
如何用python制作正方形模拟器 python项目小发明 【安安教具】-【数学】-【正方形】模拟器
anananajiushiwo的博客
02-09 1079
用python制作正方形模拟器
易语言动画框画立体图形
07-15
1. 定义图形的基本形状，如立方体、球体或其他复杂几何体，这些通常由多个二维平面组成。 2. 计算每个平面在不同角度下的坐标，这需要对欧几里得几何和向量运算有一定的了解。 3. 使用易语言的绘图命令，如"画线"、...
OpenGL简单实例——实现立方体贴上不同纹理
12-21
OpenGL是计算机图形学中的一种广泛应用的编程接口，用于在各种操作系统和硬件平台上生成二维和三维图像。本实例主要讲解如何使用OpenGL与GLUT库在C语言环境下实现一个立方体，并在其六个面上贴上不同的纹理，这对于...
《Java 3D编程实践——网络上的三维动画》 源代码
02-13
Java 3D是一种基于OpenGL的高级图形库，由Sun Microsystems开发，用于在Java应用程序中创建和展示复杂的三维图形。它为开发者提供了强大的功能，包括对象建模、光照、纹理映射、视图控制以及物理模拟等，使得Java...
上机作业要求和说明.docx
01-09
【南京航空航天大学计算机图形学2020上机作业】要求学生使用OpenGL编程接口创建一个三维房间模型。这个作业旨在让学生应用计算机图形学理论，并初步接触OpenGL编程库。任务不仅包括构建基本的3D形状（如锥体、球体、...
opengl实现键盘鼠标等交互
04-18
利用OPENGL编写的程序..实现键盘鼠标的响应，并且能都实现交互。
计算机硬件图标
12-24
【标题】"计算机硬件图标"揭示了这个压缩包文件的核心内容——它包含了一系列与计算机硬件相关的图标设计。这些图标可能是为了展示、标识或教学目的而创建的，它们以图形化的方式呈现了各种计算机硬件组件，使得用户...
计算机图形学|南邮——画由键盘鼠、标控制的正方体
qq_43808588的博客
10-15 1428
要定义一个摄像机，我们需要它在世界空间中的位置、观察的方向、一个指向它右测的向量以及一个指向它上方的向量。细心的读者可能已经注意到我们实际上创建了一个三个单位轴相互垂直的、以摄像机的位置为原点的坐标系。 这里涉及到OpenGL的坐标系类型，OpenGL是右手坐标系，而DX是左手坐标系，简单讲讲右手坐标系： 在图上画右手坐标系，一条水平的直线表示X轴，从左往右为正方向；一条垂直的直线表示Y轴，...
计算机图形学 实现鼠标拖拽图元
leihao-lester
10-26 530
计算机图形学 实现鼠标拖拽图元 问题描述 当计算机图形学中需要实现拖拽图元时，关键在于如何判断鼠标是否在拖拽，鼠标被拖拽时的移动 确定鼠标是在图元内部按下还是按下后移动到图元内 确定鼠标的移动，点击图元，图元的原点（锚点）不会瞬移至光标的位置 已知如下变量 bool isContained反映鼠标当下位置是否在图元内，true为在图元内，false为在图元外 bool isDraging反映鼠标此时是否被按下，true表示鼠标此时被按下，false表示鼠标此时未被按下 primitive图元结构体，有c
计算机图形学（六）——画一个旋转的立方体
qq_44018760的博客
10-17 1878
画一个会动的立方体 //画立方体 #include <iostream> #define GLEW_STATIC #include"Shader.h" #include"Camera.h" #include<GL/glew.h> #include<GLFW/glfw3.h> #include<glm/glm.hpp> #include<glm/gtc/matrix_transform.hpp> #include<glm/gtc/type
计算机图形学作业（ 五）：画一个立方体并实现 Phong Shading 和 Gouraud Shading 两种阴影
看门猫的博客
04-27 5807
计算机图形学作业（ 五）：画一个立方体并实现 Phong Shading 和 Gouraud Shading 两种阴影颜色和光照场景Phong Shading环境光照漫反射光照镜面光照着色器代码结果Gouraud Shading 颜色和光照场景 我们在现实生活中看到某一物体的颜色并不是这个物体真正拥有的颜色，而是它所反射的颜色。换句话说，那些不能被物体所吸收的颜色（被拒绝的颜色）就是我们能够感知到...
如何用计算机画立方体,画立方体-计算机图形学实验.doc
weixin_39737757的博客
06-25 812
画立方体-计算机图形学实验.doc (8页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！9.90 积分计算机图形学实验——画立方体(通过视向变换等)具体实现如下(仅供参考)一、添加一个头文件Data.hData文件包含立方体数据：具体代码：double Vertex[8][3]={ {0,20,0},{30,20,0},{30,20,15},{0,2...
计算机图形学作业（ 三）：使用openGL画一个立方体，并实现平移、旋转和放缩变换
热门推荐
看门猫的博客
04-09 2万+
计算机图形学作业（ 三）：使用openGL画一个立方体，并实现平移、旋转和放缩变换题目引入GLM库画立方体模型、观察和投影 题目 引入GLM库 利用openGL进行3D绘图需要用到大量的数学矩阵运算，而OpenGL没有自带任何的矩阵和向量知识，需要我们自己定义数学类和函数，这相对比较麻烦。所以我们需要引入GLM库，GLM能快速帮助我们实现各种数学矩阵运算。 前往GLM官方github仓库，选择0...
计算机图形学实验-三维变换
weixin_54372988的博客
12-03 3576
第一步：创建三维正方体 创建新类CP3，该类中有三个变量x、y、z，一个变量w，用来进行矩阵运算，一个带参构造函数，用来传入三维点。 CP2类也要创建一下。 在CView类中新建CP3类型的变量V，表示一个数组。 double类型的k，表示数组用来代替三角函数，算出视点坐标。 double类型的D和R，分别是视距和视镜。 Phi和Theta，分别是与z轴的偏转角和与y轴的偏转角，可以任意设值。 将它们在构造函数中初始化。 全都初始化之后： CMy1202View::CMy1202View() { //
svg画一个宽100长200的立方体展开图形
最新发布
09-19
如果要用 SVG 画一个宽 100 长 200 的立方体展开图形，可以这样做: 1. 在 SVG 元素中定义一个尺寸为 100x200 的矩形。 2. 在矩形的左上角画一条长度为 100 的直线，代表立方体的一条边。 3. 在直线的右侧画一条长度为 200 的直线，代表立方体的另一条边。 4. 在这两条直线的交点处画一条长度为 100 的直线，代表立方体的顶部。 5. 在这个直线的底部画一条长度为 200 的直线，代表立方体的底部。 6. 在立方体的底部画一条长度为 100 的直线，代表立方体的前面。 7. 在立方体的底部画一条长度为 100 的直线，代表立方体的后面。 8. 在立方体的底部画一条长度为 100 的直线，代表立方体的左侧。 9. 在立方体的底部画一条长度为 100 的直线，代表立方体的右侧。 10. 将所有直线相互连接起来，就可以得到一个展开的立方体图形。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值