OpenGL--多个翻滚的立方体

最新推荐文章于 2022-06-09 23:26:57 发布
最新推荐文章于 2022-06-09 23:26:57 发布
阅读量267 收藏
点赞数
分类专栏： Opengl 文章标签： opengl shader
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44210987/article/details/108151627
版权

在这里插入图片描述

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <string>
#include <iostream>
#include <fstream>
#include <cmath>
#include <glm\glm.hpp>
#include <glm\gtc\type_ptr.hpp> // glm::value_ptr
#include <glm\gtc\matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
#include "Utils.h"
using namespace std;

#define numVAOs 1
#define numVBOs 2

Utils util = Utils();
float cameraX, cameraY, cameraZ;
float cubeLocX, cubeLocY, cubeLocZ;
GLuint renderingProgram;
GLuint vao[numVAOs];
GLuint vbo[numVBOs];

// 分配在display()函数中使用的变量空间，这样它们就不必在渲染过程中分配
GLuint mvLoc, projLoc;
int width, height;
float aspect;
glm::mat4 pMat, vMat, mMat, mvMat;
glm::mat4 tMat, rMat;

void setupVertices(void) {  //36个顶点，12个三角形，组成了放置在原点处的2×2×2立方体
	float vertexPositions[108] = {
		-1.0f,  1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f,
		1.0f, -1.0f, -1.0f, 1.0f,  1.0f, -1.0f, -1.0f,  1.0f, -1.0f,
		1.0f, -1.0f, -1.0f, 1.0f, -1.0f,  1.0f, 1.0f,  1.0f, -1.0f,
		1.0f, -1.0f,  1.0f, 1.0f,  1.0f,  1.0f, 1.0f,  1.0f, -1.0f,
		1.0f, -1.0f,  1.0f, -1.0f, -1.0f,  1.0f, 1.0f,  1.0f,  1.0f,
		-1.0f, -1.0f,  1.0f, -1.0f,  1.0f,  1.0f, 1.0f,  1.0f,  1.0f,
		-1.0f, -1.0f,  1.0f, -1.0f, -1.0f, -1.0f, -1.0f,  1.0f,  1.0f,
		-1.0f, -1.0f, -1.0f, -1.0f,  1.0f, -1.0f, -1.0f,  1.0f,  1.0f,
		-1.0f, -1.0f,  1.0f,  1.0f, -1.0f,  1.0f,  1.0f, -1.0f, -1.0f,
		1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,  1.0f,
		-1.0f,  1.0f, -1.0f, 1.0f,  1.0f, -1.0f, 1.0f,  1.0f,  1.0f,
		1.0f,  1.0f,  1.0f, -1.0f,  1.0f,  1.0f, -1.0f,  1.0f, -1.0f
	};

	glGenVertexArrays(1, vao);//创建顶点数组对象VAO,      //数据集发送给管线时，是以缓冲区形式发送的
	glBindVertexArray(vao[0]);//将指定的VAO标记为活跃，生成的缓冲区和这个VAO关联
	glGenBuffers(numVBOs, vbo);//创建VBO.//参数1，创建多少个ID，参数2，保存返回的ID的数组

	glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);//将缓冲区【0】标记为活跃
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);//将包含顶点数据的数组复制进活跃缓冲区
}

//init()函数负责执行只需要一次的任务
void init(GLFWwindow* window) {
	renderingProgram = Utils::createShaderProgram("vertShader.glsl", "fragShader.glsl");//获取GL程序的ID，该程序创建着色器
	cameraX = 0.0f; cameraY = 0.0f; cameraZ = 24.0f;
	//cubeLocX = 0.0f; cubeLocY = -2.0f; cubeLocZ = 0.0f;//沿Y轴下移以展示透视
	setupVertices();//将顶点数据复制进缓冲区
}

//调用display函数的速率被称为帧率
void display(GLFWwindow* window, double currentTime) {
	int i;
	float tf; //tf == “time factor(时间因子)"
	//清除深度缓冲区
	glClear(GL_DEPTH_BUFFER_BIT);//隐藏面消除需要同时用到颜色缓冲区和深度缓冲区
								//这里只清楚了深度缓冲区，不然可能会导致黑屏
	glClear(GL_COLOR_BUFFER_BIT);
	//启用着色器
	glUseProgram(renderingProgram);//将含有两个已编译着色器的程序载入OpenGL管线阶段（在GPU上！）
								   //glUseProgram没有运行着色器，它只是将着色器加载进硬件
	
	//获取MV矩阵和投影矩阵的统一变量// m/模型矩阵在世界坐标空间中表示对象的位置和朝向
	mvLoc = glGetUniformLocation(renderingProgram, "mv_matrix");//获取着色器程序中MV统一变量的位置
	projLoc = glGetUniformLocation(renderingProgram, "proj_matrix");//获取着色器程序中投影矩阵统一变量的位置
	
	//构建透视矩阵//根据所需的视锥提供3D效果
	glfwGetFramebufferSize(window, &width, &height);
	aspect = (float)width / (float)height;//屏幕纵横比
	pMat = glm::perspective(1.0472f, aspect, 0.1f, 1000.0f);//构建透视矩阵//参数 1. 指定视场角(这里是60°，对应弧度是1.0472）
															//，2. 屏幕纵横比 ，3.近裁剪平面，4.远裁剪平面

	//构建MV矩阵
	vMat = glm::translate(glm::mat4(1.0f), glm::vec3(-cameraX, -cameraY, -cameraZ));//v，视图，相机，变换矩阵

	  //随时间位移和旋转，当前时间用来计算x,y,z的不同变换
	//MV矩阵移动到构建24次的循环中完成操作
	for (i = 0; i < 24; i++)//因为每一帧都会调用一次display，每一次display都会调用24次这个循环，所以会出现24个物体
	{
		tf = currentTime + i;//tf==“time factor(时间因子)"

		tMat = glm::translate(glm::mat4(1.0f),
			glm::vec3(sin(0.35f * tf) * 8.0f, cos(0.52f * tf) * 8.0f, sin(0.7f * tf) * 8.0f));
		rMat = glm::rotate(glm::mat4(1.0f), 1.75f * tf, glm::vec3(0.0f, 1.0f, 0.0f));
		rMat = glm::rotate(rMat, 1.75f * tf, glm::vec3(1.0f, 0.0f, 0.0f));
		rMat = glm::rotate(rMat, 1.75f * tf, glm::vec3(0.0f, 0.0f, 1.0f));
		//mMat=glm::tanslate(glm::mat4(1.0f),glm::vec3(cubeLocX,cubeLocY,cubeLocX));
		mMat = tMat * rMat;

		mvMat = vMat * mMat;

		//将透视矩阵和MV矩阵复制给相应的统一变量
		glUniformMatrix4fv(mvLoc, 1, GL_FALSE, glm::value_ptr(mvMat));//将矩阵数据发送到统一变量中，value_ptr返回的是对矩阵数据的引用
		glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(pMat));

		//将VBO关联给顶点着色器中相应的顶点属性
		glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
		glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
		glEnableVertexAttribArray(0);

		//调整OpenGL设置，绘制模型
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LEQUAL);

		glDrawArrays(GL_TRIANGLES, 0, 36);
	}
}

int main(void) {
	if (!glfwInit()) { exit(EXIT_FAILURE); }
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	GLFWwindow* window = glfwCreateWindow(600, 600, "Chapter 4.1.4 - program 1", NULL, NULL);
	glfwMakeContextCurrent(window);
	if (glewInit() != GLEW_OK) { exit(EXIT_FAILURE); }
	glfwSwapInterval(1);

	init(window);

	while (!glfwWindowShouldClose(window)) {
		display(window, glfwGetTime());
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glfwDestroyWindow(window);
	glfwTerminate();
	exit(EXIT_SUCCESS);
}

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <SOIL2\soil2.h>
#include <string>
#include <iostream>
#include <fstream>
#include <cmath>
#include <vector>
#include <glm\glm.hpp>
#include <glm\gtc\type_ptr.hpp>
#include <glm\gtc\matrix_transform.hpp>

class Utils
{
private:
	static std::string readShaderFile(const char *filePath);
	static void printShaderLog(GLuint shader);
	static void printProgramLog(int prog);
	static GLuint prepareShader(int shaderTYPE, const char *shaderPath);
	static int finalizeShaderProgram(GLuint sprogram);

public:
	Utils();
	static bool checkOpenGLError();
	static GLuint createShaderProgram(const char *vp, const char *fp);
	static GLuint createShaderProgram(const char *vp, const char *gp, const char *fp);
	static GLuint createShaderProgram(const char *vp, const char *tCS, const char* tES, const char *fp);
	static GLuint createShaderProgram(const char *vp, const char *tCS, const char* tES, char *gp, const char *fp);
	static GLuint loadTexture(const char *texImagePath);
	static GLuint loadCubeMap(const char *mapDir);

	static float* goldAmbient();
	static float* goldDiffuse();
	static float* goldSpecular();
	static float goldShininess();

	static float* silverAmbient();
	static float* silverDiffuse();
	static float* silverSpecular();
	static float silverShininess();

	static float* bronzeAmbient();
	static float* bronzeDiffuse();
	static float* bronzeSpecular();
	static float bronzeShininess();
};

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <SOIL2\soil2.h>
#include <string>
#include <iostream>
#include <fstream>
#include <cmath>
#include <glm\glm.hpp>
#include <glm\gtc\type_ptr.hpp> // glm::value_ptr
#include <glm\gtc\matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
#include "Utils.h"
using namespace std;

Utils::Utils() {}

string Utils::readShaderFile(const char *filePath) {
	string content;
	ifstream fileStream(filePath, ios::in);
	string line = " ";
	while (!fileStream.eof()) {
		getline(fileStream, line);
		content.append(line + "\n");
	}
	fileStream.close();
	return content;
}

bool Utils::checkOpenGLError() {
	bool foundError = false;
	int glErr = glGetError();
	while (glErr != GL_NO_ERROR) {
		cout << "glError: " << glErr << endl;
		foundError = true;
		glErr = glGetError();
	}
	return foundError;
}

void Utils::printShaderLog(GLuint shader) {
	int len = 0;
	int chWrittn = 0;
	char *log;
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
	if (len > 0) {
		log = (char *)malloc(len);
		glGetShaderInfoLog(shader, len, &chWrittn, log);
		cout << "Shader Info Log: " << log << endl;
		free(log);
	}
}

GLuint Utils::prepareShader(int shaderTYPE, const char *shaderPath)
{	GLint shaderCompiled;
	string shaderStr = readShaderFile(shaderPath);
	const char *shaderSrc = shaderStr.c_str();//获取着色器信息的字符串
	GLuint shaderRef = glCreateShader(shaderTYPE);//创建着色器
	glShaderSource(shaderRef, 1, &shaderSrc, NULL);//将字符串复制进着色器中
	glCompileShader(shaderRef);//编译着色器
	checkOpenGLError();
	glGetShaderiv(shaderRef, GL_COMPILE_STATUS, &shaderCompiled);
	if (shaderCompiled != 1)
	{	if (shaderTYPE == 35633) cout << "Vertex ";
		if (shaderTYPE == 36488) cout << "Tess Control ";
		if (shaderTYPE == 36487) cout << "Tess Eval ";
		if (shaderTYPE == 36313) cout << "Geometry ";
		if (shaderTYPE == 35632) cout << "Fragment ";
		cout << "shader compilation error." << endl;
		printShaderLog(shaderRef);
	}
	return shaderRef;//返回程序的ID
}

void Utils::printProgramLog(int prog) {
	int len = 0;
	int chWrittn = 0;
	char *log;
	glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &len);
	if (len > 0) {
		log = (char *)malloc(len);
		glGetProgramInfoLog(prog, len, &chWrittn, log);
		cout << "Program Info Log: " << log << endl;
		free(log);
	}
}

int Utils::finalizeShaderProgram(GLuint sprogram)
{	GLint linked;
	glLinkProgram(sprogram); //请求GLSL编译器确保他们的兼容性
	checkOpenGLError();
	glGetProgramiv(sprogram, GL_LINK_STATUS, &linked);
	if (linked != 1)
	{	cout << "linking failed" << endl;
		printProgramLog(sprogram);
	}
	return sprogram;
}

GLuint Utils::createShaderProgram(const char *vp, const char *fp) {
	GLuint vShader = prepareShader(GL_VERTEX_SHADER, vp);//获取编译着色器后得到的着色器对象
	GLuint fShader = prepareShader(GL_FRAGMENT_SHADER, fp);
	GLuint vfprogram = glCreateProgram();//创建程序对象
	glAttachShader(vfprogram, vShader);//将着色器对象载入程序对象中
	glAttachShader(vfprogram, fShader);
	finalizeShaderProgram(vfprogram); //请求GLSL编译器确保他们的兼容性
	return vfprogram;
}

GLuint Utils::createShaderProgram(const char *vp, const char *gp, const char *fp) {
	GLuint vShader = prepareShader(GL_VERTEX_SHADER, vp);
	GLuint gShader = prepareShader(GL_GEOMETRY_SHADER, gp);
	GLuint fShader = prepareShader(GL_FRAGMENT_SHADER, fp);
	GLuint vgfprogram = glCreateProgram();
	glAttachShader(vgfprogram, vShader);
	glAttachShader(vgfprogram, gShader);
	glAttachShader(vgfprogram, fShader);
	finalizeShaderProgram(vgfprogram);
	return vgfprogram;
}

GLuint Utils::createShaderProgram(const char *vp, const char *tCS, const char* tES, const char *fp) {
	GLuint vShader = prepareShader(GL_VERTEX_SHADER, vp);
	GLuint tcShader = prepareShader(GL_TESS_CONTROL_SHADER, tCS);
	GLuint teShader = prepareShader(GL_TESS_EVALUATION_SHADER, tES);
	GLuint fShader = prepareShader(GL_FRAGMENT_SHADER, fp);
	GLuint vtfprogram = glCreateProgram();
	glAttachShader(vtfprogram, vShader);
	glAttachShader(vtfprogram, tcShader);
	glAttachShader(vtfprogram, teShader);
	glAttachShader(vtfprogram, fShader);
	finalizeShaderProgram(vtfprogram);
	return vtfprogram;
}

GLuint Utils::createShaderProgram(const char *vp, const char *tCS, const char* tES, char *gp, const char *fp) {
	GLuint vShader = prepareShader(GL_VERTEX_SHADER, vp);
	GLuint tcShader = prepareShader(GL_TESS_CONTROL_SHADER, tCS);
	GLuint teShader = prepareShader(GL_TESS_EVALUATION_SHADER, tES);
	GLuint gShader = prepareShader(GL_GEOMETRY_SHADER, gp);
	GLuint fShader = prepareShader(GL_FRAGMENT_SHADER, fp);
	GLuint vtgfprogram = glCreateProgram();
	glAttachShader(vtgfprogram, vShader);
	glAttachShader(vtgfprogram, tcShader);
	glAttachShader(vtgfprogram, teShader);
	glAttachShader(vtgfprogram, gShader);
	glAttachShader(vtgfprogram, fShader);
	finalizeShaderProgram(vtgfprogram);
	return vtgfprogram;
}

GLuint Utils::loadCubeMap(const char *mapDir) {
	GLuint textureRef;
	string xp = mapDir; xp = xp + "/xp.jpg";
	string xn = mapDir; xn = xn + "/xn.jpg";
	string yp = mapDir; yp = yp + "/yp.jpg";
	string yn = mapDir; yn = yn + "/yn.jpg";
	string zp = mapDir; zp = zp + "/zp.jpg";
	string zn = mapDir; zn = zn + "/zn.jpg";
	textureRef = SOIL_load_OGL_cubemap(xp.c_str(), xn.c_str(), yp.c_str(), yn.c_str(), zp.c_str(), zn.c_str(),
		SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS);
	if (textureRef == 0) cout << "didnt find cube map image file" << endl;
	//	glBindTexture(GL_TEXTURE_CUBE_MAP, textureRef);
	// reduce seams
	//	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	//	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	//	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	return textureRef;
}

GLuint Utils::loadTexture(const char *texImagePath)
{	GLuint textureRef;
	textureRef = SOIL_load_OGL_texture(texImagePath, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_INVERT_Y);
	if (textureRef == 0) cout << "didnt find texture file " << texImagePath << endl;
	// ----- mipmap/anisotropic section
	glBindTexture(GL_TEXTURE_2D, textureRef);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glGenerateMipmap(GL_TEXTURE_2D);
	if (glewIsSupported("GL_EXT_texture_filter_anisotropic")) {
		GLfloat anisoset = 0.0f;
		glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisoset);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoset);
	}
	// ----- end of mipmap/anisotropic section
	return textureRef;
}

// GOLD material - ambient, diffuse, specular, and shininess
float* Utils::goldAmbient() { static float a[4] = { 0.2473f, 0.1995f, 0.0745f, 1 }; return (float*)a; }
float* Utils::goldDiffuse() { static float a[4] = { 0.7516f, 0.6065f, 0.2265f, 1 }; return (float*)a; }
float* Utils::goldSpecular() { static float a[4] = { 0.6283f, 0.5559f, 0.3661f, 1 }; return (float*)a; }
float Utils::goldShininess() { return 51.2f; }

// SILVER material - ambient, diffuse, specular, and shininess
float* Utils::silverAmbient() { static float a[4] = { 0.1923f, 0.1923f, 0.1923f, 1 }; return (float*)a; }
float* Utils::silverDiffuse() { static float a[4] = { 0.5075f, 0.5075f, 0.5075f, 1 }; return (float*)a; }
float* Utils::silverSpecular() { static float a[4] = { 0.5083f, 0.5083f, 0.5083f, 1 }; return (float*)a; }
float Utils::silverShininess() { return 51.2f; }

// BRONZE material - ambient, diffuse, specular, and shininess
float* Utils::bronzeAmbient() { static float a[4] = { 0.2125f, 0.1275f, 0.0540f, 1 }; return (float*)a; }
float* Utils::bronzeDiffuse() { static float a[4] = { 0.7140f, 0.4284f, 0.1814f, 1 }; return (float*)a; }
float* Utils::bronzeSpecular() { static float a[4] = { 0.3936f, 0.2719f, 0.1667f, 1 }; return (float*)a; }
float Utils::bronzeShininess() { return 25.6f; }

在这里插入图片描述
在这里插入图片描述

你好，Albert
关注
专栏目录
opengl 画个立方体
缥缈的云 专栏
07-17 7020
opengl 画个立方体
opengl 绘制多个立方体旋转
03-28
用opengl 在qt 上绘制多个立方体。并不断旋转。
OPenGL实现天空盒和创建多个立方体及贴图代码
weixin_51241980的博客
06-09 486
Opengl实现天空盒
OpenGL立方体在世界坐标系中缩放_旋转_平移_顶点片源着色器
03-30
里面有txt的使用说明，顺代如果要直接点击exe ，那么需要把用到的各个 .dll复制到和exe同一个目录下，顶点着色器和片源着色器文档也要复制过去
opengl立方体
wqdqwass的博客
08-10 235
立方体36个顶点 //立方体36个顶点 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.
AndroidOpenGL.rar_android_android 立方体_cube_openGL-es android_立方体
09-21
总的来说，"Android OpenGL 立方体旋转"实例是一个基础的3D图形编程教程，涵盖了OpenGL ES的使用、基本的几何体构建、矩阵变换以及动画原理。它为开发者提供了一个理解OpenGL ES工作原理和实践3D图形编程的起点。...
AndroidOpenGL-3D-立方体多纹理贴图源码.zip
07-10
本项目“AndroidOpenGL-3D-立方体多纹理贴图源码”是一个示例，展示了如何在Android设备上使用OpenGL ES进行3D渲染，特别是如何实现立方体的多纹理贴图。 在Android开发中，OpenGL ES（Embedded Systems的缩写）是...
Android--开发--OpenGL 3D立方体多纹理贴图.rar
最新发布
04-10
Android--开发--OpenGL 3D立方体多纹理贴图
计算机图形学-使用Python的OpenGL库绘制一个旋转的立方体
01-06
计算机图形学
openGL实现天空盒，使用OpenGL 立方体贴图
03-02
2.OpenGL 纹理立方体贴图类似于稍后将要研究的3D 纹理，它们都使用3 个纹理坐标访 问——通常标记为（s, t, r）——而不是我们目前为止用到的两个。OpenGL 纹理立方体贴图 的另一个特性是，其中的图像以纹理图像的...
罗大柚OpenGL ES教程系列_LessonTwo（Part 4）_使用shader绘制一个立方体
大柚的专栏
03-04 2540
这一次，我们还是绘制一个立方体，但是采用的是shader， 需要说明的是， 我们用的是Xcode5.02中系统提供的顶点数据 和 shader， 写shader并不难，这里图个省事了。         #import "ViewController.h" #defineBUFFER_OFFSET(i) ((char *)NULL + (i))   //Uniform index
OpenGL学习笔记（十）正方体
czhzasui的博客
07-02 1053
效果如图 主程序main.c #include &lt;glad/glad.h&gt; #include &lt;GLFW/glfw3.h&gt; #include &lt;cmath&gt; #include &lt;iostream&gt; #include &lt;fstream&gt; #include &lt;sstream&gt; #include &lt;stb_imag...
opengl绘制立方体（二）
auccy的博客
09-08 2217
使用opengl绘制两个颜色不一样的立方体 #include "stdio.h" #include &lt;GL/glew.h&gt; #include &lt;GLFW/glfw3.h&gt; #include &lt;soil/SOIL.h&gt; #include &lt;glm/glm.hpp&gt; #include &lt;glm/gtc/matrix_transform.hpp...
跟我一起学OpenGL- cube(立方体)
xiadidi的专栏
08-30 2219
前面学习了画基本的三角形/正方形和纹理的使用，但是都是二维的，没有立体效果，看起来不够真实。本节则开始讲述如何画三维图像，以立方体为例。 为了勾勒立方体的形状，需要设置立方体的坐标。前面几节里通常只设置了x,y坐标，而将z设为0，这种方法画平面图形可以，三维图像则行不通，需要设置z的数值。立方体有六个面，OpenGL用的是右手坐标系，离镜头越远，z的值越大，坐标如下: 115 float ...
使用OpenGL 立方体贴图
aoxuestudy的专栏
03-02 2002
使用OpenGL 立方体贴图 OpenGL 纹理立方体贴图类似于稍后将要研究的3D 纹理，它们都使用3 个纹理坐标访 问——通常标记为（s, t, r）——而不是我们目前为止用到的两个。OpenGL 纹理立方体贴图的另一个特性是，其中的图像以纹理图像的左上角（而不是通常的左下角）作为纹理坐标（0, 0, 0），这通常是混乱产生的源头。
Opengl中给矩形添加纹理和绘制一个立方体
yuxing55555的博客
08-01 1478
效果图： 源码： #include <stdio.h> #include <string.h> #include <GL/glew.h> #include <GL/freeglut.h> #include <string> #include <fstream> #include <iostream> #inclu...
使用opengl绘制立方体_一步步学OpenGL(2) -《你好，顶点》
weixin_39710249的博客
11-23 870
你好顶点原文: Tutorial 02 - Hello dot!CSDN完整版专栏： 专栏：一步步学OpenGL3.3+ - 博客频道 - CSDN.NET背景这里要第一次开始使用GLEW（the OpenGL Extension Wrangler Library）库。GLEW可以帮助我们解决一些伴随OpenGL扩展库管理出现的一些头疼的问题，初始化之后，它会检索你平台中所有可用的扩展库，动态的加...
【OpenGL】立方体贴图——Cubemap天空盒案例
两水先木示的博客
04-08 1128
核心内容： gltMakeCube(cubeBatch, 20.0); //创建一个半径为20个单位长度的立方体批次数据填充到cubeBatch （GLBatch对象） 该函数会将2D纹理坐标分配到GLT_ATTRIBUTE_TEXTURE0属性槽，但我们需要的并不是2D纹理坐标，而是3D纹理坐标。 3D纹理坐标获取方法是在顶点着色器里直接将归一化的顶点坐标作为输出到片段着色器，此时片段着色器插值得到的顶点坐标就是三维纹理坐标了，接着在片段着色器使用texture(samplerCube纹理对象, 三..
OpengGL绘制立方体的三种方法
zzidea的专栏
07-25 7790
这个程序主要是作为新手的入门程序，这个程序来展示OpenGL运行的基本原理。通过绘制一个基本的3D图形（立方体）的三种方法的展示，有一定的借鉴意义
OpenGL实现旋转立方体
"该资源是关于使用OpenGL编程实现三维立方体旋转的一个实例。代码中定义了立方体的顶点坐标和边的连接关系，并通过glut库进行渲染，实现了立方体的连续旋转效果。" 在计算机图形学领域，OpenGL是一个跨语言、跨平台...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值