NeHe OpenGL教程 第三十三課：TGA檔案

標籤：sso   迴圈   技術   err   管理   hunk   struct   沒有   ror   

轉自【翻譯】NeHe OpenGL 教程

前言

聲明，此 NeHe OpenGL教程系列文章由51部落格yarin翻譯（2010-08-19），本部落格為轉載並稍加整理與修改。對NeHe的OpenGL管線教程的編寫，以及yarn的翻譯整理表示感謝。

 

NeHe OpenGL第三十三課：TGA檔案

載入壓縮和未壓縮的TGA檔案:

在這一課裡，你將學會如何載入壓縮和為壓縮的TGA檔案，由於它使用RLE壓縮，所以非常的簡單，你能很快地熟悉它的。
 
我見過很多人在遊戲開發論壇或其它地方詢問關於TGA讀取的問題。接下來的程式及注釋將會向你展示如何讀取未壓縮的TGA檔案和RLE壓縮的檔案。這個詳細的教程適合於OpenGL，但是我計劃改進它使其在將來更具普遍性。

我們將從兩個標頭檔開始。第一個檔案控制紋理結構，在第二個裡，結構和變數將為程式讀取所用。

就像每個標頭檔那樣，我們需要一些包含保護措施以防止檔案被重複包含。

在檔案的頂部加入這樣幾行程式：

 #ifndef __TEXTURE_H__    // 看看此標頭檔是否已經被包含
 #define __TEXTURE_H__    // 如果沒有，定義它

然後滾動到程式底部並添加： 

 #endif      // __TEXTURE_H__ 結束包含保護

這三行程式防止此檔案被重複包含。檔案中剩下的代碼將處於這頭兩行和這最後一行之間。

在這個標頭檔中，我們將要加入完成每件工作所需的標準標頭檔。在#define __TGA_H__後添加如下幾行：

 #pragma comment(lib, "OpenGL32.lib")  // 連結 Opengl32.lib
 #include <windows.h>   // 標準Windows標頭檔
 #include <stdio.h>    // 標準檔案I/O標頭檔
 #include <gl\gl.h>    // 標準OpenGL標頭檔

第一個標頭檔是標準Windows標頭檔，第二個是為我們稍後的檔案I/O所準備的，第三個是OpenGL32.lib所需的標準OpenGL標頭檔。

我們將需要一塊空間儲存映像資料以及OpenGL產生紋理所需的類型。我們將要用到以下結構：

 typedef struct
 {
  GLubyte* imageData;   // 控制整個映像的顏色值
  GLuint  bpp;    // 控制單位像素的bit數
  GLuint width;    // 整個映像的寬度
  GLuint height;    // 整個映像的高度
  GLuint texID;    // 使用glBindTexture所需的紋理ID.
  GLuint type;     // 描述儲存在*ImageData中的資料(GL_RGB Or GL_RGBA)
 } Texture;

現在說說其它的，更長的標頭檔。同樣我們需要一些包含保護措施，這和上述最後一個是一樣的。

接下來，看看另外兩個結構，它們將在處理TGA檔案的過程中使用。

 typedef struct
 {
  GLubyte Header[12];   // 檔案頭決定檔案類型
 } TGAHeader;

 typedef struct
 {
  GLubyte header[6];    // 控制前6個位元組
  GLuint bytesPerPixel;   // 每像素的位元組數 (3 或 4)
  GLuint imageSize;    // 控制儲存映像所需的記憶體空間
  GLuint type;    // 映像類型 GL_RGB 或 GL_RGBA
  GLuint Height;    // 映像的高度
  GLuint Width;    // 映像寬度
  GLuint Bpp;    // 每像素的位元數 (24 或 32)
 } TGA;

現在我們聲明那兩個結構的一些執行個體，那樣我們可以在程式中使用它們。 

 TGAHeader tgaheader;    // 用來儲存我們的檔案頭
 TGA tga;      // 用來隱藏檔資訊

我們需要定義一對檔案頭，那樣我們能夠告訴程式什麼類型的檔案頭處於有效映像上。如果是未壓縮的TGA映像，前12位元組將會是0 0 2 0 0 0 0 0 0 0 0 0，如果是RLE壓縮的，則是0 0 10 0 0 0 0 0 0 0 0 0。這兩個值允許我們檢查正在讀取的檔案是否有效。

 // 未壓縮的TGA頭
 GLubyte uTGAcompare[12] = {0,0, 2,0,0,0,0,0,0,0,0,0};
 // 壓縮的TGA頭
 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 *);

現在，回到cpp檔案，和程式中真正首當其衝部分，我將會省去一些錯誤訊息處理代碼並且使教程更短、更具可讀性。你可以參看教程包含的檔案（在文章的尾部有連結）。

馬上，我們就可以在檔案開頭包含我們剛剛建立的標頭檔。

 #include "tga.h"    // 包含我們剛剛建立的標頭檔

不我們不需要包含其它任何檔案了，因為我們已經在自己剛剛完成的標頭檔中包含他們了。

接下來，我們要做的事情是看看第一個函數，名為LoadTGA(…)。

 // 讀取一個TGA檔案!
 bool LoadTGA(Texture * texture, char * filename)
 {

它有兩個參數。前者是一個指向紋理結構的指標，你必須在你的代碼中聲明它（見包含的例子）。後者是一個字串，它告訴電腦在哪裡去找你的紋理檔案。

函數的前兩行聲明了一個檔案指標，然後開啟由“filename”參數指定的檔案，它由函數的第二個指標傳遞進去。

 FILE * fTGA;     // 聲明檔案指標
 fTGA = fopen(filename, "rb");   // 以讀模式開啟檔案

接下來的幾行檢查指定的檔案是否已經正確地開啟。 

 if(fTGA == NULL)    // 如果此處有錯誤
 {
  ...Error code...
  return false;    // 返回 False
 }

下一步，我們嘗試讀取檔案的首12個位元組的內容並且將它們儲存在我們的TGAHeader結構中，這樣，我們得以檢查檔案類型。如果fread失敗，則關閉檔案，顯示一個錯誤，並且函數返回false。 

 if(fread(&tgaheader, sizeof(TGAHeader), 1, fTGA) == 0)
 {
  ...Error code here...
  return false;    //  如果失敗則返回 False
 }

接著，通過我們用辛苦編的程式剛讀取的頭，我們繼續嘗試確定檔案類型。這可以告訴我們它是壓縮的、未壓縮甚至是錯誤的檔案類型。為了達到這個目的，我們將會使用memcmp(…)函數。 

 // 如果檔案頭附合未壓縮的檔案頭格式
 if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
 {
  // 讀取未壓縮的TGA檔案
  LoadUncompressedTGA(texture, filename, fTGA);
 }
 // 如果檔案頭附合壓縮的檔案頭格式
 else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
 {
  // 讀取壓縮的TGA格式
  LoadCompressedTGA(texture, filename, fTGA);
 }
 else      // 如果任一個都不符合
 {
  ...Error code here...
  return false;    // 返回 False
 }

我們將要開始讀取一個未壓縮格式檔案的章節。

下面開始我們要做的第一件事，像往常一樣，是函數頭。

 //讀取未壓縮的TGA檔案
 bool LoadUncompressedTGA(Texture * texture, char * filename, FILE * fTGA)
 {

這個函數有3個參數。頭兩個和LoadTGA中的一樣，僅僅是簡單的傳遞。第三個是來自前一個函數中的檔案指標，因此我們沒有丟失我們的空間。

接下來我們試著再從檔案中讀取6個位元組的內容，並且儲存在tga.header中。如果他失敗了，我們運行一些錯誤處理代碼，並且返回false。

 // 嘗試繼續讀取6個位元組的內容
 if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
 {
  ...Error code here...
  return false;    // 返回 False
 }

現在我們有了計算映像的高度、寬度和BPP的全部資訊。我們在紋理和本地結構中都將儲存它。 

 texture->width  = tga.header[1] * 256 + tga.header[0]; // 計算高度
 texture->height = tga.header[3] * 256 + tga.header[2]; // 計算寬度
 texture->bpp = tga.header[4];   // 計算BPP
 tga.Width = texture->width;    // 拷貝Width到本地結構中去
 tga.Height = texture->height;   // 拷貝Height到本地結構中去
 tga.Bpp = texture->bpp;    // 拷貝Bpp到本地結構中去

現在，我們需要確認高度和寬度至少為1個像素，並且bpp是24或32。如果這些值中的任何一個超出了它們的界限，我們將再一次顯示一個錯誤，關閉檔案，並且離開此函數。 

 // 確認所有的資訊都是有效
 if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32)))
 {
  ...Error code here...
  return false;    // 返回 False
 }

接下來我們設定映像的類型。24 bit映像是GL_RGB，32 bit 映像是GL_RGBA 

 if(texture->bpp == 24)    // 是24 bit映像嗎？
 {
  texture->type = GL_RGB;   //如果是，設定類型為GL_RGB
 }
 else      // 如果不是24bit,則必是32bit
 {
  texture->type = GL_RGBA;  //這樣設定類型為GL_RGBA
 }

現在我們計算每像素的位元組數和總共的映像資料。 

 tga.bytesPerPixel = (tga.Bpp / 8);  // 計算BPP
 // 計算儲存映像所需的記憶體
 tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height);

我們需要一些空間去儲存整個映像資料，因此我們將要使用malloc分配正確的記憶體數量

然後我們確認記憶體已經分配，並且它不是NULL。如果出現了錯誤，則運行錯誤處理代碼。

 // 分配記憶體
 texture->imageData = (GLubyte *)malloc(tga.imageSize);
 if(texture->imageData == NULL)   // 確認已經分配成功
 {
  ...Error code here...
  return false;    // 確認已經分配成功
 }

這裡我們嘗試讀取所有的映像資料。如果不能，我們將再次觸發錯誤處理代碼。 

 // 嘗試讀取所有映像資料
 if(fread(texture->imageData, 1, tga.imageSize, fTGA) != tga.imageSize)
 {
  ...Error code here...
  return false;    // 如果不能，返回false
 }

TGA檔案用逆OpenGL需求順序的方式儲存映像，因此我們必須將格式從BGR到RGB。為了達到這一點，我們交換每個像素的第一個和第三個位元組的內容。

Steve Thomas補充：我已經編寫了能稍微更快速讀取TGA檔案的代碼。它涉及到僅用3個二進位操作將BGR轉換到RGB的方法。

然後我們關閉檔案，並且成功退出函數。

 //  開始迴圈
 for(GLuint cswap = 0; cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel)
 {
  // 第一位元組 XOR第三位元組XOR 第一位元組 XOR 第三位元組
  texture->imageData[cswap] ^= texture->imageData[cswap+2] ^=
  texture->imageData[cswap] ^= texture->imageData[cswap+2];
 }

 fclose(fTGA);     // 關閉檔案
 return true;     // 返回成功
}

以上是讀取未壓縮型TGA檔案的方法。讀取RLE壓縮型檔案的步驟稍微難一點。我們像平時一樣讀取檔案頭並且收集高度／寬度／色彩深度，這和讀取未壓縮版本是一致的。 
  
 bool LoadCompressedTGA(Texture * texture, char * filename, FILE * fTGA)
 {
  if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
  {
   ...Error code here...
  }
  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)))
  {
   ...Error code here...
  }        }
  tga.bytesPerPixel = (tga.Bpp / 8);
  tga.imageSize  = (tga.bytesPerPixel * tga.Width * tga.Height);

現在我們需要分配儲存映像所需的空間，這是為我們解壓縮之後準備的，我們將使用malloc。如果記憶體配置失敗，運行錯誤處理代碼，並且返回false。 
  
 // 分配儲存映像所需的記憶體空間
 texture->imageData = (GLubyte *)malloc(tga.imageSize);
 if(texture->imageData == NULL)   // 如果不能分配記憶體
 {
  ...Error code here...
  return false;    // 返回 False
 }

下一步我們需要決定組成映像的像素數。我們將它儲存在變數“pixelcount”中。

我們也需要儲存當前所處的像素，以及我們正在寫入的映像資料的位元組，這樣避免溢出寫入過多的舊資料。

我們將要分配足夠的記憶體來儲存一個像素。

 GLuint pixelcount = tga.Height * tga.Width; // 映像中的像素數
 GLuint currentpixel = 0;  // 當前正在讀取的像素
 GLuint currentbyte = 0;   // 當前正在向映像中寫入的像素
// 一個像素的儲存空間
 GLubyte * colorbuffer = (GLubyte *)malloc(tga.bytesPerPixel);

接下來我們將要進行一個大迴圈。

讓我們將它分解為更多可管理的塊。

首先我們聲明一個變數來儲存“塊”頭。塊頭指示接下來的段是RLE還是RAW，它的長度是多少。如果一位元組頭小於等於127，則它是一個RAW頭。頭的值是顏色數，是負數，在我們處理其它頭位元組之前，我們先讀取它並且拷貝到記憶體中。這樣我們將我們得到的值加1，然後讀取大量像素並且將它們拷貝到ImageData中，就像我們處理未壓縮型映像一樣。如果頭大於127，那麼它是下一個像素值隨後將要重複的次數。要擷取實際重複的數量，我們將它減去127以除去1bit的的頭標示符。然後我們讀取下一個像素並且依照上述次數連續拷貝它到記憶體中。

 do      // 開始迴圈
 {
 GLubyte chunkheader = 0;    // 儲存Id塊值的變數
 if(fread(&chunkheader, sizeof(GLubyte), 1, fTGA) == 0) // 嘗試讀取塊的頭
 {
  ...Error code...
  return false;    // If It Fails, Return False
 }

接下來我們將要看看它是否是RAW頭。如果是，我們需要將此變數的值加1以擷取緊隨頭之後的像素總數。 

 if(chunkheader < 128)    // 如果是RAW塊
 {
  chunkheader++;    // 變數值加1以擷取RAW像素的總數

我們開啟另一個迴圈讀取所有的顏色資訊。它將會迴圈塊頭中指定的次數，並且每次迴圈讀取和儲存一個像素。

首先，我們讀取並檢驗像素資料。單個像素的資料將被儲存在colorbuffer變數中。然後我們將檢查它是否為RAW頭。如果是，我們需要添加一個到變數之中以擷取頭之後的像素總數。

 // 開始像素讀取迴圈
 for(short counter = 0; counter < chunkheader; counter++)
 {
  // 嘗試讀取一個像素
  if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
  {
   ...Error code...
   return false;   // 如果失敗，返回false
  }

我們迴圈中的下一步將要擷取儲存在colorbuffer中的顏色值並且將其寫入稍後將要使用的imageData變數中。在這個過程中，資料格式將會由BGR翻轉為RGB或由BGRA轉換為RGBA，具體情況取決於每像素的位元數。當我們完成任務後我們增加當前的位元組和當前的像素計數器。 
  
 texture->imageData[currentbyte] = colorbuffer[2];  // 寫“R”位元組
 texture->imageData[currentbyte + 1 ] = colorbuffer[1]; //寫“G”位元組
 texture->imageData[currentbyte + 2 ] = colorbuffer[0]; // 寫“B”位元組
 if(tga.bytesPerPixel == 4)     // 如果是32位元影像像...
 {
  texture->imageData[currentbyte + 3] = colorbuffer[3]; // 寫“A”位元組
 }
 // 依據每像素的位元組數增加位元組計數器
 currentbyte += tga.bytesPerPixel;
 currentpixel++;     // 像素計數器加1
  
下一段處理描述RLE段的“塊”頭。首先我們將chunkheader減去127來得到擷取下一個顏色重複的次數。 
  
 else      // 如果是RLE頭
 {
  chunkheader -= 127;   //  減去127獲得ID Bit的Rid

然後我們嘗試讀取下一個顏色值。 

 // 讀取下一個像素
 if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
 {
  ...Error code...
  return false;    // 如果失敗，返回false
 }

接下來，我們開始迴圈拷貝我們多次讀到記憶體中的像素，這由RLE頭中的值規定。

然後，我們將顏色值拷貝到映像資料中，預先處理R和B的值交換。

隨後，我們增加當前的位元組數、當前像素，這樣我們再次寫入值時可以處在正確的位置。

 // 開始迴圈
 for(short counter = 0; counter < chunkheader; counter++)
 {
  // 拷貝“R”位元組
  texture->imageData[currentbyte] = colorbuffer[2];
  // 拷貝“G”位元組
  texture->imageData[currentbyte + 1 ] = colorbuffer[1];
  // 拷貝“B”位元組
  texture->imageData[currentbyte + 2 ] = colorbuffer[0];
  if(tga.bytesPerPixel == 4)  // 如果是32位元影像像
  {
   // 拷貝“A”位元組
   texture->imageData[currentbyte + 3] = colorbuffer[3];
  }
  currentbyte += tga.bytesPerPixel; // 增加位元組計數器
  currentpixel++;   // 增加位元組計數器
  
只要仍剩有像素要讀取，我們將會繼續主迴圈。

最後，我們關閉檔案並返回成功。

  while(currentpixel < pixelcount); // 是否有更多的像素要讀取？開始迴圈直到最後
  fclose(fTGA);   // 關閉檔案
  return true;   // 返回成功
 }
原文及其個版本原始碼下載：

http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=33

 

NeHe OpenGL教程 第三十三課：TGA檔案