OpenGL —— 2.7、绘制多个自旋转的贴图正方体（附源码，glfw+glad）

已于 2023-10-20 12:07:32 修改
阅读量809 收藏 5
点赞数
分类专栏： OpenGL 文章标签： OpenGL C++ 贴图
于 2023-10-20 12:04:31 首次发布
automoblie0
本文链接：https://blog.csdn.net/automoblie0/article/details/133943458
版权
源码效果

 

C++源码

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

     
     需下载stb_image.h这个解码图片的库，该库只有一个头文件。

在这里插入图片描述
 
     具体代码：

          vertexShader.glsl

#version 330 core

layout(location = 0) in vec3 aPos;
layout(location = 1) in vec2 aUV;

out vec2 outUV;

uniform mat4 _modelMatrix;
uniform mat4 _viewMatrix;
uniform mat4 _projMatrix;

void main()
{
	gl_Position = _projMatrix* _viewMatrix *  _modelMatrix * vec4(aPos.x, aPos.y, aPos.z, 1.0);

	outUV = aUV;
}

          fragmentShader.glsl

#version 330 core

out vec4 FragColor;

in vec2 outUV;

uniform sampler2D ourTexture;

void main()
{
	// 使用图片纹理及色彩混合
	FragColor = texture(ourTexture, outUV);
}

          main.cpp

#include "OpenGLClass.h"
#include "OpenGLClass.h"

int main()
{
	OpenGLClass opengl;
	return 0;
}

          OpenGLClass.h

#pragma once

#include "Global.h"
#include "ffImage.h"

class OpenGLClass
{
public:
	OpenGLClass();
	~OpenGLClass();

protected:
	// 初始化纹理
	bool initTexture();

	// 初始化模型VAO/VBO
	void initModel();

	// 初始化shader文件
	bool initShader(const char *_vertexPath, const char *_fragPath);

	// 读取glsl文件内容
	std::string ReadGlslContext(const char *sPath);

	// 刷新Render
	void FlushRender();

	// 回调 - 窗口尺寸变化回调
	static void bck_GLFWframebuffersizefun(GLFWwindow* window, int width, int height);

	// 处理按键输入
	void ProcessKeyPInput(GLFWwindow *window);

	// 设置矩阵
	void setMatrix(const std::string &_name, glm::mat4 _matrix)const;

private:
	unsigned short windowWidth = 800, windowHeight = 600;

	unsigned int shaderProgram = 0;		// 链接程序对象
	unsigned int VBO = 0, VAO = 0, _texture = 0;
};

          OpenGLClass.cpp

#include "OpenGLClass.h"

void OpenGLClass::bck_GLFWframebuffersizefun(GLFWwindow* window, int width, int height)
{
	// 在窗口中定义一个像素矩形,最终的图形将映射到个矩形中
	glViewport(0, 0, width, height);
}

OpenGLClass::OpenGLClass()
{
	// 初始化glfw上下文
	if (glfwInit() == GLFW_FALSE) { std::cout << "glfwInit fail!\n"; return; }
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);					// 3.3版本
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);	// 使用OpenGL核心模式

	// 创建OpenGL窗体
	GLFWwindow *window = glfwCreateWindow(windowWidth, windowHeight, "OpenGL Core", nullptr, nullptr);
	if (!window) { std::cout << "glfwCreateWindow fail!\n"; return; }

	// 当前OpenGL上下文绑定窗口
	glfwMakeContextCurrent(window);

	// 加载所有OpenGL函数指针
	if (GL_FALSE == gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { std::cout << "gladLoadGLLoader fail!\n"; return; }

	// 在窗口中定义一个像素矩形,最终的图形将映射到个矩形中
	glViewport(0, 0, windowWidth, windowHeight);

	// 窗口大小调整回调
	glfwSetFramebufferSizeCallback(window, OpenGLClass::bck_GLFWframebuffersizefun);

	// 初始化VAO/VBO
	initModel();

	// 初始化纹理
	if (!initTexture()) { std::cout << "initTexture fail!\n"; system("pause"); return; }

	// 初始化shader
	if (!initShader("vertexShader.glsl", "fragmentShader.glsl")) { std::cout << "initShader fail!\n"; system("pause"); return; }

	// 窗口标志是否是关闭
	while (!glfwWindowShouldClose(window))
	{
		// 输入按键处理
		ProcessKeyPInput(window);

#if 0
		// 使用红，绿，蓝以及alpha值来清除颜色缓冲区
		glClearColor(0.328125f, 0.35156f, 0.82421f, 1.0f);

		// 将从窗口中清除最后一次所绘制的图形
		/*
			GL_COLOR_BUFFER_BIT:    当前可写的颜色缓冲
			GL_DEPTH_BUFFER_BIT:    深度缓冲
			GL_ACCUM_BUFFER_BIT:	累积缓冲
　　			GL_STENCIL_BUFFER_BIT:	模板缓冲
		*/
		glClear(GL_COLOR_BUFFER_BIT);
#endif

		FlushRender();

		// 双缓冲,使用OpenGL或OpenGL ES进行渲染
		glfwSwapBuffers(window);

		// glfw事件循环
		glfwPollEvents();

		// 睡眠10ms,防止造成GPU疯狂消耗。实际具体调整
		Sleep(10);
	}

	// 释放窗口
	glfwDestroyWindow(window);

	// 释放资源,终止GLFW库
	glfwTerminate();
}

OpenGLClass::~OpenGLClass()
{
	// 释放
	if (glIsProgram(shaderProgram)) { glDeleteProgram(shaderProgram); }shaderProgram = 0;
	if (glIsBuffer(VAO)) { glDeleteBuffers(1, &VAO); } VAO = 0;
	if (glIsBuffer(VBO)) { glDeleteBuffers(1, &VBO); } VBO = 0;
}

void OpenGLClass::ProcessKeyPInput(GLFWwindow *window)
{
	if (window)
	{
		// 获取窗口按键是否ESC
		if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
		{
			// 设置窗口关闭标志
			glfwSetWindowShouldClose(window, true);
		}
	}
	window = nullptr;
}

void OpenGLClass::setMatrix(const std::string &_name, glm::mat4 _matrix) const
{
	// 获得指定shader程序中uniform变量的位置
	int shaderNameId = glGetUniformLocation(shaderProgram, _name.c_str());


	/*
	将4x4的矩阵数据传递给着色器
		location：指定要更改的uniform变量的位置。
		count：指定要更改的矩阵的数量。如果只更改一个矩阵，该值为1。
		transpose：指定是否需要将矩阵进行转置。一般情况下，设为GL_FALSE即可。
		value：指向包含矩阵数据的指针。
	*/
	glUniformMatrix4fv
	(
		shaderNameId,
		1,
		GL_FALSE,
		glm::value_ptr(_matrix)
	);
}

void OpenGLClass::FlushRender()
{
	// 判断VAO是否被删除
	if (glIsVertexArray(VAO))
	{
		// 使用红，绿，蓝以及alpha值来清除颜色缓冲区
		glClearColor(0.328125f, 0.35156f, 0.82421f, 1.0f);
		// 将从窗口中清除最后一次所绘制的图形,GL_DEPTH_BUFFER_BIT将深度信息也清除
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		// 开启深度检测
		glEnable(GL_DEPTH_TEST);

		///		// 模型平移数据
		glm::vec3 modelVecs[] =
		{
			glm::vec3(0.0f,0.0f,0.0f),
			glm::vec3(2.0f, 5.0f, -15.0f),
			glm::vec3(-1.5f, -2.2f, -2.5f),
			glm::vec3(-3.8f, -2.0f, -12.3f),
			glm::vec3(2.4f, -0.4f, -3.5f),
			glm::vec3(-1.7f, 3.0f, -7.5f),
			glm::vec3(1.3f, -2.0f, -2.5f),
			glm::vec3(1.5f, 2.0f, -2.5f),
			glm::vec3(1.5f, 0.2f, -1.5f),
			glm::vec3(-1.3f, 1.0f, -1.5f)
		};
		///

		///
		// 观察者/摄像机矩阵
		glm::mat4 _viewMatrix = glm::lookAt
		(
			glm::vec3(0.0f, 0.0f, 2.4f),	// 摄像机位置
			glm::vec3(0.0f, 0.0f, 0.0f),	// 摄像机看向的位置
			glm::vec3(0.0f, 1.0f, 0.0f)		// 摄像机顶部的位置
		);

		// 投影矩阵
		glm::mat4 _projMatrix = glm::perspective
		(
			glm::radians(45.0f),
			(float)windowWidth / (float)(windowHeight),
			0.1f, 100.0f
		);
		///

		// 使用程序
		glUseProgram(shaderProgram);

		// 绘制10个立方体
		for (unsigned short index = 0; index < 10; ++index)
		{
			glm::mat4 _modelMatrix(1.0f);
			_modelMatrix = glm::translate(_modelMatrix, modelVecs[index]);
			_modelMatrix = glm::rotate(_modelMatrix, glm::radians((float)glfwGetTime()*(index + 1) * 10), glm::vec3(0.5f, 1.0f, 0.0f));

			///
			setMatrix("_modelMatrix", _modelMatrix);
			setMatrix("_viewMatrix", _viewMatrix);
			setMatrix("_projMatrix", _projMatrix);
			///

			// 绑定纹理
			glBindTexture(GL_TEXTURE_2D, _texture);

			// 绑定VAO
			glBindVertexArray(VAO);

			// 绘制三角形
			glDrawArrays(GL_TRIANGLES, 0, 36);
		}

		// 关闭使用程序
		glUseProgram(0);
	}
}

bool OpenGLClass::initTexture()
{
	// 读取图片相关信息
	ffImage *pImage = ffImage::readFromFile("./rec/wall.jpeg");
	if (!pImage) { return false; }

	// 生成纹理
	glGenTextures(1, &_texture);

	// 以2D方式绑定纹理
	// 将当前绑定的纹理对象替换为参数中指定的纹理对象
	glBindTexture(GL_TEXTURE_2D, _texture);

	// 设置纹理属性
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// 读取图片数据,完成数据绑定
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pImage->getWidth(), pImage->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, pImage->getData());

	if (pImage) { delete pImage; }pImage = nullptr;
	return true;
}

void OpenGLClass::initModel()
{
	// 坐标、颜色、纹理位置
	float vertices[]
	{
		-0.5f,-0.5f,-0.5f,	0.0f,0.0f,
		 0.5f,-0.5f,-0.5f,	1.0f,0.0f,
		 0.5f, 0.5f,-0.5f,	1.0f,1.0f,
		 0.5f, 0.5f,-0.5f,	1.0f,1.0f,
		-0.5f, 0.5f,-0.5f,	0.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,0.0f,

		-0.5f,-0.5f,0.5f,	0.0f,0.0f,
		 0.5f,-0.5f,0.5f,	1.0f,0.0f,
		 0.5f, 0.5f,0.5f,	1.0f,1.0f,
		 0.5f, 0.5f,0.5f,	1.0f,1.0f,
		-0.5f, 0.5f,0.5f,	0.0f,1.0f,
		-0.5f,-0.5f,0.5f,	0.0f,0.0f,

		-0.5f, 0.5f, 0.5f,	1.0f,0.0f,
		-0.5f, 0.5f,-0.5f,	1.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,1.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,1.0f,
		-0.5f,-0.5f, 0.5f,	0.0f,0.0f,
		-0.5f, 0.5f, 0.5f,	1.0f,0.0f,

		0.5f, 0.5f, 0.5f,	1.0f,0.0f,
		0.5f, 0.5f,-0.5f,	1.0f,1.0f,
		0.5f,-0.5f,-0.5f,	0.0f,1.0f,
		0.5f,-0.5f,-0.5f,	0.0f,1.0f,
		0.5f,-0.5f, 0.5f,	0.0f,0.0f,
		0.5f, 0.5f, 0.5f,	1.0f,0.0f,

		-0.5f,-0.5f,-0.5f,	0.0f,1.0f,
		 0.5f,-0.5f,-0.5f,	1.0f,1.0f,
		 0.5f,-0.5f, 0.5f,	1.0f,0.0f,
		 0.5f,-0.5f, 0.5f,	1.0f,0.0f,
		-0.5f,-0.5f, 0.5f,	0.0f,0.0f,
		-0.5f,-0.5f,-0.5f,	0.0f,1.0f,

		-0.5f,0.5f,-0.5f,	0.0f,1.0f,
		 0.5f,0.5f,-0.5f,	1.0f,1.0f,
		 0.5f,0.5f, 0.5f,	1.0f,0.0f,
		 0.5f,0.5f, 0.5f,	1.0f,0.0f,
		-0.5f,0.5f, 0.5f,	0.0f,0.0f,
		-0.5f,0.5f,-0.5f,	0.0f,1.0f
	};

	/****************************************************/	// VAO
	// 创建VAO
	glGenVertexArrays(1, &VAO);

	// 绑定指定的顶点数组对象（Vertex Array Object, VAO）
	glBindVertexArray(VAO);
	/****************************************************/


	/****************************************************/	// VBO
	// 生成缓冲区对象
	glGenBuffers(1, &VBO);

	// 绑定命名缓冲区对象
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	// 缓冲对象（VBO，IBO 等）分配空间并存储数据
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	/*
		指定顶点属性在顶点缓冲对象中的布局，并将其与顶点着色器中的顶点属性进行关联
			参数1:第n个layout (对应glsl中顶点着色器的layout)
			参数2:顶点属性的组成元素的数量,例如3表示顶点属性是由3个浮点数组成
			参数3:顶点属性的数据类型
			参数4:是否将非浮点型的数据归一化到[-1, 1]或[0, 1]范围内
			参数5:相邻两个顶点属性之间的字节数,通常为0或属性类型大小乘以数量
			参数6:顶点属性在顶点缓冲对象中的偏移量或者数据的首地址
	*/
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(sizeof(float) * 3));

	// 激活锚点(参数:第n个layout)
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);

	// 解绑VAO/VBO
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	/****************************************************/
}

std::string OpenGLClass::ReadGlslContext(const char *sPath)
{
	std::string strContext;
	if (!sPath) { return strContext; }

	std::ifstream sFile;
	sFile.open(sPath);
	if (sFile.is_open())
	{
		std::stringstream sStream;
		sStream << sFile.rdbuf();
		strContext = sStream.str();
	}
	return strContext;
}

bool OpenGLClass::initShader(const char *_vertexPath, const char *_fragPath)
{
	char infoLog[512] = { 0 };
	int successFlag = 0;

	/*********************************************************/	// vertex编译
	std::string vertexContext = ReadGlslContext(_vertexPath); if (vertexContext.empty()) { return false; }
	const char *cVertexContext = vertexContext.c_str();

	// 创建顶点着色器对象
	unsigned int iVertexID = glCreateShader(GL_VERTEX_SHADER);

	// 为顶点着色器指定源码(参数2:传过去几个)
	glShaderSource(iVertexID, 1, &cVertexContext, nullptr);

	// 编译顶点着色器源码
	glCompileShader(iVertexID);

	// 查看编译顶点着色器源码结果
	glGetShaderiv(iVertexID, GL_COMPILE_STATUS, &successFlag);
	if (!successFlag)	// 编译失败
	{
		// 获取编译失败原因
		glGetShaderInfoLog(iVertexID, 512, nullptr, infoLog);
		std::cout << "glGetShaderiv GL_VERTEX_SHADER" << iVertexID << " fail:" << infoLog << std::endl; return false;
	}
	cVertexContext = nullptr;
	/*********************************************************/


	/*********************************************************/	// fragment编译
	std::string fragmentContext = ReadGlslContext(_fragPath); if (fragmentContext.empty()) { return false; }
	const char *cFragmentContext = fragmentContext.c_str();

	// 创建片段着色器对象
	unsigned int iFragmentID = glCreateShader(GL_FRAGMENT_SHADER);

	// 为片段着色器指定源码(参数2:传过去几个)
	glShaderSource(iFragmentID, 1, &cFragmentContext, nullptr);

	// 编译片段着色器源码
	glCompileShader(iFragmentID);

	// 查看编译片段着色器源码结果
	glGetShaderiv(iFragmentID, GL_COMPILE_STATUS, &successFlag);
	if (!successFlag)	// 编译失败
	{
		// 获取编译失败原因
		glGetShaderInfoLog(iFragmentID, 512, nullptr, infoLog);
		std::cout << "glGetShaderiv GL_FRAGMENT_SHADER" << iFragmentID << " fail:" << infoLog << std::endl; return false;
	}
	cFragmentContext = nullptr;
	/*********************************************************/


	/*********************************************************/	// 链接
	// 创建一个空的程序对象
	shaderProgram = glCreateProgram();
	if (shaderProgram == 0) { std::cout << "glCreateProgram fail!\n"; return false; }

	// 将着色器对象附加到程序对象上（注:glDetachShader为移除程序对象中的指定着色器对象）
	glAttachShader(shaderProgram, iVertexID);
	glAttachShader(shaderProgram, iFragmentID);

	// 进行链接程序对象
	glLinkProgram(shaderProgram);

	// 查看链接状态
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &successFlag);
	if (!successFlag)	// 链接失败
	{
		// 获取链接失败原因
		glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
		std::cout << "glGetProgramiv " << shaderProgram << " fail:" << infoLog << std::endl; return false;
	}
	/*********************************************************/


	/* 在链接完成后,将编译shader相关删除。仅留下链接ID */
	if (glIsShader(iVertexID)) { glDeleteShader(iVertexID); }
	if (glIsShader(iFragmentID)) { glDeleteShader(iFragmentID); }
	return true;
}

 

完整源码下载

      源码下载

 

关注

Wx GZH：码农总动员

笔者 - jxd

 

信必诺
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
android OpenglES2.0之立体模型展示（缩放+旋转+光照+纹理）
zhang_he_xiang的博客
12-15 2406
                                                                                                                            心若止水，无坚不摧。 为了绘制一个3D立体模型，你需要掌握一下知识点： 1、GLSurfaceview 2、渲染器render 3、管线渲染的流...
OpenGL绘制旋转的正方体
02-23
OpenGL初学者很适合的一个旋转的绘制正方体，并且采用键盘控制正方体的旋转与颜色变换
现代OpenGL系列教程(二)---旋转的立方体
梦起丶的博客
12-19 3133
【写在前面】 本章主要内容： 1、OpenGL Texture(OpenGL纹理) 2、Vertex Array Object(顶点数组对象) 【正文开始】 相比上一章，本章并没有多少新的内容，所以我们直接进入关键的 MyRender 类中： #ifndef MYRENDER_H #define MYRENDER_H #include "OpenGLRender.h" #includ...
Android OpenGLES2.0（九）——利用OpenGL进行图片处理
热门推荐
湖广午王
10-23 1万+
在之前的博客中我们就有提过OpenGLES的常见应用范围，其中有一个就是图片的处理。为了保证效率，Android手机中许多美颜相机、图片处理应用，都用到了OpenGLES来处理图片。上一篇博客中，我们利用OpenGLES 显示出了一张图片，并保证图片正常显示，不会被拉伸和压缩。在本篇博客中，我们来了解下利用OpenGLES来处理图片的一些简单方法。相关原理本篇博客以简单的图片色彩处理、模糊和放大镜效
opengl实现经纹理映射的旋转立方体_立方体纹理
weixin_39788051的博客
11-22 410
立方体纹理就是包含6个2D纹理的纹理.6个纹理有序排列在立方体的6个面.其可以通过方向向量采样立方体纹理上的纹素.创建立方体贴图跟创建2D贴图一样,但是绑定到GL_TEXTURE_CUBE_MAP上.glGenTextures(1, &CubeMapID); glBindTexture(GL_TEXTURE_CUBE_MAP, CubeMapID); 立方体纹理右6个面,每个面都要调用一次...
OpenGL - 2.7、绘制多个自旋转的贴图正方体（附源码，glfw+glad）
10-20
■ 本源码运行环境为Vs2017(opengl所需库均已放在资源里)，主要功能绘制多个正方体、对正方体平移旋转并贴图 ■ 本源码对应的文章介绍：https://blog.csdn.net/automoblie0/article/details/133943458 ■ 本源码...
OpenGL - 2.6、绘制一个正方体并贴图（附源码，glfw+glad）
10-20
■ 本源码运行环境为vs2017+glfw+glad（opengl环境已放在资源里），主要功能绘制一个正方体并贴图 ■ 本源码对应的文章介绍：...
OpenGL的研发库 GLFW+GLAD
最新发布
01-19
2）将opengl32.lib + glfw3.lib添加进连接器（debug采用opengl32.lib + glfw3d.lib）; 3）特别地，将OpenGLLib/src/ 的glad.c文件引入到工程里。 示例代码 #include <glad/glad.h> #include <GLFW/glfw3.h> //GLFW ...
OpenGL - 2.8、漫游之摄像机飞行移动（附源码，glfw+glad）
10-20
■ 本源码运行环境为Vs2017(opengl环境已放在资源里)，主要功能摄像机漫游功能实现上下、左右、前后、恢复场景、调速等功能 ■ 本源码对应的文章介绍：...
opengl大作业 乡间小屋
12-12
f为雾化控制，鼠标右键打开菜单，方向键调整视角。 本程序应用了渲染，回显列表，粒子系统，纹理贴图，定时回调，光照，消隐，伪装反射等技术 本程序可继续加入投影，视点切换，移动，鼠标响应，中文字幕，凹凸纹理，雾化浓度变化等
OpenGL绘制图形（包含20多个基本例子）
07-29
OpenGL绘制图形（包含20多个基本例子）。直线，圆，椭圆，球体，曲线，曲面等基础图形的绘制。
一个简单的OpenGL多线程渲染模型
01-22
用多线程实现OpenGL渲染, 子线程负责渲染, 主线程负责干其他事情.
opengl 绘制多个立方体旋转
03-28
用opengl 在qt 上绘制多个立方体。并不断旋转。
OpenGL - 2.9、摄像机之模拟CS鼠标视角转动（附源码，glfw+glad）
10-23
■ 本源码运行环境为Vs2017(openg库已放入资源中)，主要功能摄像机漫游功能实现上下、左右、前后、恢复场景、调速等功能，实现类似cs游戏持枪第一视角转动效果。 ■ 本源码对应的文章介绍：... ... ...
安卓 OpenGL ES 2.0 完全入门（三）：2D 纹理的裁剪、翻转、旋转、缩放
android开发笔记
08-18 4450
整体思路 在基本概念和 hello world中我们提到着色器程序（Shader）的最终目的就是确定图形的顶点（Vertex）坐标和片元（Fragment）颜色。其实这正是 OpenGL 提供的最基本、最核心的操作原语，我们想要用 OpenGL 实现任何效果，无论是静止的光影、色彩、形状，还是运动的物理效果、粒子效果，归根结底都是要根据时间和位置确定顶点坐标和片元颜色。不过这个归根结底说得轻巧...
Android OpenGL之二图像旋转实例
学习的最佳方式，就是把它写下来!
08-21 4601
实现GLSurfaceView.Renderer： public class MyRenderer implements GLSurfaceView.Renderer {     //GLSurfaceView的被创建时回调该方法     @Override     public void onSurfaceCreated(GL10 gl, EGLConfig config) {  
android opengl es 控制 贴图旋转
c553110519的专栏
06-06 1766
android opengl es 控制 贴图旋转 摘要：控制贴图旋转有很多种方式，通过片段着色语言或者顶点着色语言可以达到控制贴图旋转的目的，本文讲述一种更简单的控制方式，通过控制顶多坐标控制贴图旋转。 1. 顶点坐标 正常情况下顶点坐标如下所示 private float[] mVerticesData = { -1.0f, -1.0f, 0.0f, 1.0f, -
android studio 3.6.3采用opengles 2.0画不同旋转位置与方向的球
qq_25579995的博客
07-01 483
适用于初学opengles的同学。 1，需求如下几点 1），采用android studio 3.6.3环境，使用opengles 2.0 2），使用着色器语言绘制颜色部分，颜色为一种纯颜色 3），球体自旋，旋转方向不同,两个球，球用线条绘制 4），球体绕过原点的轴旋转与不过原点的轴旋转 2，新建一个功能类，公共功能放在该类里面，类名UtilityFunction.class 2.1，在该类添加一功能函数genSphereCoordinates，为获取球体坐标 public class UtilityFun
【OpenGL ES】基于ValueAnimator的旋转、平移、缩放动效
little_fat_sheep
03-23 4751
1 前言 ValueAnimator 基于 Choreographer 的 frame callback 机制，周期性（约16.7ms，与屏幕帧率相关）执行其 doAnimationFrame() 方法，回调监听器中相应方法，刷新 UI 实现动画效果。 ValueAnimator 是 Android 系统提供的时钟回调类，可以为其提供插值器，并注册 AnimatorUpdateListener 监听器、AnimatorUpdateListener 监听器。当调用 Valu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

信必诺

嗨，支持下哥们呗。

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

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

打赏作者

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

抵扣说明：

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

余额充值