(此节内容对应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;
}
#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();
}
相关推荐
本话题将深入探讨如何使用OpenGLES加载TGA（Truevision Targa）和BMP（Bitmap）文件作为纹理，同时关注压缩与非压缩格式的应用。 TGA是一种图像文件格式，支持未压缩和RLE（Run Length Encoding）压缩两种形式。非...
本篇文章将深入探讨如何读取压缩和非压缩的TGA图像，并了解它们在OpenGL中的应用。 首先，我们需要了解TGA文件的结构。TGA文件头包含图像的宽度、高度、颜色类型和图像类型等信息。其中，图像类型字段标识了图像...
通过这节课的学习，你应该掌握了如何在OpenGL中处理TGA文件，包括读取、解码和加载到纹理对象。这个技能对于创建复杂的3D场景和应用是至关重要的，因为高质量的纹理能显著提升视觉效果。同时，了解不同的图像格式和...
在“易语言源码易语言OpenGL教程第33课TGA文件源码.rar”这个压缩包中，我们可以深入学习易语言与OpenGL结合使用来处理图形图像，特别是关于TGA（Truevision TGA或Targa文件格式）的知识点。 OpenGL是一个跨语言、...
使用者可以借此学习如何使用OpenGL和相关的库来创建交互式3D图形应用。 以上是根据提供的信息解析出的OpenGL相关知识点，这些知识对于开发3D图形应用程序，尤其是游戏开发和科学可视化至关重要。通过理解和掌握这些...
- **知识点介绍**：介绍如何加载压缩和未压缩的TGA格式纹理。 - **实践要点**：学习TGA格式的相关知识。 **34. 通过高度映射创建美丽的景观 (Lesson 34)** - **知识点介绍**：介绍如何使用高度映射技术创建逼真的...
- **压缩与非压缩TGA文件的加载**：学习如何加载不同格式的纹理文件。 - **高度映射**：通过高度图创建具有复杂地形的景观。 - **AVI文件播放**：介绍如何在OpenGL应用程序中嵌入视频。 - **径向模糊与渲染到纹理**...
33. **加载压缩和未压缩的TGA图像**：讲解了如何处理不同格式的纹理图像。 34. **通过高度映射创建美丽的风景**：展示了如何使用高度映射技术生成地形。 35. **在OpenGL中播放AVI文件**：介绍了如何在OpenGL应用...
在这一课里，你将学会如何加载压缩和为压缩的TGA文件，由于它使用RLE压缩，所以非常的简单，你能很快地熟悉它的。 34.从高度图生成的美丽地形 这一课将教会你如何从一个2D的灰度图创建地形 35.在OpenGL中...
4. **纹理压缩**：虽然SOIL2本身不直接支持纹理压缩，但它可以加载已压缩的纹理文件，如DDS格式，然后由OpenGL内部处理压缩。 5. **自定义扩展**：SOIL2的设计允许开发者添加自定义的图像格式加载器或扩展其功能，...
在OpenGL编程中，图像数据经常需要预先加载到纹理中，而SOIL库则简化了这个过程，支持包括BMP、PNG、JPEG、TGA、HDR等多种常见的图像格式。 使用SOIL库，开发者可以快速地将图片文件转换为OpenGL兼容的纹理对象。库...
4. **SOIL.lib**：Simple OpenGL Image Library（SOIL）是一个小巧的库，用于加载和管理图像文件，如JPEG、PNG、BMP和TGA等。在OpenGL中加载纹理时，SOIL提供了简洁的接口，减少了处理图像数据的代码量。 在使用这...
在这一课里，你将学会如何加载压缩和为压缩的TGA文件，由于它使用RLE压缩，所以非常的简单，你能很快地熟悉它的。 34.从高度图生成的美丽地形 这一课将教会你如何从一个2D的灰度图创建地形 35.在OpenGL中播放AVI...
接下来，我们将学习如何利用OpenGL库在窗口中显示TGA图像。首先，创建一个OpenGL上下文并初始化必要的设置。然后，分配内存空间，将解析出的TGA图像数据复制到显存中。使用`glTexImage2D`函数加载纹理，指定纹理目标...
在OpenGL编程中，图像加载是一个常见的需求，例如加载纹理贴图到三维模型上。SOIL库正是为了解决这一问题而设计的，它支持多种常见的图像格式，如BMP、PNG、TGA、JPG等，使得开发者无需关注复杂的图像编码细节，就能...
NeHe OpenGL教程（中英文版附带VC++源码）中英文...加载压缩和未压缩的TGA文件 从高度图生成地形 http://ieee.org.cn/dispbbs.asp?boardID=61&ID=54271 Lesson 35-lesson 36 在OpenGL中播放AVI 放射模糊和渲染到纹理 ...
“gltf”是OpenGL传输格式（GL Transmission Format）的缩写，是一种开放标准的3D模型格式，用于高效地传输和加载3D模型，常用于Web和游戏开发。这表明这个插件可能也支持将TGA图像集成到gltf格式的3D场景中。 在...
总的来说，"grass.tga.zip_OpenGL_Visual_C++_"项目展示了如何结合OpenGL图形库和Visual C++的编程能力，实现透明纹理的加载和应用，从而创建出逼真的3D草地效果。这对于游戏开发和模拟应用来说是非常关键的技术。...
NeHe OpenGL教程（中英文版附带VC++源码）中英文...加载压缩和未压缩的TGA文件 从高度图生成地形 http://ieee.org.cn/dispbbs.asp?boardID=61&ID=54271 Lesson 35-lesson 36 在OpenGL中播放AVI 放射模糊和渲染到纹理 ...
3. 纹理压缩：为了节省内存和提高性能，可能需要对纹理数据进行压缩，如S3TC（S3 Texture Compression）或EAC（Embedded Block Compression）等格式。 4. 纹理对象的生命周期管理：创建、绑定、更新和释放纹理对象，...