openg魔方

已于 2023-12-23 15:37:56 修改
阅读量445 收藏 9
点赞数 7
文章标签： 着色器
于 2023-12-23 15:36:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44637298/article/details/135169640
版权

只完成了4个面，剩下2面
代码

OpenGL 魔方

#pragma once
#include <glad/glad.h>

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

#include <vector>
#include <Class/Shader/Shader.h>

namespace CubeN {

	// 定义一个枚举类型，表示方向。其中FRONT表示前，BACK表示后，UP表示上，DOWN表示下，LEFT表示左，RIGHT表示右
	enum Direction {
		FRONT, // 前
		BACK,  // 后
		UP,    // 上
		DOWN,  // 下
		LEFT,  // 左
		RIGHT  // 右
	};

	// 定义一个结构体，表示魔方的颜色。其中front表示前面的颜色，back表示后面的颜色，up表示上面的颜色，down表示下面的颜色，left表示左边的颜色，right表示右边的颜色
	static struct MagicCubeColor
	{
		glm::vec3 front = glm::vec3(1.0f, 1.0f, 1.0f); // 前面的颜色为白色
		glm::vec3 back = glm::vec3(1.0f, 0.0f, 0.0f);  // 后面的颜色为红色
		glm::vec3 up = glm::vec3(1.0f, 1.0f, 0.0f);     // 上面的颜色为黄色
		glm::vec3 down = glm::vec3(0.0f, 1.0f, 0.0f);   // 下面的颜色为绿色
		glm::vec3 left = glm::vec3(0.0f, 0.0f, 1.0f);   // 左边的颜色为蓝色
		glm::vec3 right = glm::vec3(0.83f, 0.0f, 1.0f);  // 右边的颜色为紫色
	};

	// 定义一个结构体，表示魔方的位置和顶点属性。其中VAO表示顶点属性对象，VBO表示顶点缓冲对象，position表示魔方的位置
	struct MagicCubeStruct
	{
		unsigned int VAO, VBO;
		int count;
		Direction direction[3];
		bool isRotating = false;
		glm::vec3 color[3];
		glm::vec3 position;
	};

	struct MagicCubeStructInd {
		float front[9];
		float back[9];

		float up[9];
		float down[9];

		float left[9];
		float right[9];
	};

	class MagicCube
	{
	private:
		float* PCube;
		int CubeSize;
		float Cube[216] = {
			// 前面
			 1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			-1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			-1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			-1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 // 后面
			 -1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,

			 // 上面
			 -1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,

			 // 下面
			 -1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			  1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,

			 // 左面
			 -1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 -1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,

			 // 右面
			 1.0f, -1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f, -1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f,  1.0f,  1.0f, 0.5f, 0.5f, 0.5f,
			 1.0f,  1.0f, -1.0f, 0.5f, 0.5f, 0.5f
		};
		float deltaTime;
		// 上一帧的时间
		float lastFrame;
		// 移动速度
		float speed;
		// 要旋转的面
		float* TheToRotate;
		// 旋转方向
		float rotDir = 1.0;
		// 旋转角度
		float angle;
		// 旋转向量
		glm::vec3 angleVec;
		// 创建魔方的骨架
		void Skeleton();
		// 创建魔方的上面部分
		void CreateUpper();
		// 创建魔方的中心部分
		void CreateCentre();
		// 创建魔方的下面部分
		void CreateBelow();
		// 修改魔方的面的颜色
		void ModifyCubeColor(Direction* direction, MagicCubeStruct& mcf, int count);
		// 设置魔方的网格数据
		void setupMesh(MagicCubeStruct& mcf);
		// 根据给定的方向，返回相应的颜色。
		glm::vec3 ReturnColor(Direction direction);
		// 根据给定的方向，返回相应的面
		float* ReturnFace(Direction direction);
		// 重新渲染
		void ReRendering();
		// 销毁 vao vbo
		void DeleteVertexData();
		// 是否旋转
		void IsRotating(bool rotating);
	public:
		// 魔方的颜色属性
		MagicCubeColor color;
		// 存放魔方各个位置的结构体数组
		std::vector<MagicCubeStruct> CubePos;
		MagicCubeStructInd CubeInd;
		// 初始化魔方的方法
		void MagicCubeInit();
		// 旋转
		void rotate(Direction direction);
		void Draw(Shader& shader, double currentTime);
		// 销毁
		void DeleteCube();
	};
}

#include "MagicCube.h"
namespace CubeN {

	void MagicCube::Skeleton()
	{
		MagicCubeStruct mcf;
		mcf.count = 1;
		// 后面
		mcf.direction[0] = BACK;
		mcf.color[0] = ReturnColor(BACK);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(0.0f, 0.0f, -2.0f);
		CubePos.push_back(mcf); // 0
		// 前面
		mcf.direction[0] = FRONT;
		mcf.color[0] = ReturnColor(FRONT);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(0.0f, 0.0f, 2.0f);
		CubePos.push_back(mcf); // 1
		// 上面
		mcf.direction[0] = UP;
		mcf.color[0] = ReturnColor(UP);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(0.0f, 2.0f, 0.0f);
		CubePos.push_back(mcf);// 2
		// 下面
		mcf.direction[0] = DOWN;
		mcf.color[0] = ReturnColor(DOWN);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(0.0f, -2.0f, 0.0f);
		CubePos.push_back(mcf);// 3
		// 左面
		mcf.direction[0] = LEFT;
		mcf.color[0] = ReturnColor(LEFT);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(-2.0f, 0.0f, 0.0f);
		CubePos.push_back(mcf);// 4
		// 右面
		mcf.direction[0] = RIGHT;
		mcf.color[0] = ReturnColor(RIGHT);
		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		mcf.position = glm::vec3(2.0f, 0.0f, 0.0f);
		CubePos.push_back(mcf);// 5
	}

	void MagicCube::CreateUpper()
	{
		MagicCubeStruct mcf;
		mcf.count = 3;
		// 左前
		mcf.position = glm::vec3(-2.0f, 2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = LEFT; // 左
		mcf.direction[2] = UP; // 上

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(LEFT);
		mcf.color[2] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 6

		// 左后
		mcf.position = glm::vec3(-2.0f, 2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = LEFT; // 左
		mcf.direction[2] = UP; // 上

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(LEFT);
		mcf.color[2] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 7

		// 右前
		mcf.position = glm::vec3(2.0f, 2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = RIGHT; // 右
		mcf.direction[2] = UP; // 上

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(RIGHT);
		mcf.color[2] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 8

		// 右后
		mcf.position = glm::vec3(2.0f, 2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = RIGHT; // 右
		mcf.direction[2] = UP; // 上

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(RIGHT);
		mcf.color[2] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 9

		mcf.count = 2;
		// 前中
		mcf.position = glm::vec3(0.0f, 2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = UP; // 上

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 10

		// 右中
		mcf.position = glm::vec3(2.0f, 2.0f, 0.0f);
		mcf.direction[0] = RIGHT; // 右
		mcf.direction[1] = UP; // 上

		mcf.color[0] = ReturnColor(RIGHT);
		mcf.color[1] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 11

		// 后中
		mcf.position = glm::vec3(0.0f, 2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = UP; // 上

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 12

		// 左中
		mcf.position = glm::vec3(-2.0f, 2.0f, 0.0f);
		mcf.direction[0] = LEFT; // 左
		mcf.direction[1] = UP; // 上

		mcf.color[0] = ReturnColor(LEFT);
		mcf.color[1] = ReturnColor(UP);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 13
	}

	void MagicCube::CreateCentre()
	{
		MagicCubeStruct mcf;
		mcf.count = 2;

		// 左前
		mcf.position = glm::vec3(-2.0f, 0.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = LEFT; // 左

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(LEFT);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 14

		// 右前
		mcf.position = glm::vec3(2.0f, 0.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = RIGHT; // 右

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(RIGHT);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);

		CubePos.push_back(mcf); // 15

		// 右后
		mcf.position = glm::vec3(2.0f, 0.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = RIGHT; // 右

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(RIGHT);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 16

		// 左后
		mcf.position = glm::vec3(-2.0f, 0.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = LEFT; // 左

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(LEFT);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 17
	}

	void MagicCube::CreateBelow()
	{
		MagicCubeStruct mcf;
		mcf.count = 3;

		// 左前
		mcf.position = glm::vec3(-2.0f, -2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = LEFT; // 左
		mcf.direction[2] = DOWN; // 下

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(LEFT);
		mcf.color[2] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 18

		// 左后
		mcf.position = glm::vec3(-2.0f, -2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = LEFT; // 左
		mcf.direction[2] = DOWN; // 下

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(LEFT);
		mcf.color[2] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 19

		// 右前
		mcf.position = glm::vec3(2.0f, -2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = RIGHT; // 右
		mcf.direction[2] = DOWN; // 下

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(RIGHT);
		mcf.color[2] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 20

		// 右后
		mcf.position = glm::vec3(2.0f, -2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = RIGHT; // 右
		mcf.direction[2] = DOWN; // 下

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(RIGHT);
		mcf.color[2] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 21

		mcf.count = 2;

		// 前中
		mcf.position = glm::vec3(0.0f, -2.0f, 2.0f);
		mcf.direction[0] = FRONT; // 前
		mcf.direction[1] = DOWN; // 下

		mcf.color[0] = ReturnColor(FRONT);
		mcf.color[1] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 22

		// 右中
		mcf.position = glm::vec3(2.0f, -2.0f, 0.0f);
		mcf.direction[0] = RIGHT; // 右
		mcf.direction[1] = DOWN; // 下

		mcf.color[0] = ReturnColor(RIGHT);
		mcf.color[1] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 23

		// 后中
		mcf.position = glm::vec3(0.0f, -2.0f, -2.0f);
		mcf.direction[0] = BACK; // 后
		mcf.direction[1] = DOWN; // 下

		mcf.color[0] = ReturnColor(BACK);
		mcf.color[1] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 24

		// 左中
		mcf.position = glm::vec3(-2.0f, -2.0f, 0.0f);
		mcf.direction[0] = LEFT; // 左
		mcf.direction[1] = DOWN; // 下

		mcf.color[0] = ReturnColor(LEFT);
		mcf.color[1] = ReturnColor(DOWN);

		ModifyCubeColor(mcf.direction, mcf, mcf.count);
		CubePos.push_back(mcf); // 25
	}

	void MagicCube::ModifyCubeColor(Direction* direction, MagicCubeStruct& mcf, int count)
	{
		// 获取立方体
		memmove(PCube, Cube, CubeSize);
		for (int i = 0; i < count; i++) {
			// 获取颜色
			glm::vec3 CubeColor = mcf.color[i];

			// 修改颜色
			int start = direction[i] * 6;
			int end = start + 6;
			for (int i = start; i < end; i++)
			{
				PCube[i * 6 + 3] = CubeColor.x;
				PCube[i * 6 + 4] = CubeColor.y;
				PCube[i * 6 + 5] = CubeColor.z;
			}
		}
		setupMesh(mcf);
	}

	void MagicCube::setupMesh(MagicCubeStruct& mcf)
	{
		// 创建 vao 
		glGenVertexArrays(1, &mcf.VAO);
		// 创建 vbo
		glGenBuffers(1, &mcf.VBO);

		// 绑定 vao
		glBindVertexArray(mcf.VAO);

		// 把顶点数据绑定到 vbo
		glBindBuffer(GL_ARRAY_BUFFER, mcf.VBO);
		glBufferData(GL_ARRAY_BUFFER, CubeSize, PCube, 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*)(sizeof(float) * 3));
		glEnableVertexAttribArray(1);

		// 解绑
		glBindVertexArray(0);
	}

	glm::vec3 MagicCube::ReturnColor(Direction direction)
	{
		switch (direction) {
		case FRONT:
			return color.front;
		case BACK:
			return color.back;
		case UP:
			return color.up;
		case DOWN:
			return color.down;
		case LEFT:
			return color.left;
		case RIGHT:
			return color.right;
		default:
			return glm::vec3(0.0f);
		}
	}

	float* MagicCube::ReturnFace(Direction direction)
	{
		switch (direction) {
		case FRONT:
			return CubeInd.front;
		case BACK:
			return CubeInd.back;
		case UP:
			return CubeInd.up;
		case DOWN:
			return CubeInd.down;
		case LEFT:
			return CubeInd.left;
		case RIGHT:
			return CubeInd.right;
		default:
			exit(EXIT_FAILURE);
		}
	}

	void MagicCube::ReRendering()
	{
		DeleteVertexData();
		for (auto& mcf : CubePos)
		{
			ModifyCubeColor(mcf.direction, mcf, mcf.count);
		}
	}

	void MagicCube::DeleteVertexData()
	{
		for (const auto& mcf : CubePos)
		{
			glDeleteVertexArrays(1, &mcf.VAO);
			glDeleteBuffers(1, &mcf.VBO);
		}
	}

	void MagicCube::IsRotating(bool rotating)
	{
		for (int i = 0; i < 9; i++)
		{
			CubePos[TheToRotate[i]].isRotating = rotating;
		}
		if (!rotating) TheToRotate = nullptr;
	}

	void MagicCube::MagicCubeInit()
	{
		PCube = new float[256];
		angle = 0;
		TheToRotate = nullptr;
		CubeSize = 216 * sizeof(float);
		speed = 0.005;

		Skeleton();
		CreateUpper();
		CreateCentre();
		CreateBelow();

		// ----------------------- 前 -----------------------
		// 左 中 右（第一排）
		CubeInd.front[0] = 6;
		CubeInd.front[1] = 10;
		CubeInd.front[2] = 8;

		// 左 右（第二排）
		CubeInd.front[3] = 14;
		CubeInd.front[4] = 15;

		// 左 中 右（第三排）
		CubeInd.front[5] = 18;
		CubeInd.front[6] = 22;
		CubeInd.front[7] = 20;

		// ----------------------- 后 -----------------------
		// 左 中 右（第一排）
		CubeInd.back[0] = 7;
		CubeInd.back[1] = 12;
		CubeInd.back[2] = 9;

		// 左 右（第二排）
		CubeInd.back[3] = 16;
		CubeInd.back[4] = 17;

		// 左 中 右（第三排）
		CubeInd.back[5] = 19;
		CubeInd.back[6] = 24;
		CubeInd.back[7] = 21;

		// ----------------------- 上 -----------------------
		// 左 中 右（第一排）
		CubeInd.up[0] = 7;
		CubeInd.up[1] = 12;
		CubeInd.up[2] = 9;

		// 左 右（第二排）
		CubeInd.up[3] = 13;
		CubeInd.up[4] = 11;

		// 左 中 右（第三排）
		CubeInd.up[5] = 6;
		CubeInd.up[6] = 10;
		CubeInd.up[7] = 8;

		// ----------------------- 下 -----------------------
		// 左 中 右（第一排）
		CubeInd.down[0] = 18;
		CubeInd.down[1] = 22;
		CubeInd.down[2] = 20;

		// 左 右（第二排）
		CubeInd.down[3] = 25;
		CubeInd.down[4] = 23;

		// 左 中 右（第三排）
		CubeInd.down[5] = 19;
		CubeInd.down[6] = 24;
		CubeInd.down[7] = 21;

		// ----------------------- 左 -----------------------
		// 左 中 右（第一排）
		CubeInd.left[0] = 7;
		CubeInd.left[1] = 13;
		CubeInd.left[2] = 6;

		// 左 右（第二排）
		CubeInd.left[3] = 17;
		CubeInd.left[4] = 14;

		// 左 中 右（第三排）
		CubeInd.left[5] = 19;
		CubeInd.left[6] = 25;
		CubeInd.left[7] = 18;

		// ----------------------- 右 -----------------------
		// 左 中 右（第一排）
		CubeInd.right[0] = 8;
		CubeInd.right[1] = 11;
		CubeInd.right[2] = 9;

		// 左 右（第二排）
		CubeInd.right[3] = 15;
		CubeInd.right[4] = 16;

		// 左 中 右（第三排）
		CubeInd.right[5] = 20;
		CubeInd.right[6] = 23;
		CubeInd.right[7] = 21;


		// ----------------------- 中 -----------------------
		CubeInd.front[8] = 1;
		CubeInd.back[8] = 0;

		CubeInd.left[8] = 4;
		CubeInd.right[8] = 5;

		CubeInd.up[8] = 2;
		CubeInd.down[8] = 3;
	}

	void MagicCube::rotate(Direction direction)
	{
		if (TheToRotate != nullptr) return;
		// 受影响的面有 上 左 下 右
		TheToRotate = ReturnFace(direction);
		IsRotating(true);
		// 前
		if (direction == FRONT) {
			// 旋转轴
			angleVec = glm::vec3(0.0f, 0.0f, 1.0f);

			glm::vec3 vec1 = CubePos[CubeInd.up[5]].color[2];
			glm::vec3 vec2 = CubePos[CubeInd.up[6]].color[1];
			glm::vec3 vec3 = CubePos[CubeInd.up[7]].color[2];

			// 上
			CubePos[CubeInd.up[5]].color[2] = CubePos[CubeInd.right[0]].color[1];
			CubePos[CubeInd.up[6]].color[1] = CubePos[CubeInd.right[3]].color[1];
			CubePos[CubeInd.up[7]].color[2] = CubePos[CubeInd.right[5]].color[1];

			// 右
			CubePos[CubeInd.right[0]].color[1] = CubePos[CubeInd.down[2]].color[2];
			CubePos[CubeInd.right[3]].color[1] = CubePos[CubeInd.down[1]].color[1];
			CubePos[CubeInd.right[5]].color[1] = CubePos[CubeInd.down[0]].color[2];

			// 下
			CubePos[CubeInd.down[0]].color[2] = CubePos[CubeInd.left[2]].color[1];
			CubePos[CubeInd.down[1]].color[1] = CubePos[CubeInd.left[4]].color[1];
			CubePos[CubeInd.down[2]].color[2] = CubePos[CubeInd.left[7]].color[1];

			// 左
			CubePos[CubeInd.left[2]].color[1] = vec3;
			CubePos[CubeInd.left[4]].color[1] = vec2;
			CubePos[CubeInd.left[7]].color[1] = vec1;

			// 前
			vec1 = CubePos[CubeInd.front[0]].color[0];
			vec2 = CubePos[CubeInd.front[1]].color[0];
			vec3 = CubePos[CubeInd.front[2]].color[0];

			CubePos[CubeInd.front[0]].color[0] = CubePos[CubeInd.front[2]].color[0];
			CubePos[CubeInd.front[1]].color[0] = CubePos[CubeInd.front[4]].color[0];
			CubePos[CubeInd.front[2]].color[0] = CubePos[CubeInd.front[7]].color[0];

			CubePos[CubeInd.front[2]].color[0] = CubePos[CubeInd.front[7]].color[0];
			CubePos[CubeInd.front[4]].color[0] = CubePos[CubeInd.front[6]].color[0];
			CubePos[CubeInd.front[7]].color[0] = CubePos[CubeInd.front[5]].color[0];

			CubePos[CubeInd.front[7]].color[0] = CubePos[CubeInd.front[5]].color[0];
			CubePos[CubeInd.front[5]].color[0] = CubePos[CubeInd.front[0]].color[0];
			CubePos[CubeInd.front[6]].color[0] = CubePos[CubeInd.front[3]].color[0];

			CubePos[CubeInd.front[0]].color[0] = vec3;
			CubePos[CubeInd.front[3]].color[0] = vec2;
			CubePos[CubeInd.front[5]].color[0] = vec1;
		}
		// 右
		else if (direction == RIGHT) {
			// 旋转轴
			angleVec = glm::vec3(1.0f, 0.0f, 0.0f);

			glm::vec3 vec1 = CubePos[CubeInd.right[0]].color[2];
			glm::vec3 vec2 = CubePos[CubeInd.right[1]].color[1];
			glm::vec3 vec3 = CubePos[CubeInd.right[2]].color[2];

			// 上
			CubePos[CubeInd.right[0]].color[2] = CubePos[CubeInd.back[2]].color[0];
			CubePos[CubeInd.right[1]].color[1] = CubePos[CubeInd.back[3]].color[0];
			CubePos[CubeInd.right[2]].color[2] = CubePos[CubeInd.back[7]].color[0];

			// 右
			CubePos[CubeInd.back[2]].color[0] = CubePos[CubeInd.down[7]].color[2];
			CubePos[CubeInd.back[3]].color[0] = CubePos[CubeInd.down[4]].color[1];
			CubePos[CubeInd.back[7]].color[0] = CubePos[CubeInd.down[2]].color[2];

			// 下
			CubePos[CubeInd.down[2]].color[2] = CubePos[CubeInd.front[2]].color[0];
			CubePos[CubeInd.down[4]].color[1] = CubePos[CubeInd.front[4]].color[0];
			CubePos[CubeInd.down[7]].color[2] = CubePos[CubeInd.front[7]].color[0];

			// 左
			CubePos[CubeInd.front[2]].color[0] = vec3;
			CubePos[CubeInd.front[4]].color[0] = vec2;
			CubePos[CubeInd.front[7]].color[0] = vec1;

			// 右
			vec1 = CubePos[CubeInd.right[0]].color[1];
			vec2 = CubePos[CubeInd.right[1]].color[0];
			vec3 = CubePos[CubeInd.right[2]].color[1];

			CubePos[CubeInd.right[0]].color[1] = CubePos[CubeInd.right[2]].color[1];
			CubePos[CubeInd.right[1]].color[0] = CubePos[CubeInd.right[4]].color[1];
			CubePos[CubeInd.right[2]].color[1] = CubePos[CubeInd.right[7]].color[1];

			CubePos[CubeInd.right[2]].color[1] = CubePos[CubeInd.right[7]].color[1];
			CubePos[CubeInd.right[4]].color[1] = CubePos[CubeInd.right[6]].color[0];
			CubePos[CubeInd.right[7]].color[1] = CubePos[CubeInd.right[5]].color[1];

			CubePos[CubeInd.right[7]].color[1] = CubePos[CubeInd.right[5]].color[1];
			CubePos[CubeInd.right[5]].color[1] = CubePos[CubeInd.right[0]].color[1];
			CubePos[CubeInd.right[6]].color[0] = CubePos[CubeInd.right[3]].color[1];

			CubePos[CubeInd.right[0]].color[1] = vec3;
			CubePos[CubeInd.right[3]].color[1] = vec2;
			CubePos[CubeInd.right[5]].color[1] = vec1;
		}
		// 后
		else if (direction == BACK) {
			// 旋转轴
			angleVec = glm::vec3(0.0f, 0.0f, 1.0f);

			glm::vec3 vec1 = CubePos[CubeInd.back[0]].color[2];
			glm::vec3 vec2 = CubePos[CubeInd.back[1]].color[1];
			glm::vec3 vec3 = CubePos[CubeInd.back[2]].color[2];

			CubePos[CubeInd.back[0]].color[2] = CubePos[CubeInd.right[2]].color[1];
			CubePos[CubeInd.back[1]].color[1] = CubePos[CubeInd.right[4]].color[1];
			CubePos[CubeInd.back[2]].color[2] = CubePos[CubeInd.right[7]].color[1];

			CubePos[CubeInd.right[2]].color[1] = CubePos[CubeInd.down[7]].color[2];
			CubePos[CubeInd.right[4]].color[1] = CubePos[CubeInd.down[6]].color[1];
			CubePos[CubeInd.right[7]].color[1] = CubePos[CubeInd.down[5]].color[2];

			CubePos[CubeInd.down[5]].color[2] = CubePos[CubeInd.left[0]].color[1];
			CubePos[CubeInd.down[6]].color[1] = CubePos[CubeInd.left[3]].color[1];
			CubePos[CubeInd.down[7]].color[2] = CubePos[CubeInd.left[5]].color[1];

			CubePos[CubeInd.left[0]].color[1] = vec3;
			CubePos[CubeInd.left[3]].color[1] = vec2;
			CubePos[CubeInd.left[5]].color[1] = vec1;

			vec1 = CubePos[CubeInd.back[0]].color[0];
			vec2 = CubePos[CubeInd.back[1]].color[0];
			vec3 = CubePos[CubeInd.back[2]].color[0];

			CubePos[CubeInd.back[0]].color[0] = CubePos[CubeInd.back[2]].color[0];
			CubePos[CubeInd.back[1]].color[0] = CubePos[CubeInd.back[3]].color[0];
			CubePos[CubeInd.back[2]].color[0] = CubePos[CubeInd.back[7]].color[0];

			CubePos[CubeInd.back[2]].color[0] = CubePos[CubeInd.back[7]].color[0];
			CubePos[CubeInd.back[3]].color[0] = CubePos[CubeInd.back[6]].color[0];
			CubePos[CubeInd.back[7]].color[0] = CubePos[CubeInd.back[5]].color[0];

			CubePos[CubeInd.back[7]].color[0] = CubePos[CubeInd.back[5]].color[0];
			CubePos[CubeInd.back[5]].color[0] = CubePos[CubeInd.back[0]].color[0];
			CubePos[CubeInd.back[6]].color[0] = CubePos[CubeInd.back[4]].color[0];

			CubePos[CubeInd.back[0]].color[0] = vec3;
			CubePos[CubeInd.back[4]].color[0] = vec2;
			CubePos[CubeInd.back[5]].color[0] = vec1;
		}
		// 左
		else if (direction == LEFT) {
			// 旋转轴
			angleVec = glm::vec3(1.0f, 0.0f, 0.0f);

			glm::vec3 vec1 = CubePos[CubeInd.left[0]].color[2];
			glm::vec3 vec2 = CubePos[CubeInd.left[1]].color[1];
			glm::vec3 vec3 = CubePos[CubeInd.left[2]].color[2];

			CubePos[CubeInd.left[0]].color[2] = CubePos[CubeInd.back[5]].color[0];
			CubePos[CubeInd.left[1]].color[1] = CubePos[CubeInd.back[4]].color[0];
			CubePos[CubeInd.left[2]].color[2] = CubePos[CubeInd.back[0]].color[0];

			CubePos[CubeInd.back[0]].color[0] = CubePos[CubeInd.down[5]].color[2];
			CubePos[CubeInd.back[4]].color[0] = CubePos[CubeInd.down[3]].color[1];
			CubePos[CubeInd.back[5]].color[0] = CubePos[CubeInd.down[0]].color[2];

			CubePos[CubeInd.down[0]].color[2] = CubePos[CubeInd.front[0]].color[0];
			CubePos[CubeInd.down[3]].color[1] = CubePos[CubeInd.front[3]].color[0];
			CubePos[CubeInd.down[5]].color[2] = CubePos[CubeInd.front[5]].color[0];

			CubePos[CubeInd.front[0]].color[0] = vec1;
			CubePos[CubeInd.front[3]].color[0] = vec2;
			CubePos[CubeInd.front[5]].color[0] = vec3;


			vec1 = CubePos[CubeInd.left[0]].color[1];
			vec2 = CubePos[CubeInd.left[1]].color[0];
			vec3 = CubePos[CubeInd.left[2]].color[1];

			CubePos[CubeInd.left[0]].color[1] = CubePos[CubeInd.left[5]].color[1];
			CubePos[CubeInd.left[1]].color[0] = CubePos[CubeInd.left[3]].color[1];
			CubePos[CubeInd.left[2]].color[1] = CubePos[CubeInd.left[0]].color[1];

			CubePos[CubeInd.left[0]].color[1] = CubePos[CubeInd.left[5]].color[1];
			CubePos[CubeInd.left[3]].color[1] = CubePos[CubeInd.left[6]].color[0];
			CubePos[CubeInd.left[5]].color[1] = CubePos[CubeInd.left[7]].color[1];

			CubePos[CubeInd.left[7]].color[1] = CubePos[CubeInd.left[5]].color[1];
			CubePos[CubeInd.left[5]].color[1] = CubePos[CubeInd.left[7]].color[1];
			CubePos[CubeInd.left[6]].color[0] = CubePos[CubeInd.left[4]].color[1];

			CubePos[CubeInd.left[2]].color[1] = vec1;
			CubePos[CubeInd.left[4]].color[1] = vec2;
			CubePos[CubeInd.left[7]].color[1] = vec3;
		}
	}

	void MagicCube::Draw(Shader& shader, double currentTime)
	{
		if (TheToRotate) {
			deltaTime = currentTime - lastFrame;
			if (deltaTime > speed) {
				angle += rotDir;
				lastFrame = currentTime;
			}
		}
		if (angle > 90|| angle < -90) {
			IsRotating(false);
			angle = 0;
			// 重新渲染
			ReRendering();
		}
		for (int i = 0; i < 26; i++)
		{
			glBindVertexArray(CubePos[i].VAO);
			glm::mat4 mMat = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));
			if (CubePos[i].isRotating) {
				mMat = glm::rotate(mMat, glm::radians(angle), angleVec);
			}
			// 模型矩阵
			mMat = glm::translate(mMat, CubePos[i].position);
			// 模型矩阵
			shader.setPUFMat4("m_matrix", glm::value_ptr(mMat));
			// 绘制模型
			glDrawArrays(GL_TRIANGLES, 0, 36);
		}
	}

	void MagicCube::DeleteCube()
	{
		delete[]PCube;
		DeleteVertexData();
	}
}

main.cpp

#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 <ImgUI/imgui.h>
#include <ImgUI/imgui_impl_glfw.h>
#include <ImgUI/imgui_impl_opengl3.h>

#include <iostream>
#include <assert.h>
#include <cmath>
#include <map>
#include <ctime>
#include <stack>
#include <vector>
#include <Class/Shader/Shader.h>
#include <Class/Camera/Camera.h>
#include "MagicCube.h"

// 创建着色器类
Shader shader;
// 创建魔法类
CubeN::MagicCube myMagicCube;

// 位置、目标、上向量
Camera myCamera(glm::vec3(0.0f, 0.0f, 3.0f),glm::vec3(0.0f, 0.0f, -1.0f),glm::vec3(0.0f, 1.0f, 0.0f));

float aspect;// 屏幕宽度比
bool isCtrlPressed = true;

GLuint
vLoad,// 视图矩阵
mLoad,// 模型矩阵
pLoad;// 透视矩阵

glm::mat4
mMat,	// 模型矩阵
pMat,  // 透视矩阵
vMat;  // 视图矩阵

// 初始自定义代码
void init(GLFWwindow* window);
// 渲染自定义代码
void display(GLFWwindow* window, double currentTime);
// 销毁
void destroy(GLFWwindow* window);
// 窗口改变事件
void window_reshape_callback(GLFWwindow* window, int width, int height);
// 注册了鼠标移动事件
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
// 注册了鼠标移动事件
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
// 监听按键，鼠标事件
void ProcessInput(GLFWwindow* window);
// 键盘按下和抬起事件的回调函数
void onKey(GLFWwindow* window, int key, int scancode, int action, int mods);

int main() {
	// 初始化 glfw
	if (!glfwInit()) { exit(EXIT_FAILURE); }
	// 设置 opengl 版本 （4.6 核心）
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	// 创建 window 窗口
	GLFWwindow* window = glfwCreateWindow(600, 600, "LearOpenGL 3.5", NULL, NULL);
	// 链接 opengl 上下文
	glfwMakeContextCurrent(window);

	// 初始化 glad 获取 opengl api 函数 地址
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { exit(EXIT_FAILURE); }
	// 开启垂直
	glfwSwapInterval(1);

	// 注册窗口改变事件
	glfwSetWindowSizeCallback(window, window_reshape_callback);
	// 隐藏光标
	// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	// 注册了鼠标移动事件
	glfwSetCursorPosCallback(window, mouse_callback);
	// 注册了鼠标滚动事件
	glfwSetScrollCallback(window, scroll_callback);
	// 设置键盘事件的回调函数
	glfwSetKeyCallback(window, onKey);

	// 创建imgui上下文
	ImGui::CreateContext();
	ImGuiIO& io = ImGui::GetIO();
	// 设置样式
	ImGui::StyleColorsDark();
	// 设置平台和渲染器
	ImGui_ImplGlfw_InitForOpenGL(window, true);
	ImGui_ImplOpenGL3_Init("#version 460");

	// 初始化着色器类
	shader.init("vertShader.glsl", "fragShader.glsl");

	// 初始化魔方
	myMagicCube.MagicCubeInit();

	// 初始自定义代码
	init(window);

	myCamera.fov = 45.0f;

	// 循环渲染
	while (!glfwWindowShouldClose(window))
	{
		// 监听键盘
		ProcessInput(window);

		ImGui_ImplOpenGL3_NewFrame();
		ImGui_ImplGlfw_NewFrame();
		ImGui::NewFrame();

		ImGui::Begin("imgui");
		ImGui::Text("%.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
		ImGui::End();

		// 渲染自定义代码
		display(window, glfwGetTime());

		// 渲染 gui
		ImGui::Render();
		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

		// 交换缓存和轮询IO事件
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	// 释放内存
	destroy(window);

	// 成功退出程序
	exit(EXIT_SUCCESS);
}

void init(GLFWwindow* window) {
	// 开启着色器程序
	shader.useProgram();
	mLoad = shader.getULocation("m_matrix");
	vLoad = shader.getULocation("v_matrix");
	pLoad = shader.getULocation("p_matrix");
	// 获取窗口的宽高
	int width, height;
	glfwGetFramebufferSize(window, &width, &height);// 获取屏幕宽，高
	// 计算宽高比
	aspect = (float)width / (float)height;//获取屏幕比例
}

void display(GLFWwindow* window, double currentTime) {
	// 填充颜色缓冲区
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	// 清除深度缓冲区
	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
	// 创建透视矩阵 / 设置投影矩阵
	pMat = glm::perspective(glm::radians(myCamera.fov), aspect, 0.1f, 1000.0f);
	// 将视图矩阵压入栈
	vMat = myCamera.getLookAt();

	// 开启着色器程序
	shader.useProgram();
	// 视图矩阵
	shader.setPUFMat4(vLoad, glm::value_ptr(vMat));
	// 透视矩阵
	shader.setPUFMat4(pLoad, glm::value_ptr(pMat));

	// 开启深度测试
	glEnable(GL_DEPTH_TEST);
	// 设置深度测试的比较方式
	glDepthFunc(GL_LESS);
	// 开启背面剔除
	glEnable(GL_CULL_FACE);
	// 设置立方体顶点的缠绕顺序为逆时针方向
	glFrontFace(GL_CW);

	myMagicCube.Draw(shader, currentTime);
}

void destroy(GLFWwindow* window) {
	// 销毁 vao vbo
	myMagicCube.DeleteCube();
	// 销毁着色器
	shader.deleteProgram();
	// 销毁窗口
	glfwDestroyWindow(window);
	glfwTerminate();
}

void window_reshape_callback(GLFWwindow* window, int width, int height)
{
	// 设置和帧缓冲区相关的屏幕区域
	glViewport(0, 0, width, height);
	aspect = (float)width / (float)height;//获取屏幕比例
}

// 监听按键，鼠标事件
void ProcessInput(GLFWwindow* window)
{
	// 检查用户是否按下了返回键(Esc)
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		// 下一次while循环的条件检测将会失败，程序将会关闭
		glfwSetWindowShouldClose(window, true);
	}

	static float deltaTime = 0.0f;
	static float lastFrame = 0.0f;

	float currentFrame = glfwGetTime();
	deltaTime = currentFrame - lastFrame; //  当前帧与上一帧的时间差
	lastFrame = currentFrame;             //  上一帧的时间

	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
		myCamera.ProcessKeyboard(FORWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
		myCamera.ProcessKeyboard(BACKWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
		myCamera.ProcessKeyboard(LEFT, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
		myCamera.ProcessKeyboard(RIGHT, deltaTime);
}

// 回调函数，鼠标进入程序窗口，获取焦点
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
	static bool firstMouse = true;
	static float lastX = 0.0f;
	static float lastY = 0.0f;
	static float xoffset = 0.0f;
	static float yoffset = 0.0f;

	if (firstMouse)
	{
		lastX = xpos;
		lastY = ypos;
		firstMouse = false;
	}

	// 获取 x 坐标
	xoffset = xpos - lastX;
	// 注意这里是相反的，因为y坐标是从底部往顶部依次增大的
	yoffset = lastY - ypos;

	// 更新鼠标坐标
	lastX = xpos;
	lastY = ypos;
	if (!isCtrlPressed)
		myCamera.mouse_callback(xoffset, yoffset);
}

// 监听鼠标滚动
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
	myCamera.scroll_callback(xoffset, yoffset);
}

// 键盘按下和抬起事件的回调函数
void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {
	if (action == GLFW_PRESS) {
		// 键盘按下的处理逻辑
		if (key == GLFW_KEY_LEFT_CONTROL && !isCtrlPressed) {
			isCtrlPressed = true;
			glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
		}
		else if (key == GLFW_KEY_LEFT_CONTROL && isCtrlPressed) {
			isCtrlPressed = false;
			glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
		}

		if (key == GLFW_KEY_I) {
			myMagicCube.rotate(CubeN::FRONT);
		}
		else if (key == GLFW_KEY_L) {
			myMagicCube.rotate(CubeN::RIGHT);
		}
		else if (key == GLFW_KEY_M) {
			myMagicCube.rotate(CubeN::BACK);
		}
		else if (key == GLFW_KEY_J) {
			myMagicCube.rotate(CubeN::LEFT);
		}
	}
	else if (action == GLFW_RELEASE) {
		// 键盘抬起的处理逻辑
	}
}
Salted&fish
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
欧朋浏览器 6.7 JAVA源码
05-17
欧朋浏览器，全称为Opera浏览器，是一款源自挪威的著名网页浏览器，以其高效、安全和便捷的特性在全球范围内受到用户喜爱。这里的"欧朋浏览器 6.7 JAVA源码"指的是欧朋浏览器6.7版本的Java语言实现的源代码。由于...
欧朋浏览器 Java
02-11
欧朋浏览器 Java 它可以加载大的网页，但是字体有点过大，手机内存经常不足的可以试试！
欧朋java_欧朋浏览器java版下载安装2019
weixin_36401013的博客
02-12 508
功能介绍欧朋浏览器java版下载安装2019OperaSoftware开发的欧朋浏览器(OperaMini)是一款适用于各种平台、操作系统和嵌入式网络产品的高品质、多平台产品。基于云端压缩技术的全平台手机浏览器，它具有速度快，体积小，超省流量，支持w3c标准的HTML、CSS等基本功能特点。还具有简洁清爽的UI，可定制化的启动页面，内置微博和资讯服务等个性化功能。本站提供欧朋浏览器java版下载安...
linux卸载欧朋浏览器,欧朋Opera Linux浏览器下载
weixin_39889214的博客
05-11 112
说实话，小编还没怎么用过Linux系统呢，其实就没有用过，但这并不妨碍小编提供Opera Linux浏览器下载，因为下载地址源自Opera欧朋官方下载，不是小编自己编译的版本，所以，小编有没有用过Linux都不妨碍提供Opera Linux下载。Opera浏览器是当下全球知名的浏览器品牌，虽然现在很多人不再看好Opera浏览器，但欧朋浏览器的未来依旧是光明的，其内置的很多独有的功能让我们上网浏览器...
欧朋浏览器java下载_欧朋浏览器java手机版
weixin_39539563的博客
02-16 229
欧朋浏览器java手机版介绍欧朋浏览器java手机版涵盖海量新闻资讯，实时更新,根据欧朋独有云端数据处理技术，你看到的，就是不一样!热点，资讯，深度，娱乐，一个就够。经常使用欧朋浏览器，会习惯打开浏览器就有个自定义的固定主页。那么，我们怎样对其设置一个自定义的主页。这种情况下应该怎么设置其主页呢?一起来了解下吧!1、在计算机桌面“欧朋浏览器”程序图标上双击鼠标左键，将其打开运行。如图所示;2、在打...
java版欧朋浏览器_Opera欧朋浏览器_Opera欧朋浏览器下载[2020官方最新版]Opera欧朋浏览器安全下载_ 极速下载...
weixin_39646021的博客
02-27 251
Opera(64位)为来自挪威的一个极为出色的浏览器，具有速度快、节省系统资源、订制能力强、安全性高以及体积小等特点，目前已经是最受欢迎的浏览器之一。多文件接口(MDI)、方便的缩放功能、整合搜索引擎、键盘截径与鼠标浏览功能、当机时下次可以从上次浏览进度开始、防止pop-up、Fullscreen、对HTML标准的支持、整合电子邮件与新闻群组以及让使用者自订接口按钮、skin、工具列等的排列方式，...
欧朋的paused in debugger怎么关闭
小罗的博客
04-11 5131
问题：欧朋的paused in debugger怎么关闭 鼠标右键点击审查元素，将有颜色行号点击一下，断点调试就没有啦。
linux卸载欧朋浏览器,如何在Centos下安装opera浏览器
weixin_39857153的博客
05-11 278
如何在Centos下安装opera浏览器 ，Opera目前是Linux平台上性能最优的浏览器，而且Opera中国团队本身即定位于Opera的研发中心，主要也是负责全球Linux平台项目的开发，这个版本初步解决了经年来Linux上Opera中文字体显示混乱的问题。我的机子是Centos5.4 final版[root@host32 ~]# uname -aLinux host32 2.6.18-92....
linux卸载欧朋浏览器,Ubuntu Opera 默认浏览器安装与设置方法
weixin_29221753的博客
05-11 318
目前 Opera 提供了针对 Ubuntu 的 .deb 文件(官方下载地址 http://opera.cn.uptodown.com/ubuntu)。Debian的.deb文件应该也可以工作。Opera 提供了两种基本安装类型：使用静态库和共享库。它们的区别是 Opera 是如何链接到 Qt 库的。在共享库版本中，Opera 使用你机器上的 Qt，而静态库的版本则使用 Opera 内建的 Qt。...
linux卸载欧朋浏览器,如何在Ubuntu系统中安装和卸载Opera浏览器
weixin_35972981的博客
05-11 272
以下内容教您如何在Ubuntu操作系统中安装Opera浏览器. 通常，可以通过以下方法安装不同的Opera版本. 下面将向您展示如何在Ubuntu中安装Opera 55版本的浏览器. 如果不需要，则可以将其卸载(删除).有关Opera 55的发行详细信息和下载，请参阅: Opera 55浏览器下载. 基于Chromium，更容易安装Chrome扩展程序.您可以下载Opera 55软件包并进行安装，...
linux 火狐欧朋谷歌浏览器,火狐/Chrome/Opera三大浏览器争霸
weixin_39648297的博客
05-14 921
MarkBrowserMark是又一个测试JavaScript、HTML5、WebGL、CSS3/3D等各项水平的基准测试软件。功能看起来好像跟Peacekeeper没区别嘛，会不会测试的结果也一样？别急，还是先来看结果吧！Chrome：5358分火狐：4591分欧朋：5189分没错，根据这些数据所排出来的顺序好像跟Peacekeeper确实没差，不过，各个浏览器之间的差距却是偏小了许多。广告Ba...
2013年欧朋php笔试回顾
sarah的专栏
10-23 601
最近有些自己觉得更要紧的事要做，手上有份完整的笔试试卷，以后有时间再码字上来。
欧朋浏览器
02-28
**欧朋浏览器——高效浏览，智能体验** 欧朋浏览器（Opera）是一款广受用户喜爱的网络浏览器，以其高效、安全和便捷的特性在全球范围内积累了大量的忠实用户。作为一款优秀的浏览器，欧朋在网页加载速度、资源占用...
android 4.0 欧朋 浏览器
10-23
android 4.0 欧朋 浏览器。12.1版本
glsl着色器学习（五）
localhost
09-03 768
接下来是创建buffer，设置顶点位置，法线，顶点索引等。
glsl着色器学习（八）通用模板
localhost
09-04 194
下面是一个简单的通用WebGL模板。
glsl着色器学习 （十一）旋转
最新发布
localhost
09-04 195
0,0,1]三维向量表示X,Y,Z三个分量，这里表示按照Z轴旋转。是一样的，都是变化矩阵，只是将缩放矩阵替换成旋转矩阵。是将给定的矩阵，按照给定的轴旋转后返回。
glsl着色器学习（十）缩放
localhost
09-04 156
不出意外的话，没啥变化，因为设置的矩阵是[1,1,1]，将[1,1,1]改成[2,1,1]，会发现图像X轴方向放大了2倍。对二维图形进行缩放，需要用到顶点着色器，顶点着色器经过矩阵变换，会将模型空间最终转换成裁剪空间。定义了一个统一变量4x4矩阵，用来接收应用程序传递过来的矩阵数据。获取变量在着色器程序中的位置。
2019年5月W3C（万维网联盟，成立于 2. 1994，拥有40个国家的400多个会员） 正式宣告将HTML和DOM标准制定权全权移交 给浏览器厂商联盟WHATWG（由浏览器巨头 Mozilla火狐、Opera欧朋、谷歌、苹果和微软组成）。这一次的移交，意味着以后，所有重大Web标准都将由浏览器厂商代替W3C全权负责了。请分析这一局面产生的原因，以及此局面可能对互联网产生的影响？
02-22
这一次W3C将HTML和DOM标准制定权移交给WHATWG，主要是因为W3C在定位和管理方面存在一些问题，把控不力，结果导致HTML和DOM标准制定过程变得缓慢、繁琐，跟不上现代网络技术的发展速度，而WHATWG的成立则正是为了解决...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值