OpenGL学习三十五：加载压缩TGA

最新推荐文章于 2022-03-11 13:10:37 发布
最新推荐文章于 2022-03-11 13:10:37 发布
阅读量1.2k 收藏 2
点赞数
文章标签： OpenGL 图形
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiankefeng19850520/article/details/18658939
版权

(此节内容对应NEHE教程第33课)

 

利用压缩算法可以减低图片大小。降低图片存储所需的物理存储空间，但是也会相应的增加图片解压缩带来的时间消耗

对于TGA文件的压缩可以简单理解为，在图片信息存储区。并不是把每一个像素点的RGB值都进行存储，而是临近的像素点如果RGB值相同，那么进行合并形成“块”对于一个”块“来说 他们有一个共同的RGB值，但是块是由很多个像素点组成的


0~~11头信息第3位（2）是2 代表未压缩
第3位（2）是10 代表未压缩RLE压缩
12~13图像宽度byte[13]*256+byte[12]
14~15图像高度byte[15]*256+byte[14]
16图像每像素存储占用位（bit）数24或32
接下来读一个字符 代表接下来的”块“中包含的像素点数 用chumk代替
如果 0<=chumk<=127 代表接下来的 chumk+1个像素点的RGB值都不同，因此每一个都需要读取

如果 128<=chumk 代表接下来的 chumk-127个像素点的RGB值相同，因此只需要读取一次即可


Texture.h

#ifndef __TEXTURE_H__
#define __TEXTURE_H__

#pragma comment(lib, "Opengl32.lib")					

#include <windows.h>								
								
typedef	struct									
{
	GLubyte	* imageData;								
	GLuint	bpp;										
	GLuint	width;										
	GLuint	height;										
	GLuint	texID;										
	GLuint	type;				
} Texture;	

#endif

Tga.h 

#ifndef __TGA_H__
#define __TGA_H__

#pragma comment(lib, "Opengl32.lib")				

#include <windows.h>							
#include "texture.h"

typedef struct
{
	GLubyte Header[12];									
} TGAHeader;


typedef struct
{
	GLubyte		header[6];							
	GLuint		bytesPerPixel;							
	GLuint		imageSize;							
	GLuint		temp;								
	GLuint		type;	
	GLuint		Height;									
	GLuint		Width;									
	GLuint		Bpp;									
} TGA;


TGAHeader tgaheader;								
TGA tga;												


GLubyte uTGAcompare[12] = {0,0,2, 0,0,0,0,0,0,0,0,0};	
GLubyte cTGAcompare[12] = {0,0,10,0,0,0,0,0,0,0,0,0};	
bool LoadUncompressedTGA(Texture *, char *, FILE *);	
bool LoadCompressedTGA(Texture *, char *, FILE *);		

#endif

TGALoader.cpp 

#include "tga.h"

bool LoadTGA(Texture * texture, char * filename)				
{
	FILE * fTGA;									
	fTGA = fopen(filename, "rb");								

	if(fTGA == NULL)										
	{
		MessageBox(NULL, "Could not open texture file", "ERROR", MB_OK);	
		return false;													
	}

	if(fread(&tgaheader, sizeof(TGAHeader), 1, fTGA) == 0)					
	{
		MessageBox(NULL, "Could not read file header", "ERROR", MB_OK);		e
		if(fTGA != NULL)													
		{
			fclose(fTGA);													
		}
		return false;														
	}

	if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)				
	{																		
		LoadUncompressedTGA(texture, filename, fTGA);					
	}
	else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)		
	{																		
		LoadCompressedTGA(texture, filename, fTGA);						
	}
	else																
	{
		MessageBox(NULL, "TGA file be type 2 or type 10 ", "Invalid Image", MB_OK);	
		fclose(fTGA);
		return false;															
	}
	return true;														
}

bool LoadUncompressedTGA(Texture * texture, char * filename, FILE * fTGA)	
{																		
	if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)					
	{										
		MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);		
		if(fTGA != NULL)													
		{
			fclose(fTGA);												
		}
		return false;														
	}	

	texture->width  = tga.header[1] * 256 + tga.header[0];				
	texture->height = tga.header[3] * 256 + tga.header[2];					
	texture->bpp	= tga.header[4];									
	tga.Width		= texture->width;															
	tga.Height		= texture->height;									
	tga.Bpp			= texture->bpp;											

	if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32)))	
	{
		MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);	
		if(fTGA != NULL)													
		{
			fclose(fTGA);													
		}
		return false;														
	}

	if(texture->bpp == 24)													
		texture->type	= GL_RGB;											
	else																	
		texture->type	= GL_RGBA;										

	tga.bytesPerPixel	= (tga.Bpp / 8);								
	tga.imageSize		= (tga.bytesPerPixel * tga.Width * tga.Height);		
	texture->imageData	= (GLubyte *)malloc(tga.imageSize);					

	if(texture->imageData == NULL)											
	{
		MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);	
		fclose(fTGA);														
		return false;													
	}

	if(fread(texture->imageData, 1, tga.imageSize, fTGA) != tga.imageSize)
	{
		MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);		
		if(texture->imageData != NULL)										
		{
			free(texture->imageData);									
		}
		fclose(fTGA);														
		return false;														
	}

	// Byte Swapping Optimized By Steve Thomas
	for(GLuint cswap = 0; cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel)
	{
		texture->imageData[cswap] ^= texture->imageData[cswap+2] ^=
		texture->imageData[cswap] ^= texture->imageData[cswap+2];
	}

	fclose(fTGA);															
	return true;															
}

bool LoadCompressedTGA(Texture * texture, char * filename, FILE * fTGA)		
{ 
	if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)				
	{
		MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);		
		if(fTGA != NULL)													
		{
			fclose(fTGA);												
		}
		return false;														
	}

	texture->width  = tga.header[1] * 256 + tga.header[0];					
	texture->height = tga.header[3] * 256 + tga.header[2];					
	texture->bpp	= tga.header[4];										
	tga.Width		= texture->width;										
	tga.Height		= texture->height;										
	tga.Bpp			= texture->bpp;											

	if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32)))	
	{
		MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);	
		if(fTGA != NULL)												
		{
			fclose(fTGA);												
		}
		return false;														
	}

	if(texture->bpp == 24)													
		texture->type	= GL_RGB;											
	else																	
		texture->type	= GL_RGBA;										

	tga.bytesPerPixel	= (tga.Bpp / 8);									
	tga.imageSize		= (tga.bytesPerPixel * tga.Width * tga.Height);		
	texture->imageData	= (GLubyte *)malloc(tga.imageSize);				

	if(texture->imageData == NULL)											
		MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);	
		fclose(fTGA);														
		return false;														
	}

	GLuint pixelcount	= tga.Height * tga.Width;							
	GLuint currentpixel	= 0;											
	GLuint currentbyte	= 0;												
	GLubyte * colorbuffer = (GLubyte *)malloc(tga.bytesPerPixel);		

	do
	{
		GLubyte chunkheader = 0;											

		if(fread(&chunkheader, sizeof(GLubyte), 1, fTGA) == 0)				
		{
			MessageBox(NULL, "Could not read RLE header", "ERROR", MB_OK);	
			if(fTGA != NULL)												
			{
				fclose(fTGA);											
			}
			if(texture->imageData != NULL)								
			{
				free(texture->imageData);								
			}
			return false;													
		}

		if(chunkheader < 128)												
		{																	
			chunkheader++;												
			for(short counter = 0; counter < chunkheader; counter++)		
			{
				if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel) 
				{
					MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);		

					if(fTGA != NULL)													
					{
						fclose(fTGA);													
					}

					if(colorbuffer != NULL)												
					{
						free(colorbuffer);												
					}

					if(texture->imageData != NULL)										
					{
						free(texture->imageData);										
					}

					return false;														
				}
																						
				texture->imageData[currentbyte		] = colorbuffer[2];				   
				texture->imageData[currentbyte + 1	] = colorbuffer[1];
				texture->imageData[currentbyte + 2	] = colorbuffer[0];

				if(tga.bytesPerPixel == 4)												
				{
					texture->imageData[currentbyte + 3] = colorbuffer[3];				
				}

				currentbyte += tga.bytesPerPixel;										
				currentpixel++;															

				if(currentpixel > pixelcount)											
				{
					MessageBox(NULL, "Too many pixels read", "ERROR", NULL);			

					if(fTGA != NULL)													
					{
						fclose(fTGA);												
					}	

					if(colorbuffer != NULL)												
					{
						free(colorbuffer);												
					}

					if(texture->imageData != NULL)										
					{
						free(texture->imageData);										
					}

					return false;														
				}
			}
		}
		else																			
		{
			chunkheader -= 127;															
			if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)		
			{	
				MessageBox(NULL, "Could not read from file", "ERROR", MB_OK);			

				if(fTGA != NULL)														
				{
					fclose(fTGA);														
				}

				if(colorbuffer != NULL)													
				{
					free(colorbuffer);												
				}

				if(texture->imageData != NULL)											
				{
					free(texture->imageData);										
				}

				return false;															
			}

			for(short counter = 0; counter < chunkheader; counter++)					
			{																			
				texture->imageData[currentbyte		] = colorbuffer[2];				
				texture->imageData[currentbyte + 1	] = colorbuffer[1];
				texture->imageData[currentbyte + 2	] = colorbuffer[0];

				if(tga.bytesPerPixel == 4)												
				{
					texture->imageData[currentbyte + 3] = colorbuffer[3];				
				}

				currentbyte += tga.bytesPerPixel;										
				currentpixel++;															
				if(currentpixel > pixelcount)											
				{
					MessageBox(NULL, "Too many pixels read", "ERROR", NULL);			

					if(fTGA != NULL)													
					{
						fclose(fTGA);													
					}	

					if(colorbuffer != NULL)												
					{
						free(colorbuffer);												
					}

					if(texture->imageData != NULL)										
					{
						free(texture->imageData);									
					}

					return false;														
				}
			}
		}
	}

	while(currentpixel < pixelcount);													
	fclose(fTGA);																		
	return true;																		
}

main.cpp

#include "header.h"											
#include "texture.h"											

bool LoadTGA(Texture *, char *);								

float	spin;													

Texture texture[2];												

LRESULT	CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);			

int LoadGLTextures()											
{
	int Status=FALSE;											

	// Load The Bitmap, Check For Errors.
	if (LoadTGA(&texture[0], "Data/Uncompressed.tga") &&
		LoadTGA(&texture[1], "Data/Compressed.tga"))
	{
		Status=TRUE;											

		for (int loop=0; loop<2; loop++)						
		{
			
			glGenTextures(1, &texture[loop].texID);				
			glBindTexture(GL_TEXTURE_2D, texture[loop].texID);
			glTexImage2D(GL_TEXTURE_2D, 0, texture[loop].bpp / 8, texture[loop].width, texture[loop].height, 0, texture[loop].type, GL_UNSIGNED_BYTE, texture[loop].imageData);
			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

			if (texture[loop].imageData)						
			{
				free(texture[loop].imageData);					
			}
		}
	}
	return Status;											
}

void ReSizeGLScene(GLsizei width, GLsizei height)				
{
	if (height==0)												
	{
		height=1;										
	}

	glViewport(0,0,width,height);							

	glMatrixMode(GL_PROJECTION);							
	glLoadIdentity();										

	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

	glMatrixMode(GL_MODELVIEW);									
	glLoadIdentity();										
}

int InitGL(void)												
{
	if (!LoadGLTextures())									
	{
		return FALSE;											
	}

	glEnable(GL_TEXTURE_2D);									
	glShadeModel(GL_SMOOTH);								
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);						
	glClearDepth(1.0f);											
	glEnable(GL_DEPTH_TEST);									
	glDepthFunc(GL_LEQUAL);									
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);			

	return TRUE;											
}

void DrawGLScene(void)											
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		
	glLoadIdentity();											
	glTranslatef(0.0f,0.0f,-10.0f);								

	spin+=0.05f;												

	for (int loop=0; loop<20; loop++)						
	{
		glPushMatrix();											
		glRotatef(spin+loop*18.0f,1.0f,0.0f,0.0f);			
		glTranslatef(-2.0f,2.0f,0.0f);							

		glBindTexture(GL_TEXTURE_2D, texture[0].texID);			
		glBegin(GL_QUADS);									
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, 0.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, 0.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 0.0f);
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
		glEnd();												
		glPopMatrix();											

		glPushMatrix();										
		glTranslatef(2.0f,0.0f,0.0f);							
		glRotatef(spin+loop*36.0f,0.0f,1.0f,0.0f);				
		glTranslatef(1.0f,0.0f,0.0f);							

		glBindTexture(GL_TEXTURE_2D, texture[1].texID);			
		glBegin(GL_QUADS);										
			glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f, 0.0f);
			glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f, 0.0f);
			glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, -1.0f, 0.0f);
			glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
		glEnd();												
		glPopMatrix();											
	}
	glFlush();											
}



void rotate()
{
	spin+=0.05f;
	glutPostRedisplay();
}
void keyboard(unsigned char key,int x,int y)
{
	switch (key)
	{

	case 'S':
		glutIdleFunc(rotate);
		break;
	case 'R':
		glutIdleFunc(NULL);
		break;
	}

}


int main(int argc,char **argv)
{
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
	glutInitWindowSize(800,600);
	glutInitWindowPosition(100,100);
	glutCreateWindow("加载压缩TGA");
	InitGL();
	glutDisplayFunc(DrawGLScene);
	glutKeyboardFunc(keyboard);
	glutReshapeFunc(ReSizeGLScene);
	glutMainLoop();
}


寻找幸存者
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Three.js - 加载 TGA 格式的纹理
ithanmang
09-05 4978
1、TGA格式 TGA（Targa）格式是计算机上应用最广泛的图象格式。 在兼顾了BMP的图象质量的同时又兼顾了JPEG的体积优势。 并且还有自身的特点：通道效果、方向性。 在CG领域常作为影视动画的序列输出格式，因为兼具体积小和效果清晰的特点。 TGA的结构比较简单，属于一种图形、图像数据的通用格式，在多媒体领域有很大影响，是计算机生成图像向电视转换的一种首选格式。 TGA...
OpenGLES加载tga(压缩/非压缩)、bmp文件为纹理
03-04
在嵌入式编程中，资源是很重要的，如果纹理文件经过压缩后的质量也能满足要求，那就尽量用压缩格式来做纹理吧。
【数据压缩】TGA文件格式分析
spadeK2020的博客
03-11 4015
这里写自定义目录标题欢迎使用Markdown编辑器前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 提示：文章写完后，目录可
Three.js 导入FBX模型 时 加载GTA 贴图问题
Gentle02的博客
04-08 3015
最近在学习three.js的时候 ，发现按照官网的例子导入FBX模型，模型显示黑色 ，没有材质显示。故特此记录解决方法 1.引入FBXLoader 与 TGALoader import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader import { TGALoader } from 'three/examples/jsm/loaders/TGALoader const fbxloader =new FBXLoader()
数据压缩4 | TGA文件格式分析
月婵婵的程序媛生涯
03-24 1147
目录一、简介二、结构1. TGA文件头2. 图像/颜色表数据3. 开发者区域，扩展区域，文件尾三、压缩算法三、总结 一、简介 TGA是由美国Truevision公司为其显示卡开发的一种图像文件格式，已被国际上的图形、图像工业所接受。现已成为数字化图像，以及运用光线跟踪算法所产生的高质量图像的常用格式。TGA文件的扩展名为.tga，该格式支持压缩，使用不失真的压缩算法，可以带通道图，另外还支持行程编码压缩。 ——来自360百科 问题 .tga结构是怎样的？ 如何压缩，算法是什么？ 光线追踪算法 二、结
数据压缩（5）：分析TGA文件
weixin_46338503的博客
03-29 340
作业：分析一个png图像格式文件 这是一个png图像 二进制打开 图像说明部分： 图像的格式，深度，高度，宽度，调色板，压缩方法等 这表示它是一个png文件 这是图像的宽高 这是图像数据部分：描述图像每个像素的数据 ...
Nehe的OpenGL教程电子书
04-07
在这一课里，你将学会如何加载压缩和为压缩的TGA文件，由于它使用RLE压缩，所以非常的简单，你能很快地熟悉它的。 34.从高度图生成的美丽地形 这一课将教会你如何从一个2D的灰度图创建地形 35.在OpenGL中...
OPenGL编程书籍
07-22
在这一课里，你将学会如何加载压缩和为压缩的TGA文件，由于它使用RLE压缩，所以非常的简单，你能很快地熟悉它的。 34.从高度图生成的美丽地形 这一课将教会你如何从一个2D的灰度图创建地形 35.在OpenGL中播放AVI...
NeHe lesson08.
05-25
NeHe OpenGL教程（中英文版附带VC++源码）中英文...加载压缩和未压缩的TGA文件 从高度图生成地形 http://ieee.org.cn/dispbbs.asp?boardID=61&ID=54271 Lesson 35-lesson 36 在OpenGL中播放AVI 放射模糊和渲染到纹理 ...
NeHe lesson10
05-25
NeHe OpenGL教程（中英文版附带VC++源码）中英文...加载压缩和未压缩的TGA文件 从高度图生成地形 http://ieee.org.cn/dispbbs.asp?boardID=61&ID=54271 Lesson 35-lesson 36 在OpenGL中播放AVI 放射模糊和渲染到纹理 ...
读取压缩/非压缩TGA图片
12-29
可读取压缩或非压缩的TGA格式的图像，可用于OpenGL中的贴图。尤其是压缩后的TGA图像格式在使用上不但小，而且还很方便，可包含透明通道。优于BMP和JPEG的使用
c++生成tga文件
08-19
TGA格式(Tagged Graphics)是由美国Truevision公司为其显示卡开发的一种图像文件格式，文件后缀为"．tga"，已被国际上的图形、图像工业所接受。 TGA的结构比较简单，属于一种图形、图像数据的通用格式，在多媒体领域有很大影响，是计算机生成图像向电视转换的一种首选格式。　　TGA图像格式最大的特点是可以做出不规则形状的图形、图像文件，一般图形、图像文件都为四方形，若需要有圆形、菱形甚至是缕空的图像文件时，TGA可就派上用场了! TGA格式支持压缩，使用不失真的压缩算法。　　TGA格式是Truevision公司设计并负责解释的图像格式。TGA也包含了多种变体，TGA文件的第三个字节用来区别不是TGA的文件。
libtga-开源
05-09
无效。 用于读取/写入TGA图像的库
tga-开源
04-26
TGA是一个解决古代棋盘游戏中生与死问题的程序。 估计的力量在圭/丹级别的边界上。 程序以命令行为导向，在SGF中要求/提供输入和输出。
THREE各种格式文件加载合集*Loader.js
10-23
截止于2017年10月23日THREE官网支持的所有*Loader.js 3MFLoader.js AMFLoader.js AssimpJSONLoader.js AssimpLoader.js AWDLoader.js BabylonLoader.js BinaryLoader.js BVHLoader.js ColladaLoader.js ColladaLoader2.js DDSLoader.js FBXLoader.js GLTFLoader.js HDRCubeTextureLoader.js ImageBitmapLoader.js KMZLoader.js MD2Loader.js MMDLoader.js MTLLoader.js NRRDLoader.js OBJLoader.js OBJLoader2.js PCDLoader.js PDBLoader.js PlayCanvasLoader.js PLYLoader.js PRWMLoader.js PVRLoader.js RGBELoader.js STLLoader.js SVGLoader.js TDSLoader.js TGALoader.js TTFLoader.js UTF8Loader.js VRMLLoader.js VTKLoader.js WWOBJLoader2.js XLoader.js
java练习题13.txt
最新发布
04-18
java练习题
云南省移动应用大赛模板.zip
04-18
云南省移动应用大赛模板.zip
HTML5基于SSM校园微公益网站设计可升级SpringBoot源码.7z
04-18
前台技术框架采用Bootstrap，一个高度灵活的HTML5响应式框架，为用户提供了流畅的前端交互体验。程序开发环境支持多样化，无论是myEclipse、Eclipse还是Idea都能轻松应对，结合mysql数据库，确保了数据的高效处理与存储。后台架构则选用SSM组合——SpringMVC、Spring和Mybatis，这一组合以其稳定性和高效性而备受青睐。 校园公益信息关联系统采用b/s架构，实现用户信息、活动类型、公益活动、活动报名、捐款、捐款统计、留言和新闻信息的全面管理。系统分为前台学生端和后台管理员端，满足不同用户群体的需求。 管理员端功能丰富，包括学院管理、活动类型管理、公益活动管理、活动报名管理、捐款信息管理、管理员账号管理、密码修改、捐款统计管理、留言管理和新闻信息管理等。管理员能够灵活添加、修改、删除和查询各类信息，确保信息的准确性和时效性。同时，捐款统计功能以直观的统计图形式展现，为管理员提供决策支持。 学生端则专注于学生的日常需求，包括添加捐款信息、留言、报名活动以及密码修改等。学生可以轻松完成捐款操作，发表留言，查看并报名公益活动，随时修改个人密码，确保账
实验五:基于opengl的三维变换与投影
11-10
在实验五中，我们学习了基于OpenGL的三维变换和投影。通过这个实验，我们能够更好地理解和掌握OpenGL图形库的基本概念和使用方法。 首先，我们学习了OpenGL的三维变换。三维变换包括平移、旋转和缩放。平移是将物体...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寻找幸存者

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值