Changeset 3086 in orxonox.OLD for orxonox/branches/images/importer/material.cc

Timestamp:

Dec 4, 2004, 6:05:54 PM (19 years ago)

Author:

bensch

Message:

orxonox/branches/images: ability to readIn jpg-files

File:

• orxonox/branches/images/importer/material.cc (modified) (2 diffs)

orxonox/branches/images/importer/material.cc

@@ -319 +319 @@
     printf ("setting Diffuse Map %s\n", dMap);
 
-  diffuseTextureSet = loadBMP(dMap, &diffuseTexture);
+  //  diffuseTextureSet = loadBMP(dMap, &diffuseTexture);
+  diffuseTextureSet = loadJPG(dMap, &diffuseTexture);
 
 }
@@ -384 +385 @@
 }
 
-
-
-
+bool Material::loadJPG (char* jpgName, GLuint* texture)
+{
+  struct jpeg_decompress_struct cinfo;
+  tImageJPG *pImage = NULL;
+  FILE *pFile;
+  
+  // Open a file pointer to the jpeg file and check if it was found and opened 
+  if((pFile = fopen(jpgName, "rb")) == NULL) 
+    {
+      // Display an error message saying the file was not found, then return NULL
+      printf("Unable to load JPG File %s.\n", jpgName);
+      return false;
+    }
+  
+  // Create an error handler
+  jpeg_error_mgr jerr;
+  
+  // Have our compression info object point to the error handler address
+  cinfo.err = jpeg_std_error(&jerr);
+  
+  // Initialize the decompression object
+  jpeg_create_decompress(&cinfo);
+  
+  // Specify the data source (Our file pointer) 
+  jpeg_stdio_src(&cinfo, pFile);
+  
+  // Allocate the structure that will hold our eventual jpeg data (must free it!)
+  pImage = (tImageJPG*)malloc(sizeof(tImageJPG));
+  
+  // Decode the jpeg file and fill in the image data structure to pass back
+  decodeJPG(&cinfo, pImage);
+  
+  // This releases all the stored memory for reading and decoding the jpeg
+  jpeg_destroy_decompress(&cinfo);
+  
+  // Close the file pointer that opened the file
+  fclose(pFile);
+  
+
+  if(pImage == NULL)                                                                    // If we can't load the file, quit!
+    exit(0);
+
+  // Generate a texture with the associative texture ID stored in the array
+  glGenTextures(1, texture);
+  
+  // Bind the texture to the texture arrays index and init the texture
+  glBindTexture(GL_TEXTURE_2D, *texture);
+  
+  // Build Mipmaps (builds different versions of the picture for distances - looks better)
+  gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pImage->sizeX, pImage->sizeY, GL_RGB, GL_UNSIGNED_BYTE, pImage->data);
+  
+  // Lastly, we need to tell OpenGL the quality of our texture map.  GL_LINEAR_MIPMAP_LINEAR
+  // is the smoothest.  GL_LINEAR_MIPMAP_NEAREST is faster than GL_LINEAR_MIPMAP_LINEAR, 
+  // but looks blochy and pixilated.  Good for slower computers though. 
+  
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
+  
+
+  // Now we need to free the image data that we loaded since OpenGL stored it as a texture
+  
+  if (pImage)                                                                           // If we loaded the image
+    {
+      if (pImage->data)                                                 // If there is texture data
+        {
+          free(pImage->data);                                           // Free the texture data, we don't need it anymore
+        }
+      
+      free(pImage);                                                             // Free the image structure
+    }
+
+}
+
+void Material::decodeJPG(jpeg_decompress_struct* cinfo, tImageJPG *pImageData)
+{
+  // Read in the header of the jpeg file
+  jpeg_read_header(cinfo, TRUE);
+  
+  // Start to decompress the jpeg file with our compression info
+  jpeg_start_decompress(cinfo);
+  
+  // Get the image dimensions and row span to read in the pixel data
+  pImageData->rowSpan = cinfo->image_width * cinfo->num_components;
+  pImageData->sizeX   = cinfo->image_width;
+  pImageData->sizeY   = cinfo->image_height;
+  
+  // Allocate memory for the pixel buffer
+  pImageData->data = new unsigned char[pImageData->rowSpan * pImageData->sizeY];
+  
+  // Here we use the library's state variable cinfo.output_scanline as the
+  // loop counter, so that we don't have to keep track ourselves.
+  
+  // Create an array of row pointers
+  unsigned char** rowPtr = new unsigned char*[pImageData->sizeY];
+  for (int i = 0; i < pImageData->sizeY; i++)
+    rowPtr[i] = &(pImageData->data[i*pImageData->rowSpan]);
+  
+  // Now comes the juice of our work, here we extract all the pixel data
+  int rowsRead = 0;
+  while (cinfo->output_scanline < cinfo->output_height) 
+    {
+      // Read in the current row of pixels and increase the rowsRead count
+      rowsRead += jpeg_read_scanlines(cinfo, &rowPtr[rowsRead], cinfo->output_height - rowsRead);
+    }
+  
+  // Delete the temporary row pointers
+  delete [] rowPtr;
+  
+  // Finish decompressing the data
+  jpeg_finish_decompress(cinfo);
+}
+