广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C++ OpenGL实现旋转立方体的绘制
  • 422

0
分享到

C++ OpenGL实现旋转立方体的绘制

2024-04-02 19:04:59 422人浏览 独家记忆
摘要

目录1、Z-缓冲2、GLM库函数3、PVM矩阵4、PVM矩阵的使用5、工程文件结构shader.hshader.cppmain.cpp 1、Z-缓冲 //开启深度测试

1、Z-缓冲

//开启深度测试
glEnable(GL_DEPTH_TEST);

2、GLM库函数

3、PVM矩阵

4、PVM矩阵的使用

我们需要引入GLM函数库的头文件：

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

设置vew矩阵的相关参数：

//相机参数
glm::vec3 camera_position = glm::vec3(0.0f, 0.0f, 3.0f);     //摄像机位置
glm::vec3 camera_front = glm::vec3(0.0f, 0.0f, -1.0f);       //摄像机方向
glm::vec3 camera_up = glm::vec3(0.0f, 1.0f, 0.0f);           //摄像机上向量

设置project矩阵视野fov：

float fov = 45.0f;

// Transform坐标变换矩阵
		glm::mat4 model(1);//model矩阵，局部坐标变换至世界坐标
		model = glm::translate(model, glm::vec3(0.0,0.0,0.0));
		model = glm::rotate(model, (float)glfwGetTime(), glm::vec3(0.5f, 1.0f, 0.0f));
		model = glm::scale(model, glm::vec3(1.0f,1.0f,1.0f));

glm::mat4 view(1);//view矩阵，世界坐标变换至观察坐标系
		view = glm::lookAt(camera_position, camera_position + camera_front, camera_up);

glm::mat4 projection(1);//projection矩阵，投影矩阵
		projection = glm::perspective(glm::radians(fov), (float)screen_width / screen_height, 0.1f, 100.0f);

int model_location = glGetUniformLocation(shader.ID, "model"); //获取着色器内某个参数的位置
		

glUniformMatrix4fv(model_location, 1, GL_FALSE, glm::value_ptr(model));//写入参数值

gl_Position=projection*view*model*vec4(aPos,1.0);

5、工程文件结构

shader.h

#ifndef __SHADER_H__
#define __SHADER_H__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class Shader
{
public:
	unsigned int ID;
 
	Shader(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path);
	~Shader();
 
	void Use();
	void SetBool(const std::string &name, bool value) const;
	void SetInt(const std::string &name, int value) const;
	void SetFloat(const std::string &name, float value) const;
	void SetVec2(const std::string &name, const glm::vec2 &value) const;
	void SetVec2(const std::string &name, float x, float y) const;
	void SetVec3(const std::string &name, const glm::vec3 &value) const;
	void SetVec3(const std::string &name, float x, float y, float z) const;
	void SetVec4(const std::string &name, const glm::vec4 &value) const;
	void SetVec4(const std::string &name, float x, float y, float z, float w) const;
	void SetMat2(const std::string &name, const glm::mat2 &value) const;
	void SetMat3(const std::string &name, const glm::mat3 &value) const;
	void SetMat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int GetShaderFromFile(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int LinkShader(const char* vertex_shader_code, const char* fragment_shader_code);
	int GetUniform(const std::string &name) const;
	void CheckCompileErrors(GLuint shader, std::string type);
};
 
#endif // !__SHADER_H__
#ifndef __SHADER_H__
#define __SHADER_H__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class Shader
{
public:
	unsigned int ID;
 
	Shader(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path);
	~Shader();
 
	void Use();
	void SetBool(const std::string &name, bool value) const;
	void SetInt(const std::string &name, int value) const;
	void SetFloat(const std::string &name, float value) const;
	void SetVec2(const std::string &name, const glm::vec2 &value) const;
	void SetVec2(const std::string &name, float x, float y) const;
	void SetVec3(const std::string &name, const glm::vec3 &value) const;
	void SetVec3(const std::string &name, float x, float y, float z) const;
	void SetVec4(const std::string &name, const glm::vec4 &value) const;
	void SetVec4(const std::string &name, float x, float y, float z, float w) const;
	void SetMat2(const std::string &name, const glm::mat2 &value) const;
	void SetMat3(const std::string &name, const glm::mat3 &value) const;
	void SetMat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int GetShaderFromFile(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int LinkShader(const char* vertex_shader_code, const char* fragment_shader_code);
	int GetUniform(const std::string &name) const;
	void CheckCompileErrors(GLuint shader, std::string type);
};
 
#endif // !__SHADER_H__
#ifndef __SHADER_H__
#define __SHADER_H__
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "string"
 
class Shader
{
public:
	unsigned int ID;
 
	Shader(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path);
	~Shader();
 
	void Use();
	void SetBool(const std::string &name, bool value) const;
	void SetInt(const std::string &name, int value) const;
	void SetFloat(const std::string &name, float value) const;
	void SetVec2(const std::string &name, const glm::vec2 &value) const;
	void SetVec2(const std::string &name, float x, float y) const;
	void SetVec3(const std::string &name, const glm::vec3 &value) const;
	void SetVec3(const std::string &name, float x, float y, float z) const;
	void SetVec4(const std::string &name, const glm::vec4 &value) const;
	void SetVec4(const std::string &name, float x, float y, float z, float w) const;
	void SetMat2(const std::string &name, const glm::mat2 &value) const;
	void SetMat3(const std::string &name, const glm::mat3 &value) const;
	void SetMat4(const std::string &name, const glm::mat4 &value) const;
 
private:
	int GetShaderFromFile(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path,
		std::string *vertex_shader_code, std::string *fragment_shader_code);
	int LinkShader(const char* vertex_shader_code, const char* fragment_shader_code);
	int GetUniform(const std::string &name) const;
	void CheckCompileErrors(GLuint shader, std::string type);
};
 
#endif // !__SHADER_H__

shader.cpp

#include "Shader.h"
#include "fstream"
#include "sstream"
#include "iOStream"
 
Shader::Shader(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path)
{
	std::string vertex_shader_code;
	std::string fragment_shader_code;
	if (GetShaderFromFile(vertex_shader_path, fragment_shader_path, &vertex_shader_code, &fragment_shader_code))
	{
		return;
	}
	if (LinkShader(vertex_shader_code.c_str(), fragment_shader_code.c_str()))
	{
		return;
	}
}
 
Shader::~Shader()
{
 
}
 
void Shader::Use()
{
	glUseProgram(ID);
}
 
void Shader::SetBool(const std::string &name, bool value) const
{
	SetInt(name, (int)value);
}
 
void Shader::SetInt(const std::string &name, int value) const
{
	glUniform1i(GetUniform(name), value);
}
 
void Shader::SetFloat(const std::string &name, float value) const
{
	glUniform1f(GetUniform(name), value);
}
 
void Shader::SetVec2(const std::string &name, float x, float y) const
{
	glUniform2f(GetUniform(name), x, y);
}
 
void Shader::SetVec2(const std::string &name, const glm::vec2 &value) const
{
	SetVec2(name, value.x, value.y);
}
 
void Shader::SetVec3(const std::string &name, float x, float y, float z) const
{
	glUniform3f(GetUniform(name), x, y, z);
}
 
void Shader::SetVec3(const std::string &name, const glm::vec3 &value) const
{
	SetVec3(name, value.x, value.y, value.z);
}
 
void Shader::SetVec4(const std::string &name, float x, float y, float z, float w) const
{
	glUniform4f(GetUniform(name), x, y, z, w);
}
 
void Shader::SetVec4(const std::string &name, const glm::vec4 &value) const
{
	SetVec4(name, value.x, value.y, value.z, value.w);
}
 
void Shader::SetMat2(const std::string &name, const glm::mat2 &value) const
{
	glUniformMatrix2fv(GetUniform(name), 1, GL_FALSE, &value[0][0]);
}
 
void Shader::SetMat3(const std::string &name, const glm::mat3 &value) const
{
	glUniformMatrix3fv(GetUniform(name), 1, GL_FALSE, &value[0][0]);
}
 
void Shader::SetMat4(const std::string &name, const glm::mat4 &value) const
{
	glUniformMatrix4fv(GetUniform(name), 1, GL_FALSE, &value[0][0]);
}
 
int Shader::GetShaderFromFile(const GLchar* vertex_shader_path, const GLchar* fragment_shader_path, std::string *vertex_shader_code, std::string *fragment_shader_code)
{
	std::ifstream vertex_shader_file;
	std::ifstream fragment_shader_file;
	vertex_shader_file.exceptions(std::ifstream::badbit | std::ifstream::failbit);
	fragment_shader_file.exceptions(std::ifstream::badbit | std::ifstream::failbit);
	try
	{
		vertex_shader_file.open(vertex_shader_path);
		fragment_shader_file.open(fragment_shader_path);
		std::stringstream vertex_shader_stream, fragment_shader_stream;
		vertex_shader_stream << vertex_shader_file.rdbuf();
		fragment_shader_stream << fragment_shader_file.rdbuf();
		vertex_shader_file.close();
		fragment_shader_file.close();
		*vertex_shader_code = vertex_shader_stream.str();
		*fragment_shader_code = fragment_shader_stream.str();
	}
	catch (std::ifstream::failure e)
	{
		std::cout << "Load Shader File Error!" << std::endl;
		return -1;
	}
	return 0;
}
 
int Shader::LinkShader(const char* vertex_shader_code, const char* fragment_shader_code)
{
	int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertex_shader, 1, &vertex_shader_code, NULL);
	glCompileShader(vertex_shader);
	CheckCompileErrors(vertex_shader, "VERTEX");
 
	int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment_shader, 1, &fragment_shader_code, NULL);
	glCompileShader(fragment_shader);
	CheckCompileErrors(fragment_shader, "FRAGMENT");
 
	this->ID = glCreateProgram();
	glAttachShader(ID, vertex_shader);
	glAttachShader(ID, fragment_shader);
	glLinkProgram(ID);
	CheckCompileErrors(ID, "PROGRAM");
 
	glDeleteShader(vertex_shader);
	glDeleteShader(fragment_shader);
	return 0;
}
 
int Shader::GetUniform(const std::string &name) const
{
	int position = glGetUniformLocation(ID, name.c_str());
	if (position == -1)
	{
		std::cout << "uniform " << name << " set failed!" << std::endl;
	}
	return position;
}
 
void Shader::CheckCompileErrors(GLuint shader, std::string type)
{
	GLint success;
	GLchar infoLog[512];
	if (type == "PROGRAM")
	{
		glGetProgramiv(shader, GL_LINK_STATUS, &success);
		if (!success)
		{
			glGetProgramInfoLog(shader, 512, NULL, infoLog);
			std::cout << "ERROR::PROGRAM_LINKING_ERROR!\n" << infoLog << std::endl;
		}
	}
	else
	{
		glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glGetShaderInfoLog(shader, 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::" << type << "::COMPILATION_FAILED\n" << infoLog << std::endl;
		}
	}
}

main.cpp 

//总体流程
//1. 初始化并创建窗口
//2. 加载立方体顶点VAOVBO以及着色器并开启深度测试
//3. 进入主循环清除缓冲
//4. 使用立方体着色器，构造并传入pvm矩阵，绘制
//5. 循环结束，释放VAOVBO
 
#include <iostream>
#include "glad/glad.h"
#include "GLFW/glfw3.h"
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "glm/gtc/type_ptr.hpp"
 
#include "shader.h"
 
const float vertices[] = {                  //立方体数组
	-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,
	-0.5f, -0.5f, -0.5f,  1.0f,0.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,
	-0.5f, -0.5f,  0.5f,  0.0f,1.0f,0.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,
	-0.5f,  0.5f,  0.5f,  0.0f,0.0f,1.0f,
 
	0.5f,  0.5f,  0.5f,  0.5f,0.0f,0.0f,
	0.5f,  0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f, -0.5f,  0.5f,0.0f,0.0f,
	0.5f, -0.5f,  0.5f,  0.5f,0.0f,0.0f,
	0.5f,  0.5f,  0.5f,  0.5f,0.0f,0.0f,
 
	-0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	-0.5f, -0.5f,  0.5f,  0.0f,0.5f,0.0f,
	-0.5f, -0.5f, -0.5f,  0.0f,0.5f,0.0f,
 
	-0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	-0.5f,  0.5f,  0.5f,  0.0f,0.0f,0.5f,
	-0.5f,  0.5f, -0.5f,  0.0f,0.0f,0.5f
};
 
float screen_width = 1280.0f;          //窗口宽度
float screen_height = 720.0f;          //窗口高度
//相机参数
glm::vec3 camera_position = glm::vec3(0.0f, 0.0f, 3.0f);     //摄像机位置
glm::vec3 camera_front = glm::vec3(0.0f, 0.0f, -1.0f);       //摄像机方向
glm::vec3 camera_up = glm::vec3(0.0f, 1.0f, 0.0f);           //摄像机上向量
//视野
float fov = 45.0f;
 
int main() {
	// 初始化GLFW
	glfwInit();                                                     // 初始化GLFW
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);                  // OpenGL版本为3.3，主次版本号均设为3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 使用核心模式(无需向后兼容性)
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // 如果使用的是Mac OS X系统，需加上这行
	glfwWindowHint(GLFW_RESIZABLE, FALSE);						    // 不可改变窗口大小
 
																	// 创建窗口(宽、高、窗口名称)
	auto window = glfwCreateWindow(screen_width, screen_height, "Cube", nullptr, nullptr);
	if (window == nullptr) {                                        // 如果窗口创建失败，输出Failed to Create OpenGL Context
		std::cout << "Failed to Create OpenGL Context" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);                                 // 将窗口的上下文设置为当前线程的主上下文
 
																	// 初始化GLAD，加载OpenGL函数指针地址的函数
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}
 
	// 指定当前视口尺寸(前两个参数为左下角位置，后两个参数是渲染窗口宽、高)
	glViewport(0, 0, screen_width, screen_height);
 
 
	Shader shader("res/shader/task-cube.vs", "res/shader/task-cube.fs");//加载着色器
 
	// 生成并绑定VAO和VBO
	GLuint vertex_array_object; // == VAO
	glGenVertexArrays(1, &vertex_array_object);
	glBindVertexArray(vertex_array_object);
 
	GLuint vertex_buffer_object; // == VBO
	glGenBuffers(1, &vertex_buffer_object);
	glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_object);
	// 将顶点数据绑定至当前默认的缓冲中
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
	// 设置顶点属性指针
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);
 
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(1);
 
 
	glEnable(GL_DEPTH_TEST);
	// Render loop主循环
	while (!glfwwindowshouldClose(window)) {
		//进入主循环，清理颜色缓冲深度缓冲
		glClearColor(0.0f, 0.34f, 0.57f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清理颜色缓冲和深度缓冲
 
		shader.Use();
 
		// Transform坐标变换矩阵
		glm::mat4 model(1);//model矩阵，局部坐标变换至世界坐标
		model = glm::translate(model, glm::vec3(0.0,0.0,0.0));
		model = glm::rotate(model, (float)glfwGetTime(), glm::vec3(0.5f, 1.0f, 0.0f));
		model = glm::scale(model, glm::vec3(1.0f,1.0f,1.0f));
		glm::mat4 view(1);//view矩阵，世界坐标变换至观察坐标系
		view = glm::lookAt(camera_position, camera_position + camera_front, camera_up);
		glm::mat4 projection(1);//projection矩阵，投影矩阵
		projection = glm::perspective(glm::radians(fov), (float)screen_width / screen_height, 0.1f, 100.0f);
 
		
		// 向着色器中传入参数
		int model_location = glGetUniformLocation(shader.ID, "model"); //获取着色器内某个参数的位置
		glUniformMatrix4fv(model_location, 1, GL_FALSE, glm::value_ptr(model));//写入参数值
		int view_location = glGetUniformLocation(shader.ID, "view");
		glUniformMatrix4fv(view_location, 1, GL_FALSE, glm::value_ptr(view));
		int projection_location = glGetUniformLocation(shader.ID, "projection");
		glUniformMatrix4fv(projection_location, 1, GL_FALSE, glm::value_ptr(projection));
		//绘制
		glBindVertexArray(vertex_array_object);
		glDrawArrays(GL_TRIANGLES, 0, 36);
		glBindVertexArray(0);
		
		
		glfwSwapBuffers(window);
		glfwPollEvents();
	}
	//释放VAOVBO
	glDeleteVertexArrays(1, &vertex_array_object);
	glDeleteBuffers(1, &vertex_buffer_object);
 
	// 清理所有的资源并正确退出程序
	glfwTerminate();
	return 0;
}

输出结果：

到此这篇关于c++ OpenGL实现旋转立方体的绘制的文章就介绍到这了,更多相关C++ OpenGL旋转立方体内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: C++ OpenGL实现旋转立方体的绘制

本文链接: https://www.lsjlt.com/news/165472.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • C++ OpenGL实现旋转立方体的绘制
    目录1、Z-缓冲2、GLM库函数3、PVM矩阵4、PVM矩阵的使用5、工程文件结构shader.hshader.cppmain.cpp 1、Z-缓冲 //开启深度测试 ...
    99+
    2022-11-13
  • CSS绘制奇幻效果：实现3D旋转立方体效果
    在Web开发中，我们常常需要使用CSS来实现各种奇幻的效果，而其中一个很受欢迎的效果就是3D旋转立方体效果。通过CSS的3D转换属性，我们可以很轻松地实现这一效果。下面，我将为大家详细介绍如何使用CSS来实现一个3D旋转立方体，并提供具体的...
    99+
    2023-10-21
    CSS 绘制 D旋转 立方体效果
  • C++ OpenGL实现球形的绘制
    目录1、封装Shader（1）为什么要封装Shader（2）如何使用2、绘制球模型（1）球面顶点遍历（2）构造三角形图元（3）开启线框模式（4）开启面剔除（5）最后1、封装Shade...
    99+
    2022-11-13
  • C++OpenGL实现三角形的绘制
    目录一、绘制三角形1、初始化2、顶点输入3、数据处理4、顶点着色器和片段着色器5、渲染二、完整代码代码输出修改尺寸修改三角形颜色修改背景颜色线框模式一、绘制三角形 1、初始化 （1）...
    99+
    2022-11-13
  • HTML5如何实现旋转立体魔方3D模型
    这篇文章给大家分享的是有关HTML5如何实现旋转立体魔方3D模型的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。下面是预览画面。制作流程首先你需要下载Html5开源库件lufyle...
    99+
    2022-10-19
  • HTML5+CSS3如何实现3D立方体旋转动画
    这篇文章将为大家详细讲解有关HTML5+CSS3如何实现3D立方体旋转动画，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。效果图：知识点：1、perspective ，tr...
    99+
    2022-10-19
  • 使用c++实现OpenCV绘制旋转矩形图形
    目录功能函数测试代码测试效果  功能函数 // 绘制旋转矩形 void DrawRotatedRect(cv::Mat mask,const cv::RotatedRe...
    99+
    2022-11-12
  • 利用C#实现绘制出地球旋转效果
    将方形的图像映射到正方形上似乎并没有什么难度，所以接下来要做的是把图像映射到球面上。 而球的参数方程为 x​=rcosϕcosθ y=rcosϕsinθ z=...
    99+
    2023-02-28
    C#实现地球旋转效果 C#地球旋转 C#地球
  • 基于JS实现简单的3D立方体自动旋转
    目录演示技术栈源码cssjs雪花部分演示 技术栈 display:inline-block，block，inline元素的区别: display：block将元素显示为块级元素，从...
    99+
    2022-11-13
  • css3怎么实现立方体旋转发光效果动图
    本篇内容介绍了“css3怎么实现立方体旋转发光效果动图”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！<...
    99+
    2022-10-19
  • 怎么利用C#实现绘制出地球旋转效果
    这篇文章主要介绍“怎么利用C#实现绘制出地球旋转效果”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“怎么利用C#实现绘制出地球旋转效果”文章能帮助大家解决问题。将方形的图像映射到正方形上似乎并没有什么...
    99+
    2023-07-05
  • C++实现旋转图像的方法
    这篇文章主要讲解了“C++实现旋转图像的方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C++实现旋转图像的方法”吧！Rotate Image 旋转图像You are given an&n...
    99+
    2023-06-20
  • 怎么用HTML5 transform三维立方体实现三维旋转效果
    本篇内容主要讲解“怎么用HTML5 transform三维立方体实现三维旋转效果”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“怎么用HTML5 transfor...
    99+
    2022-10-19
  • 使用Echart实现绘制立体的柱状图
    效果图： 实现代码： var xData3 = ["6", "7", "8", "9","10","11"]; var data3 = [1209, 1715, 2408,...
    99+
    2022-11-13
  • Matlab实现绘制立体玫瑰花的示例代码
    目录基础绘制坐标区域修饰配色旋转又是一年情人节，今年带来一款更有立体感的玫瑰： 曲面的函数表达式来自:http://www.bugman123.com/Math/index.htm...
    99+
    2023-02-16
    Matlab绘制立体玫瑰花 Matlab立体玫瑰花 Matlab玫瑰花
  • css3 transform及原生js实现鼠标拖动3D立方体旋转的示例分析
    这篇文章将为大家详细讲解有关css3 transform及原生js实现鼠标拖动3D立方体旋转的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。js的作用是什么1、能够嵌入动态文本于HTML页面。2、...
    99+
    2023-06-08
  • 如何通过纯CSS实现图片的3D立体旋转效果的方法和技巧
    如何通过纯CSS实现图片的3D立体旋转效果的方法和技巧，需要具体代码示例随着Web技术的发展，我们可以通过CSS实现各种令人惊叹的效果，其中包括图片的3D立体旋转效果。本文将介绍如何通过纯CSS实现这样的效果，并提供具体的代码示例，帮助读者...
    99+
    2023-10-24
    图片 旋转 纯CSS
  • 基于Echarts实现绘制立体柱状图的示例代码
    目录前言实现方法先写一个常规的柱状图echarts的配置选项效果图前言 大家好，我是梁木由。之前在做大屏可视化项目时，UI设计了一个立体形状的柱状图，根据之前做的一些图表的项目没有能...
    99+
    2023-02-23
    Echarts绘制立体柱状图 Echarts立体柱状图 Echarts柱状图
  • C++sdl实现渲染旋转视频的方法分享
    目录前言一、如何实现1、计算边框大小2、计算缩放大小3、逆运算视频宽高二、完整代码三、使用示例总结前言 一般情况下播放视频时不需要旋转，但是如果是移动端录制的视频有时会出现rotat...
    99+
    2022-12-16
    sdl 渲染旋转视频 sdl 渲染视频 sdl 旋转视频 sdl 视频
  • C++实现寻找旋转有序数组的最小值的方法
    本篇内容介绍了“C++实现寻找旋转有序数组的最小值的方法”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！寻找旋转有序数组的最小值Suppose...
    99+
    2023-06-20
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作