openGL初学笔记3：纹理

已于 2022-10-09 15:14:47 修改
阅读量146 收藏
点赞数 1
文章标签： c++ 开发语言
于 2022-10-08 17:29:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45539300/article/details/127212793
版权 
/* 引入相应的库 */
#include <iostream>
using namespace std;
#define GLEW_STATIC	
#include"Shader.h"
#include <GLFW/glfw3.h>
#include <GL/glew.h>
#include <SOIL2/stb_image.h>
#include <SOIL2/SOIL2.h>

int width, height;

//* (样例一：木板) 编写各顶点位置  + 读取纹理 */
GLfloat vertices_1[] =
{
	//position				// color				// texture coords(纹理坐标)
	0.5f, 0.5f, 0.0f,		0.0f, 0.0f, 0.0f,		2.0f, 2.0f,		// 右上顶点		编号0
	0.5f, -0.5f, 0.0f,		0.0f, 0.0f, 0.0f,		2.0f, 0.0f,		// 右下顶点		编号1
	-0.5f, -0.5f, 0.0f,		0.0f, 0.0f, 0.0f,		0.0f, 0.0f,		// 左下顶点		编号2
	-0.5f, 0.5f, 0.0f,		0.0f, 0.0f, 0.0f,		0.0f, 2.0f		// 左上顶点		编号3
};
unsigned char* image = SOIL_load_image("T_image3.png", &width, &height, 0, SOIL_LOAD_RGBA);			// 获取图片


/* 四个顶点的连接信息给出来 */
GLuint indices_1[] =
{
	0, 1, 3,		// 序号为 0、1、3 的顶点组合成一个三角形
	1, 2, 3			// 序号为 1、2、3 的顶点组合成一个三角形
};

const GLint WIDTH = 600, HEIGHT = 600;

int main()
{
	glfwInit();
	GLFWwindow* window_1 = glfwCreateWindow(WIDTH, HEIGHT, "Learn OpenGL Texture test", nullptr, nullptr);
	int screenWidth_1, screenHeight_1;
	glfwGetFramebufferSize(window_1, &screenWidth_1, &screenHeight_1);
	cout << "screenWidth_1 = " << screenWidth_1 << ", screenHeight = " << screenHeight_1 << endl;
	glfwMakeContextCurrent(window_1);
	glewInit();

	/* 将我们自己设置的着色器文本传进来 */
	Shader ourShader = Shader("shader_v.txt", "shader_f.txt");		// 相对路径

	/* 设置顶点缓冲对象(VBO) + 设置顶点数组对象(VAO) + 索引缓冲对象(EBO)  */
	GLuint VAO, VBO, EBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glGenBuffers(1, &EBO);
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_1), vertices_1, GL_STATIC_DRAW);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices_1), indices_1, GL_STATIC_DRAW);

	/* 设置链接顶点属性 */
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(0);	// 通道 0 打开
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
	glEnableVertexAttribArray(1);	// 通道 1 打开
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
	glEnableVertexAttribArray(2);	// 通道 2 打开


	/* 生成纹理 */
	GLuint texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);			// 读取图片信息
	glGenerateMipmap(GL_TEXTURE_2D);	// 多层渐进纹理
	SOIL_free_image_data(image);

	/* 纹理环绕方式 */
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);	// S 坐标
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);	// T 坐标

	/* 纹理过滤 */
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	/* 纹理单元：下一节重点使用 */
	ourShader.Use();	// don't forget to activate/use the shader before setting uniforms!
	int textureLocation = glGetUniformLocation(ourShader.Program, "ourTexture");	// 找到着色器中 uniform 属性的名为"ourTexture"的纹理的索引
	glUniform1i(textureLocation, 0);		// 告诉 OpenGL 的着色器采样器属于哪个纹理单元	

	/* draw loop 画图循环 */
	while (!glfwWindowShouldClose(window_1))
	{
		/* 视口 + 时间 */
		glViewport(0, 0, screenWidth_1, screenHeight_1);
		glfwPollEvents();

		/* 渲染 + 清除颜色缓冲 */
		glClearColor(0.5f, 0.8f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		/* 生成纹理 */
		glActiveTexture(GL_TEXTURE0);			// 激活 0 号纹理单元。最多 16 个通道
		glBindTexture(GL_TEXTURE_2D, texture);	// 绑定这个纹理到当前激活的纹理目标			

		/* 绘制图形 */
		ourShader.Use();
		glBindVertexArray(VAO);									// 绑定 VAO
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);				// 绑定 EBO
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);	// 画两个三角形 从第0个顶点开始 一共画6次
		glBindVertexArray(0);									// 解绑定 VAO
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);				// 解绑定 EBO
		glBindTexture(GL_TEXTURE_2D, 0);						// 解绑定 纹理

		/* 交换缓冲 */
		glfwSwapBuffers(window_1);
	}

	/* 释放资源 */
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);

	glfwTerminate();	// 结束
	return 0;
}

片段着色器代码

#version 330 core				// 3.30版本
in vec3 ourColor;
in vec2 ourTextureCoords;		// 将纹理坐标引入(从顶点着色器过来的)
out vec4 FragColor;				// 输出是四个浮点数构成的一个向量 RGB+aerfa
uniform sampler2D ourTexture;	// 纹理对象引入(从主函数过来的)
void main()
{
	// FragColor = vec4(ourColor, 1.0f);
	FragColor = texture(ourTexture, ourTextureCoords);	// 采样获得纹理坐标
}

顶点着色器代码

#version 330 core		// 3.30版本 
layout(location = 0) in vec3 position;			// 位置变量的顶点属性位置值为 0
layout(location = 1) in vec3 color;				// 颜色变量的顶点属性位置值为 1
layout(location = 2) in vec2 textureCoords;		// 纹理坐标只有两个浮点数 (s,t), 属性位置值为 2 
out vec3 ourColor;								
out vec2 ourTextureCoords;						// 将纹理坐标传到片元着色器
void main()
{
	gl_Position = vec4(position, 1.0f);			// 核心函数(位置信息赋值)
	// ourColor = color;
	ourTextureCoords = vec2(textureCoords.x, 1-textureCoords.y);
}

着色器类


#pragma once	// 为了避免同一个头文件被包含（include）多次
#include<string>
#include<fstream>
#include<sstream>
#include<iostream>
using namespace std;
#include <GL\glew.h>
#include <GLFW\glfw3.h>
// 我们自己的着色器
class Shader
{
private:
	unsigned int vertex, fragment;	// 顶点着色器 和 片元着色器 
public:
	unsigned int Program;				// 着色器程序的ID

	// Constructor(着色器构造函数)
	Shader(const char* vertexPath, const char* fragmentPath)
	{
		// 文件读取系列的变量定义
		string vertexCode;
		string fragmentCode;
		ifstream vShaderFile;
		ifstream fShaderFile;

		// 异常机制处理：保证ifstream对象可以抛出异常：
		vShaderFile.exceptions(ifstream::badbit);
		fShaderFile.exceptions(ifstream::badbit);

		try
		{
			// 打开文件
			vShaderFile.open(vertexPath);
			fShaderFile.open(fragmentPath);
			stringstream vShaderStream, fShaderStream;

			// 读取文件的缓冲内容到数据流中
			vShaderStream << vShaderFile.rdbuf();
			fShaderStream << fShaderFile.rdbuf();

			// 关闭文件处理器
			vShaderFile.close();
			fShaderFile.close();

			// 转换数据流到string
			vertexCode = vShaderStream.str();
			fragmentCode = fShaderStream.str();

		}
		catch (ifstream::failure e) {	// 发生异常时输出
			cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ" << endl;
		}

		/* 将 string 类型的字符串转化为 char数组 类型 */
		const char* vShaderCode = vertexCode.c_str();
		const char* fShaderCode = fragmentCode.c_str();

		/* 顶点着色器 */
		vertex = glCreateShader(GL_VERTEX_SHADER);				// 创建顶点着色器对象
		glShaderSource(vertex, 1, &vShaderCode, NULL);			// 将顶点着色器的内容传进来
		glCompileShader(vertex);								// 编译顶点着色器
		int flag;                                             // 用于判断编译是否成功
		char infoLog[512];
		glGetShaderiv(vertex, GL_COMPILE_STATUS, &flag); // 获取编译状态
		if (!flag)
		{
			glGetShaderInfoLog(vertex, 512, NULL, infoLog);
			cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << endl;
		}

		/* 片元着色器 */
		fragment = glCreateShader(GL_FRAGMENT_SHADER);			// 创建片元着色器对象
		glShaderSource(fragment, 1, &fShaderCode, NULL);		// 将片元着色器的内容传进来
		glCompileShader(fragment);								// 编译顶点着色器
		glGetShaderiv(fragment, GL_COMPILE_STATUS, &flag);		// 获取编译状态
		if (!flag)
		{
			glGetShaderInfoLog(fragment, 512, NULL, infoLog);
			cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
		}

		/* 着色器程序 */
		this->Program = glCreateProgram();
		glAttachShader(this->Program, vertex);
		glAttachShader(this->Program, fragment);
		glLinkProgram(this->Program);
		if (!flag)
		{
			glGetProgramInfoLog(this->Program, 512, NULL, infoLog);
			cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
		}
		// 删除着色器，它们已经链接到我们的程序中了，已经不再需要了
		glDeleteShader(vertex);
		glDeleteShader(fragment);
	}

	// Deconstructor(析构函数)
	~Shader()
	{
		glDetachShader(this->Program, vertex);
		glDetachShader(this->Program, fragment);
		glDeleteShader(vertex);
		glDeleteShader(fragment);
		glDeleteProgram(this->Program);
	}

	void Use()
	{
		glUseProgram(this->Program);
	}
};

纹理坐标是作为0.0到1.0范围内的浮点值指定的。纹理坐标命名为s,t,r,q，支持从一维到三位的纹理坐标，并且可以选择一种对坐标进行缩放的方法。
纹理参数通过glTexParameter函数的变量来进行设置。该函数第一个参数指定这些参数将要应用在哪个纹理模式上，第二个参数指定了需要设置哪个纹理参数，最后一个参数用于设置特定的纹理参数的值。
纹理过滤是根据一个拉伸或收缩的纹理贴图计算颜色片段的过程。
不使用Shader.h时的代码

#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <SOIL2/SOIL2.h>
#include <SOIL2/stb_image.h>
#include <sstream>
#include <string>
#include <fstream>

//顶点数组
GLfloat vertex[] =
{
	0.5f,0.5f,0.0f,     0.0f,0.0f,0.0f,    2.0f,2.0f,
	0.5f,-0.5f,0.0f,    0.0f,0.0f,0.0f,    2.0f,0.0f,
	-0.5f,-0.5f,0.0f,   0.0f,0.0f,0.0f,    0.0f,0.0f,
	-0.5f,0.5f,0.0f,    0.0f,0.0f,0.0f,    0.0f,0.2f
};

int height, width;
//获取图片
unsigned char* image = SOIL_load_image("T_image3.png", &width, &height, 0, SOIL_LOAD_RGBA);

//索引数组
unsigned int index[] =
{
	0,1,3,
	1,2,3
};

//创建着色器
unsigned int createshader(std::string vertexshaderPath,std::string flagshaderPath)
{
	//着色器代码
	std::string vertexcode;
	std::string flagcode;
	//着色器代码流
	std::stringstream vertexstream;
	std::stringstream flagstream;
	//着色器文件
	std::ifstream vertexfile;
	std::ifstream flagfile;
	//打开着色器文件
	vertexfile.open(vertexshaderPath);
	flagfile.open(flagshaderPath);
	//读取文件中流
	vertexstream << vertexfile.rdbuf();
	flagstream << flagfile.rdbuf();
	//获取着色器代码
	vertexcode = vertexstream.str();
	flagcode = flagstream.str();
	//转化为数组型
	const char* vertexch = vertexcode.c_str();
	const char* flagch = flagcode.c_str();
	//编译着色器
	unsigned int vertex, flag;
	vertex = glCreateShader(GL_VERTEX_SHADER);
	flag = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(vertex,1,&vertexch,NULL);
	glShaderSource(flag,1,&flagch,NULL);
	glCompileShader(vertex);
	glCompileShader(flag);
	unsigned int program;
	program=glCreateProgram();
	glAttachShader(program,vertex);
	glAttachShader(program,flag);
	glLinkProgram(program);
	return program;
}


int main()
{
	glfwInit();
	GLFWwindow* window = glfwCreateWindow(600,600,"OPENGL2",NULL,NULL);
	int screenWidth, screenHeight;
	glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
	if (!window)
	{
		glfwTerminate();
	}
	glfwMakeContextCurrent(window);
	//glfwSwapInterval(1);
	glewInit();
	//缓冲区
	unsigned int VAO, VBO, EBO;
	glGenBuffers(1,&VAO);
	glGenBuffers(1,&VBO);
	glGenBuffers(1,&EBO);
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER,VBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
	glBufferData(GL_ARRAY_BUFFER,sizeof(vertex),vertex,GL_STATIC_DRAW);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(index),index,GL_STATIC_DRAW);

	//连接顶点
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)0);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
	glEnableVertexAttribArray(2);

	unsigned int shader;
	shader = createshader("shader_v.txt", "shader_f.txt");
	//纹理
	GLuint texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);			
	glGenerateMipmap(GL_TEXTURE_2D);	
	SOIL_free_image_data(image);
	//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	//环绕方式
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);	
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);	
	//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	//过滤
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	glUseProgram(shader);
	int textureLocation = glGetUniformLocation(shader, "ourTexture");	
	glUniform1i(textureLocation, 0);		

	while (!glfwWindowShouldClose(window))
	{
		glClearColor(0.5f, 0.8f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		//生成纹理
		glActiveTexture(GL_TEXTURE0);			
		glBindTexture(GL_TEXTURE_2D, texture);	
		//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

		//生成图形
		glUseProgram(shader);
		glBindVertexArray(VAO);									
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);				
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);	
		glBindVertexArray(0);									
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);				
		glBindTexture(GL_TEXTURE_2D, 0);						
		glfwSwapBuffers(window);
		glfwPollEvents();
	}
	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);

	glfwDestroyWindow(window);
	glfwTerminate();
}

纹理

物载煎蛋煮茶蒸小笼包
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
OpenGL纹理贴图
牵LV小猪精的博客
04-09 7895
OpenGL纹理1. 基本概念2. 纹理环绕方式3. 纹理过滤3.1 GL_NEAREST3.2 GL_LINEAR3.3 多级渐远纹理 (Mipmap)4. 纹理加载与创建4.1 纹理加载4.2 纹理创建4.3 纹理的使用 1. 基本概念 纹理是一个2D图片（甚至也有1D和3D的纹理），它可以用来表示物体的细节特征，希望绘制一个有足够多细节的物体，当然可以用足够多的顶点颜色来描述，但是无疑也增加了许多额外的开销；另一种办法就是使用纹理。 学习之前先展示一张实现的纹理图以更好理解纹理！ 还是这张图为了将纹
OpenGL初学笔记
01-04
OpenGL初学笔记主要针对的是那些刚开始接触图形编程的开发者，尤其适合使用Visual C++ 6.0作为开发环境的初学者。OpenGL是一个强大的、跨平台的图形库，它允许程序员创建复杂的2D和3D图形应用程序。Visual C++ 6.0是...
openGL之纹理
lzz555517的博客
09-06 2174
opengl纹理相关介绍
Unity3d渲染系列教程二 shader基础（译）
qingshui37的专栏
07-08 2420
课程目标：顶点转换像素着色Shader属性从顶点着色器传递数据到片段着色器查看编译的shader代码使用tiling 和offset属性从纹理取样 这是渲染的第二部分教程。第一部分讲解了矩阵。现在是时候开始写我们的第一个shader了。这部分的教程是基于Unity 5.4.0b10. Texturing a sphere.在unity3d中创建一个新的场景。使用默认的相机跟平行光就可以了。接下来让...
OpenGL第五章坐标系统
ahang的博客
05-19 415
这一节对shader类添加了一些函数 在顶点坐标里面使用model view projection变换 需要依次乘以model view projection矩阵注意矩阵的连续乘法是从右到左结合的 glm::mat4 model = glm::mat4(1.0f);//定义一个单位矩阵 projection = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); //perspe
OpenGL 纹理坐标 和 顶点坐标映射关系 详解
热门推荐
风平浪静的专栏
12-12 4万+
看了关于纹理坐标的但是感觉都没有说清楚 特整理如下： 参考文章：http://blog.csdn.NET/meegomeego/article/details/8295660 http://blog.csdn.Net/tiankefeng19850520/article/details/18620779?utm_source=tuicool&utm_medium=referral
OpenGL超级宝典学习笔记：纹理
孙君的空间站
03-10 796
本篇章记录对OpenGL中纹理使用的学习
openGL初学笔记1
weixin_45539300的博客
09-27 162
openGL初学笔记1
OpenGL学习笔记：光照贴图
mumufan05的专栏
09-02 1万+
漫反射贴图 简单说就是在上一节的基础上给物体添加上纹理，主要做两件事，将之前定义的vec3漫反射颜色向量替换为漫反射贴图，删除环境光源 这里就不贴完整例子了，简单说一下着色器的主要修改，添加纹理的部分就不贴了，详见前面纹理部分的章节，记得更新顶点着色器的数据，将纹理添加进去 #version 330 core // 定义材质结构体 struct Material { // vec3 ambi...
android OpenGL学习笔记（一）
03-22
这篇笔记将帮助初学者理解基本概念并开始实践。 首先，OpenGL ES是跨平台的图形库，它提供了丰富的API来创建2D和3D图形。在Android开发环境中，我们通常使用Java或Kotlin通过Android SDK与OpenGL ES交互。为了开始...
webgl学习笔记初学记录00
10-15
它是WebGL学习笔记的重点，特别是在初学者阶段。WebGL的核心是光栅化引擎，它能够根据程序员编写的代码在GPU上绘制点、线和三角形，进而构建复杂的3D场景。 在WebGL中，所有图形渲染都是通过GPU来执行的，这需要...
code__opengl学习笔记1-基本的运行框架
09-22
OpenGL学习笔记1 - 基本的运行框架 在计算机图形学领域，OpenGL是一个广泛使用的跨语言、跨平台的应用程序编程接口（API），用于渲染2D、3D图像。本笔记将聚焦于如何在Visual Studio 2012环境下搭建一个基本的...
openGL入门参考资料
04-18
在配合的文章《OpenGL学习笔记——JNI篇》中，作者通过JNI（Java Native Interface）来演示如何在Java程序中调用OpenGL进行图形绘制。JNI是Java平台的一部分，允许Java代码和其他语言写的代码进行交互，这在需要高...
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 982
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1049
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
C++ std::partial_sort_copy 用法
07-16 296
部分排序，即选出前n个最大值或者最小值，并将其保存到另外一个容器中。
C++的内存管理
最新发布
2301_78694309的博客
07-19 556
C++的内存管理
C语言中的指针函数和函数指针
letterljhx的博客
07-18 294
C语言中的指针函数和函数指针
OpenGL初学者教程：从创建窗口到3D空间
OpenGL教程Nehe版是一个面向初学者的中文教程，旨在帮助学习者轻松入门OpenGL编程。该教程涵盖了一系列课程，从创建基本的OpenGL窗口开始，逐步引导学习者掌握3D图形渲染的基础知识。教程强调实践，鼓励读者通过阅读...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值