//--------------------------------------------------------------------------
// load source file for a shader
BOOL GL21loadShaderFile(
const char* fileName,
GLuint shader)
{
FILE* sourceFile = mgOSFileOpen(fileName, "rb");
if (sourceFile == NULL)
return false;
fseek(sourceFile, 0, SEEK_END);
long fileSize = ftell(sourceFile);
fseek(sourceFile, 0, SEEK_SET);
// read shader source
char* buffer = new char[fileSize+1];
size_t readLen = fread(buffer, 1, fileSize, sourceFile);
buffer[readLen] = '\0';
fclose(sourceFile);
const GLchar* strings[1];
strings[0] = (GLchar *) buffer;
// =-= skip any leading UTF-8 BOM
glShaderSource(shader, 1, strings, NULL);
// delete shader source
delete buffer;
return true;
}
//--------------------------------------------------------------
// constructor
MinecraftRegion::MinecraftRegion(
const char* regionDir,
int regionX,
int regionZ)
{
memset(m_header, 0, sizeof(m_header));
m_lock = mgOSLock::create();
// create the region file name
m_fileName.format("%s/r.%d.%d.mcr", (const char*) regionDir, regionX, regionZ);
mgOSFixFileName(m_fileName);
// open the file
m_regionFile = mgOSFileOpen(m_fileName, "rb");
if (m_regionFile == NULL)
{
mgDebug("could not open region file %s", (const char*) m_fileName);
m_exists = false;
return;
}
else m_exists = true;
// read the header
int count = fread(m_header, 1, sizeof(m_header), m_regionFile);
if (count != sizeof(m_header))
{
mgDebug("Could not read region (%d, %d) header -- %d bytes read, %d expected",
regionX, regionZ, count, sizeof(m_header));
m_exists = false;
}
}
//--------------------------------------------------------------
// parse a file
void mgXMLScanner::parseFile(
const char* fileName)
{
m_sourceFileName = fileName;
mgOSFixFileName(m_sourceFileName);
FILE* inFile = mgOSFileOpen(m_sourceFileName, "rb");
if (inFile == NULL)
throw new mgErrorMsg("xmlFileNotFound", "filename", "%s", (const char*) m_sourceFileName);
char* buffer = new char[PARSE_BUFFER_SIZE];
while (true)
{
size_t len = fread(buffer, 1, PARSE_BUFFER_SIZE, inFile);
if (len <= 0)
break;
// parse buffer of file data
parse((int) len, buffer);
}
delete buffer;
fclose(inFile);
// end of input
parseEnd();
}
//--------------------------------------------------------
// initialize target image
BOOL mgJPGWrite::outputStart(
int width, // width of image
int height) // height of image
{
m_outFile = mgOSFileOpen(m_fileName, "wb");
if (m_outFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
m_CompInfo.err = jpeg_std_error(&m_CompErr); // standard error handler
m_CompErr.error_exit = ImageErrorExit;
m_CompErr.output_message = ImageOutputMessage;
// allocate and initialize JPEG compression object
jpeg_create_compress(&m_CompInfo);
jpeg_stdio_dest(&m_CompInfo, m_outFile);
m_CompInfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&m_CompInfo);
m_CompInfo.in_color_space = JCS_RGB;
m_CompInfo.input_components = 3;
m_CompInfo.data_precision = 8;
m_CompInfo.image_width = width;
m_CompInfo.image_height = height;
jpeg_default_colorspace(&m_CompInfo);
// Start compressor, write complete file
jpeg_start_compress(&m_CompInfo, true);
return true;
}
//--------------------------------------------------------
// initialize target image
BOOL mgGIFWrite::outputStart(
int width, // width of image
int height) // height of image
{
m_outFile = mgOSFileOpen(m_fileName, "wb");
if (m_outFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
// initialize error diffusion
m_target = new BYTE[width];
m_diffuse = new mgDiffuse(0, width);
m_gifWrite = new mgGIFFileWrite;
m_gifWrite->m_outFile = m_outFile;
m_gifWrite->writeHeader(width, height);
m_RGBline = new BYTE[width*3];
// build standard color table
DWORD alColors[6*6*6];
int i = 0;
for (int r = 0; r < 6; r++)
for (int g = 0; g < 6; g++)
for (int b = 0; b < 6; b++)
alColors[i++] = ((r*51) << 16) | ((g*51) << 8) | (b*51);
m_gifWrite->writeColorTable(alColors, 6*6*6);
m_gifWrite->writeImageHeader(width, height);
return true;
}
//--------------------------------------------------------
// open a GIF file to be read
BOOL mgGIFRead::open(
const char* fileName) // name of file to open
{
// if file name exists
m_inFile = mgOSFileOpen(fileName, "rb");
if (m_inFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
// Figure out the input file format, and set up to read it.
m_srcMgr = jinit_read_gif(&m_CompInfo);
m_srcMgr->input_file = m_inFile;
// Read the input file header to obtain file size & colorspace.
(*m_srcMgr->start_input) (&m_CompInfo, m_srcMgr);
(*m_CompInfo.mem->realize_virt_arrays) ((j_common_ptr) &m_CompInfo);
m_width = m_CompInfo.image_width;
m_height = m_CompInfo.image_height;
m_RGBAline = new BYTE[m_CompInfo.image_width * 4];
if (!m_writer->outputStart(m_CompInfo.image_width, m_CompInfo.image_height))
return false;
return true;
}
//--------------------------------------------------------------
// save BGRA image data to a jpg file
void mgWriteBGRAtoJPGFile(
const char* fileName,
int width,
int height,
const BYTE* pData)
{
FILE* pOutFile = mgOSFileOpen(fileName, "wb");
if (pOutFile == NULL)
throw new mgErrorMsg("imgBadOpen", "filename", "%s", (const char*) fileName);
struct jpeg_error_mgr compErr; // error handler
struct jpeg_compress_struct compInfo;
compInfo.err = jpeg_std_error(&compErr); // standard error handler
compErr.error_exit = ImageErrorExit;
compErr.output_message = ImageOutputMessage;
// allocate and initialize JPEG compression object
jpeg_create_compress(&compInfo);
jpeg_stdio_dest(&compInfo, pOutFile);
compInfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&compInfo);
jpeg_set_quality(&compInfo, 99, true);
compInfo.in_color_space = JCS_RGB;
compInfo.input_components = 3;
compInfo.data_precision = 8;
compInfo.image_width = width;
compInfo.image_height = height;
jpeg_default_colorspace(&compInfo);
// Start compressor, write complete file
jpeg_start_compress(&compInfo, TRUE);
// read scanlines from the screen, top to bottom
BYTE* line = new BYTE[width*3];
const BYTE* pSource = pData;
for (int i = 0; i < height; i++)
{
int targetOffset = 0;
int sourceOffset = 0;
for (int j = 0; j < width; j++)
{
line[targetOffset++] = pSource[sourceOffset+2];
line[targetOffset++] = pSource[sourceOffset+1];
line[targetOffset++] = pSource[sourceOffset+0];
sourceOffset += 4;
}
jpeg_write_scanlines(&compInfo, &line, 1);
pSource += width*4;
}
delete line;
jpeg_finish_compress(&compInfo);
jpeg_destroy_compress(&compInfo);
fclose(pOutFile);
}
//--------------------------------------------------------------
// return file handle (open if necessary)
FILE* MinecraftRegion::getFile()
{
if (!m_exists)
return NULL;
if (m_regionFile != NULL)
return m_regionFile;
m_regionFile = mgOSFileOpen(m_fileName, "rb");
if (m_regionFile == NULL)
m_exists = false;
return m_regionFile;
}
//--------------------------------------------------------
// open a JPG file to be read
BOOL mgJPGRead::open(
const char* fileName) // name of file to open
{
// if file name exists
m_inFile = mgOSFileOpen(fileName, "rb");
if (m_inFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
jpeg_stdio_src(&m_CompInfo, m_inFile);
// read the dimensions of the source image
jpeg_read_header(&m_CompInfo, true);
// if there's been an error, return
if (// m_CompInfo.err->num_warnings > 0 ||
m_CompInfo.image_width == 0 || m_CompInfo.image_height == 0)
return false;
m_RGBAline = new BYTE[m_CompInfo.image_width * 4];
m_width = m_CompInfo.image_width;
m_height = m_CompInfo.image_height;
if (!m_writer->outputStart(m_CompInfo.image_width, m_CompInfo.image_height))
{
return false;
}
// set color map for output
if (m_CompInfo.out_color_space != JCS_GRAYSCALE)
m_CompInfo.out_color_space = JCS_RGB;
m_CompInfo.quantize_colors = false;
// start decompression
jpeg_calc_output_dimensions(&m_CompInfo);
jpeg_start_decompress(&m_CompInfo);
return true;
}
//--------------------------------------------------------
// open a BMP file to be read
BOOL mgBMPRead::open(
const char* fileName) // name of file to open
{
// if file name exists
m_inFile = mgOSFileOpen(fileName, "rb");
if (m_inFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
BitmapFileHeader fileHeader;
fileHeader.bfType = readWord(m_inFile);
fileHeader.bfSize = readDWord(m_inFile);
fileHeader.bfReserved1 = readWord(m_inFile);
fileHeader.bfReserved2 = readWord(m_inFile);
fileHeader.bfOffBits = readDWord(m_inFile);
if (fileHeader.bfType != 0x4D42)
throw new mgErrorMsg("imgNotBmp", "filename", "%s", (const char*) fileName);
BitmapInfoHeader infoHeader;
infoHeader.biSize = readDWord(m_inFile);
infoHeader.biWidth = (int) readDWord(m_inFile);
infoHeader.biHeight = (int) readDWord(m_inFile);
infoHeader.biPlanes = readWord(m_inFile);
infoHeader.biBitCount = readWord(m_inFile);
infoHeader.biCompression = readDWord(m_inFile);
infoHeader.biSizeImage = readDWord(m_inFile);
// handle uncompressed 24 and 32 bit images
if (infoHeader.biCompression != BITMAP_COMPRESSION_RGB ||
(infoHeader.biBitCount != 24 && infoHeader.biBitCount != 32))
throw new mgErrorMsg("imgBMPDepth", "filename", "%s", (const char*) fileName);
m_width = infoHeader.biWidth;
m_height = abs(infoHeader.biHeight);
m_bitCount = infoHeader.biBitCount;
m_reverse = infoHeader.biHeight > 0;
// read the image data
DWORD imageSize = m_height * m_width * m_bitCount/8;
if (infoHeader.biSizeImage != 0 && infoHeader.biSizeImage != imageSize)
throw new mgErrorMsg("imgBmpSize", "filename,calcSize,declSize", "%s,%d,%d",
(const char*) fileName, imageSize, infoHeader.biSizeImage);
m_data = new BYTE[imageSize];
fseek(m_inFile, fileHeader.bfOffBits, SEEK_SET);
size_t bytesRead = fread(m_data, 1, imageSize, m_inFile);
if (bytesRead != imageSize)
throw new mgErrorMsg("imgBmpRead", "filename,size", "%s,%d", (const char*) fileName, imageSize);
fclose(m_inFile);
m_inFile = NULL;
m_RGBAline = new BYTE[m_width * 4];
m_y = 0;
m_lineLen = m_width * m_bitCount/8;
m_lineLen = 4*((m_lineLen+3)/4);
if (!m_writer->outputStart(m_width, m_height))
return false;
return true;
}
