static void ReadCovTable(CICcontext *context, struct methodblock *mb)
{
int attribute_length = get4bytes(context);
unsigned char *end_ptr = context->ptr + attribute_length;
int old_clinit, i;
old_clinit = context->in_clinit;
context->in_clinit = FALSE; /* Since all storage needed by the class initialization method
* <clinit> can be freed after the class is loaded
* we should not place Jcov data into this memory
*/
if ((mb->coverage_table_length = get2bytes(context)) > 0) {
int sz = mb->coverage_table_length * sizeof(struct covtable)
+ mb->code_length * sizeof(long);
struct covtable *cv = allocNBytes(context, sz);
long *hash;
mb->coverage_table = cv;
hash = (long*)(mb->coverage_table + mb->coverage_table_length);
memset(hash, 0, mb->code_length*sizeof(long));
for (i = 0; i < mb->coverage_table_length; cv++) {
cv->pc = get2bytes(context);
*(hash+cv->pc) = i + 1;
cv->type = get2bytes(context);
cv->where = get4bytes(context);
cv->count = 0;
i++;
}
}
if (context->ptr != end_ptr)
mb->coverage_table = NULL; /* Don't use a wrong coverage table */
context->in_clinit = old_clinit;
}
bool loadFunctionCode (loadedFunction * newFunc) {
unsigned int numLines, numLinesRead;
int a;
if (! openSubSlice (newFunc -> originalNumber)) return false;
newFunc -> unfreezable = fgetc (bigDataFile);
numLines = get2bytes (bigDataFile);
newFunc -> numArgs = get2bytes (bigDataFile);
newFunc -> numLocals = get2bytes (bigDataFile);
newFunc -> compiledLines = new lineOfCode[numLines];
if (! checkNew (newFunc -> compiledLines)) return false;
for (numLinesRead = 0; numLinesRead < numLines; numLinesRead ++) {
newFunc -> compiledLines[numLinesRead].theCommand = (sludgeCommand) fgetc (bigDataFile);
newFunc -> compiledLines[numLinesRead].param = get2bytes (bigDataFile);
}
finishAccess ();
// Now we need to reserve memory for the local variables
newFunc -> localVars = new variable[newFunc -> numLocals];
if (! checkNew (newFunc -> localVars)) return false;
for (a = 0; a < newFunc -> numLocals; a ++) {
initVarNew (newFunc -> localVars[a]);
}
return true;
}
bool loadZBufferFile (const char * name, spriteBank *loadhere) {
int n, i, x, y, zbWidth, zbHeight;
uint32_t stillToGo = 0;
FILE * fp = fopen (name, "rb");
if (! fp) return false;
if (fgetc (fp) != 'S') { fclose (fp); return false; }
if (fgetc (fp) != 'z') { fclose (fp); return false; }
if (fgetc (fp) != 'b') { fclose (fp); return false; }
switch (fgetc (fp)) {
case 0:
zbWidth = 640;
zbHeight = 480;
break;
case 1:
zbWidth = get2bytes (fp);
zbHeight = get2bytes (fp);
break;
default:
fclose (fp);
return false;
}
loadhere->total = fgetc (fp);
loadhere->sprites = new sprite [loadhere->total];
for (n = 0; n < loadhere->total; n ++) {
loadhere->sprites[n].width = zbWidth;
loadhere->sprites[n].height = -zbHeight;
loadhere->sprites[n].xhot = 0;
loadhere->sprites[n].yhot = 0;
loadhere->sprites[n].tex_x = 0;
loadhere->sprites[n].special = get2bytes (fp);
loadhere->sprites[n].texNum = n;
loadhere->myPalette.tex_names[n] = 0;
loadhere->myPalette.tex_h[n] = zbHeight;
loadhere->myPalette.tex_w[n] = zbWidth;
loadhere->sprites[n].data = new unsigned char [zbWidth * zbHeight];
}
for (y = 0; y < zbHeight; y ++) {
for (x = 0; x < zbWidth; x ++) {
if (stillToGo == 0) {
n = fgetc (fp);
stillToGo = n >> 4;
if (stillToGo == 15) stillToGo = get2bytes (fp) + 16l;
else stillToGo ++;
n &= 15;
}
loadhere->sprites[0].data[y*zbWidth+x] = n;
for (i = 1; i < loadhere->total; i ++) {
loadhere->sprites[i].data[y*zbWidth+x] = (n == i) ? 255: 0;
}
stillToGo --;
}
}
void loadSounds (FILE * fp) {
while (fgetc (fp)) {
get2bytes (fp);
get2bytes (fp);
}
defSoundVol = get2bytes (fp);
defVol = get2bytes (fp);
}
bool restoreSnapshot (FILE * fp) {
unsigned int picWidth = get2bytes (fp);
unsigned int picHeight = get2bytes (fp);
if ((picWidth != winWidth) || (picHeight != winHeight))
return false;
unsigned int t1, t2, n;
unsigned short c;
GLubyte * target;
if (! NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
snapTexW = ((double)winWidth) / picWidth;
snapTexH = ((double)winHeight) / picHeight;
}
GLubyte * snapshotTexture = new GLubyte [picHeight*picWidth*4];
if (! snapshotTexture) return fatal("Out of memory while restoring snapshot.");
for (t2 = 0; t2 < winHeight; t2 ++) {
t1 = 0;
while (t1 < winWidth) {
c = (unsigned short) get2bytes (fp);
if (c & 32) {
n = fgetc (fp) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
target = snapshotTexture + 4*picWidth*t2 + t1*4;
target[0] = (GLubyte) redValue(c);
target[1] = (GLubyte) greenValue(c);
target[2] = (GLubyte) blueValue(c);
target[3] = (GLubyte) 255;
t1++;
}
}
}
if (! snapshotTextureName) glGenTextures (1, &snapshotTextureName);
glBindTexture(GL_TEXTURE_2D, snapshotTextureName);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, picWidth, picHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, snapshotTexture, snapshotTextureName);
delete snapshotTexture;
snapshotTexture = NULL;
return true;
}
static void ReadInCode(CICcontext *context, struct methodblock *mb)
{
int attribute_length = get4bytes(context);
unsigned char *end_ptr = context->ptr + attribute_length;
int attribute_count;
int code_length;
int i;
if (cbMinorVersion(context->cb) <= 2) {
mb->maxstack = get1byte(context);
mb->nlocals = get1byte(context);
code_length = mb->code_length = get2bytes(context);
} else {
mb->maxstack = get2bytes(context);
mb->nlocals = get2bytes(context);
code_length = mb->code_length = get4bytes(context);
}
if (mb->nlocals < mb->args_size)
JAVA_ERROR(context, "Arguments can't fit into locals");
if (code_length > 65535) {
JAVA_ERROR(context, "Byte code size exceeds 65535 bytes");
}
mb->code = allocNBytes(context, code_length);
getNbytes(context, code_length, (char *)mb->code);
if ((mb->exception_table_length = get2bytes(context)) > 0) {
unsigned exception_table_size = mb->exception_table_length
* sizeof(struct CatchFrame);
mb->exception_table = allocNBytes(context, exception_table_size);
for (i = 0; i < (int)mb->exception_table_length; i++) {
mb->exception_table[i].start_pc = get2bytes(context);
mb->exception_table[i].end_pc = get2bytes(context);
mb->exception_table[i].handler_pc = get2bytes(context);
mb->exception_table[i].catchType = get2bytes(context);
mb->exception_table[i].compiled_CatchFrame = NULL;
}
}
attribute_count = get2bytes(context);
for (i = 0; i < attribute_count; i++) {
char *name = getAsciz(context);
if (strcmp(name, "LineNumberTable") == 0) {
ReadLineTable(context, mb);
#ifdef JCOV
} else if (strcmp(name, "CoverageTable") == 0 && cov_file) {
ReadCovTable(context, mb);
#endif
} else if (strcmp(name, "LocalVariableTable") == 0) {
ReadLocalVars(context, mb);
} else {
int length = get4bytes(context);
getNbytes(context, length, NULL);
}
}
if (context->ptr != end_ptr)
JAVA_ERROR(context, "Code segment was wrong length");
}
void loadSounds (FILE * fp) {
for (int i = 0; i < MAX_SAMPLES; i ++) freeSound (i);
while (fgetc (fp)) {
int fileLoaded = get2bytes (fp);
defSoundVol = get2bytes (fp);
startSound (fileLoaded, 1);
}
defSoundVol = get2bytes (fp);
defVol = get2bytes (fp);
}
static void
ReadExceptions(CICcontext *context, struct methodblock *mb)
{
int attribute_length = get4bytes(context);
unsigned char *end_ptr = context->ptr + attribute_length;
unsigned short nexceptions = get2bytes(context);
if ((mb->nexceptions = nexceptions) > 0) {
unsigned short *ep, *exceptions =
allocNBytes(context, nexceptions * sizeof (unsigned short));
mb->exceptions = ep = exceptions;
while (nexceptions-- > 0) {
*ep++ = get2bytes(context);
}
}
if (context->ptr != end_ptr)
JAVA_ERROR(context, "Exceptions attribute has wrong length");
}
static void ReadLineTable(CICcontext *context, struct methodblock *mb)
{
int attribute_length = get4bytes(context);
unsigned char *end_ptr = context->ptr + attribute_length;
int i;
if ((mb->line_number_table_length = get2bytes(context)) > 0) {
struct lineno *ln =
allocNBytes(context, mb->line_number_table_length *
sizeof(struct lineno));
mb->line_number_table = ln;
for (i = mb->line_number_table_length; --i >= 0; ln++) {
ln->pc = get2bytes(context);
ln->line_number = get2bytes(context);
}
}
if (context->ptr != end_ptr)
JAVA_ERROR(context, "Line number table was wrong length?");
}
void loadHandlers (FILE * fp) {
currentEvents -> leftMouseFunction = get2bytes (fp);
currentEvents -> leftMouseUpFunction = get2bytes (fp);
currentEvents -> rightMouseFunction = get2bytes (fp);
currentEvents -> rightMouseUpFunction = get2bytes (fp);
currentEvents -> moveMouseFunction = get2bytes (fp);
currentEvents -> focusFunction = get2bytes (fp);
currentEvents -> spaceFunction = get2bytes (fp);
}
char * readString (FILE * fp) {
int n = get2bytes (fp), a;
char * grabber = new char[n + 1];
// checkNew (grabber);
for (a = 0; a < n; a ++) {
grabber[a] = (char) (fgetc (fp) - MOVETEXT);
}
grabber[n] = NULL;
return grabber;
}
static char *getAsciz(CICcontext *context)
{
ClassClass *cb = context->cb;
union cp_item_type *constant_pool = cbConstantPool(cb);
int nconstants = cbConstantPoolCount(cb);
unsigned char *type_table =
constant_pool[CONSTANT_POOL_TYPE_TABLE_INDEX].type;
int value = get2bytes(context);
if ((value == 0) || (value >= nconstants) ||
type_table[value] != (CONSTANT_Utf8 | CONSTANT_POOL_ENTRY_RESOLVED))
JAVA_ERROR(context, "Illegal constant pool index");
return constant_pool[value].cp;
}
bool loadCostume (persona * cossy, FILE * fp) {
int a;
cossy -> numDirections = get2bytes (fp);
cossy -> animation = new personaAnimation * [cossy -> numDirections * 3];
if (! checkNew (cossy -> animation)) return false;
for (a = 0; a < cossy -> numDirections * 3; a ++) {
cossy -> animation[a] = new personaAnimation;
if (! checkNew (cossy -> animation[a])) return false;
if (! loadAnim (cossy -> animation[a], fp)) return false;
}
// debugCostume ("Loaded", cossy);
return true;
}
void loadRegions (FILE * fp) {
int numRegions = get2bytes (fp);
screenRegion * newRegion;
screenRegion * * pointy = & allScreenRegions;
while (numRegions --) {
newRegion = new screenRegion;
* pointy = newRegion;
pointy = & (newRegion -> next);
newRegion -> x1 = get2bytes (fp);
newRegion -> y1 = get2bytes (fp);
newRegion -> x2 = get2bytes (fp);
newRegion -> y2 = get2bytes (fp);
newRegion -> sX = get2bytes (fp);
newRegion -> sY = get2bytes (fp);
newRegion -> di = get2bytes (fp);
newRegion -> thisType = loadObjectRef (fp);
}
* pointy = NULL;
}
bool loadAnim (personaAnimation * p, FILE * fp) {
p -> numFrames = get2bytes (fp);
if (p -> numFrames) {
int a = get4bytes (fp);
p -> frames = new animFrame[p -> numFrames];
if (! checkNew (p -> frames)) return false;
p -> theSprites = loadBankForAnim (a);
for (a = 0; a < p -> numFrames; a ++) {
p -> frames[a].frameNum = get4bytes (fp);
p -> frames[a].howMany = get4bytes (fp);
if (ssgVersion >= VERSION(2,0)) {
p -> frames[a].noise = get4bytes (fp);
} else {
p -> frames[a].noise = 0;
}
}
} else {
p -> theSprites = NULL;
p -> frames = NULL;
}
return true;
}
static void ReadLocalVars(CICcontext *context, struct methodblock *mb)
{
int attribute_length = get4bytes(context);
unsigned char *end_ptr = context->ptr + attribute_length;
int i;
if ((mb->localvar_table_length = get2bytes(context)) > 0) {
struct localvar *lv =
allocNBytes(context, mb->localvar_table_length *
sizeof(struct localvar));
mb->localvar_table = lv;
for (i = mb->localvar_table_length; --i >= 0; lv++) {
lv->pc0 = get2bytes(context);
lv->length = get2bytes(context);
lv->nameoff = get2bytes(context);
lv->sigoff = get2bytes(context);
lv->slot = get2bytes(context);
}
}
if (context->ptr != end_ptr)
JAVA_ERROR(context, "Local variables table was wrong length?");
}
bool loadLightMap (int v) {
int newPicWidth, newPicHeight;
setResourceForFatal (v);
if (! openFileFromNum (v)) return fatal ("Can't open light map.");
long file_pointer = ftell (bigDataFile);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
size_t bytes_read = fread(tmp, 1, 8, bigDataFile);
if (bytes_read != 8 && ferror (bigDataFile)) {
debugOut("Reading error in loadLightMap.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(bigDataFile, file_pointer, SEEK_SET);
newPicWidth = lightMap.w = get2bytes (bigDataFile);
newPicHeight = lightMap.h = get2bytes (bigDataFile);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, bigDataFile); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
newPicWidth = lightMap.w = width;
newPicHeight = lightMap.h = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
//int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
}
if (lightMapMode == LIGHTMAPMODE_HOTSPOT) {
if (lightMap.w != sceneWidth || lightMap.h != sceneHeight) {
return fatal ("Light map width and height don't match scene width and height. That is required for lightmaps in HOTSPOT mode.");
}
}
if (! NPOT_textures) {
newPicWidth = getNextPOT(lightMap.w);
newPicHeight = getNextPOT(lightMap.h);
lightMap.texW = (double) lightMap.w / newPicWidth;
lightMap.texH = (double) lightMap.h / newPicHeight;
} else {
lightMap.texW = 1.0;
lightMap.texH = 1.0;
}
killLightMap ();
lightMapNumber = v;
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
if (lightMap.data) delete [] lightMap.data;
lightMap.data = new GLubyte [newPicWidth*newPicHeight*4];
if (! lightMap.data) {
return fatal ("Out of memory loading light map.");
}
int t1, t2, n;
unsigned short c;
GLubyte * target;
if (fileIsPNG) {
unsigned char * row_pointers[lightMap.h];
for (int i = 0; i<lightMap.h; i++)
row_pointers[i] = lightMap.data + 4*i*newPicWidth;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
for (t2 = 0; t2 < lightMap.h; t2 ++) {
t1 = 0;
while (t1 < lightMap.w) {
c = (unsigned short) get2bytes (bigDataFile);
if (c & 32) {
n = fgetc (bigDataFile) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
target = lightMap.data + 4*newPicWidth*t2 + t1*4;
target[0] = (GLubyte) redValue(c);
target[1] = (GLubyte) greenValue(c);
target[2] = (GLubyte) blueValue(c);
target[3] = (GLubyte) 255;
t1++;
}
}
}
}
if (! lightMap.name) glGenTextures (1, &lightMap.name);
glBindTexture(GL_TEXTURE_2D, lightMap.name);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, newPicWidth, newPicHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, lightMap.data, lightMap.name);
finishAccess ();
setResourceForFatal (-1);
return true;
}
bool loadSpriteBank (int fileNum, spriteBank & loadhere, bool isFont) {
int i, tex_num, total, picwidth, picheight, spriteBankVersion = 0, howmany=0, startIndex=0;
int * totalwidth, * maxheight;
int numTextures = 0;
byte * data;
setResourceForFatal (fileNum);
if (! openFileFromNum (fileNum)) return fatal ("Can't open sprite bank / font");
loadhere.isFont = isFont;
total = get2bytes (bigDataFile);
if (! total) {
spriteBankVersion = fgetc (bigDataFile);
if (spriteBankVersion == 1) {
total = 0;
} else {
total = get2bytes (bigDataFile);
}
}
if (total <= 0) return fatal ("No sprites in bank or invalid sprite bank file");
if (spriteBankVersion > 3) return fatal ("Unsupported sprite bank file format");
loadhere.total = total;
loadhere.sprites = new sprite [total];
if (! checkNew (loadhere.sprites)) return false;
byte ** spriteData = new byte * [total];
if (! checkNew (spriteData)) return false;
totalwidth = new int[total];
if (! checkNew (totalwidth)) return false;
maxheight = new int[total];
if (! checkNew (maxheight)) return false;
loadhere.myPalette.tex_names = new GLuint [total];
if (! checkNew (loadhere.myPalette.tex_names)) return false;
if (isFont) {
loadhere.myPalette.burnTex_names = new GLuint [total];
if (! checkNew (loadhere.myPalette.burnTex_names)) return false;
}
loadhere.myPalette.tex_w = new int [total];
if (! checkNew (loadhere.myPalette.tex_w)) return false;
loadhere.myPalette.tex_h = new int [total];
if (! checkNew (loadhere.myPalette.tex_h)) return false;
if (spriteBankVersion && spriteBankVersion < 3) {
howmany = fgetc (bigDataFile);
startIndex = 1;
}
totalwidth[0] = maxheight[0] = 1;
for (i = 0; i < total; i ++) {
switch (spriteBankVersion) {
case 3:
{
loadhere.sprites[i].xhot = getSigned (bigDataFile);
loadhere.sprites[i].yhot = getSigned (bigDataFile);
png_structp png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return fatal ("Can't open sprite bank / font.");
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return fatal ("Can't open sprite bank / font.");
}
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return fatal ("Can't open sprite bank / font.");
}
png_init_io(png_ptr, bigDataFile); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // No sig
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
unsigned char * row_pointers[height];
spriteData[i] = new unsigned char [rowbytes*height];
if (! checkNew (spriteData[i])) return false;
for (unsigned int row = 0; row<height; row++)
row_pointers[row] = spriteData[i] + row*rowbytes;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
picwidth = loadhere.sprites[i].width = width;
picheight = loadhere.sprites[i].height = height;
break;
}
case 2:
picwidth = get2bytes (bigDataFile);
picheight = get2bytes (bigDataFile);
loadhere.sprites[i].xhot = getSigned (bigDataFile);
loadhere.sprites[i].yhot = getSigned (bigDataFile);
break;
default:
picwidth = (byte) fgetc (bigDataFile);
picheight = (byte) fgetc (bigDataFile);
loadhere.sprites[i].xhot = fgetc (bigDataFile);
loadhere.sprites[i].yhot = fgetc (bigDataFile);
break;
}
if (totalwidth[numTextures] + picwidth < 2047) {
loadhere.sprites[i].tex_x = totalwidth[numTextures];
totalwidth[numTextures] += (loadhere.sprites[i].width = picwidth) + 1;
if ((loadhere.sprites[i].height = picheight)+2 > maxheight[numTextures]) maxheight[numTextures] = picheight+2;
} else {
numTextures++;
if (numTextures > 255) return fatal ("Can't open sprite bank / font - it's too big.");
loadhere.sprites[i].tex_x = 0;
totalwidth[numTextures] = (loadhere.sprites[i].width = picwidth);
maxheight[numTextures] = loadhere.sprites[i].height = picheight;
}
loadhere.sprites[i].texNum = numTextures;
if (spriteBankVersion < 3) {
data = (byte *) new byte [picwidth * (picheight + 1)];
if (! checkNew (data)) return false;
int ooo = picwidth * picheight;
for (int tt = 0; tt < picwidth; tt ++) {
data[ooo ++] = 0;
}
spriteData[i] = data;
switch (spriteBankVersion) {
case 2: // RUN LENGTH COMPRESSED DATA
{
unsigned size = picwidth * picheight;
unsigned pip = 0;
while (pip < size) {
byte col = fgetc (bigDataFile);
int looper;
if (col > howmany) {
col -= howmany + 1;
looper = fgetc (bigDataFile) + 1;
} else looper = 1;
while (looper --) {
data[pip ++] = col;
}
}
}
break;
default: // RAW DATA
size_t bytes_read = fread (data, picwidth, picheight, bigDataFile);
if (bytes_read != picwidth * picheight && ferror (bigDataFile)) {
debugOut("Reading error in loadSpriteBank.\n");
}
break;
}
}
}
numTextures++;
if (! spriteBankVersion) {
howmany = fgetc (bigDataFile);
startIndex = fgetc (bigDataFile);
}
if (spriteBankVersion < 3) {
if (! reserveSpritePal (loadhere.myPalette, howmany + startIndex)) return false;
for (i = 0; i < howmany; i ++) {
loadhere.myPalette.r[i + startIndex] = (byte) fgetc (bigDataFile);
loadhere.myPalette.g[i + startIndex] = (byte) fgetc (bigDataFile);
loadhere.myPalette.b[i + startIndex] = (byte) fgetc (bigDataFile);
loadhere.myPalette.pal[i + startIndex] = makeColour (loadhere.myPalette.r[i + startIndex], loadhere.myPalette.g[i + startIndex], loadhere.myPalette.b[i + startIndex]);
}
}
loadhere.myPalette.originalRed = loadhere.myPalette.originalGreen = loadhere.myPalette.originalBlue = 255;
loadhere.myPalette.numTextures = numTextures;
GLubyte * tmp[numTextures];
GLubyte * tmp2[numTextures];
for (tex_num = 0; tex_num < numTextures; tex_num++) {
if (! NPOT_textures) {
totalwidth[tex_num] = getNextPOT(totalwidth[tex_num]);
maxheight[tex_num] = getNextPOT(maxheight[tex_num]);
}
tmp[tex_num] = new GLubyte [(maxheight[tex_num]+1)*totalwidth[tex_num]*4];
if (! checkNew (tmp[tex_num])) return false;
memset (tmp[tex_num], 0, maxheight[tex_num]*totalwidth[tex_num]*4);
if (isFont) {
tmp2[tex_num] = new GLubyte [(maxheight[tex_num]+1)*totalwidth[tex_num]*4];
if (! checkNew (tmp2[tex_num])) return false;
memset (tmp2[tex_num], 0, maxheight[tex_num]*totalwidth[tex_num]*4);
}
loadhere.myPalette.tex_w[tex_num] = totalwidth[tex_num];
loadhere.myPalette.tex_h[tex_num] = maxheight[tex_num];
}
int fromhere;
unsigned char s;
for (i = 0; i < total; i ++) {
fromhere = 0;
int transColour = -1;
if (spriteBankVersion < 3) {
int size = loadhere.sprites[i].height * loadhere.sprites[i].width;
while (fromhere < size) {
s = spriteData[i][fromhere++];
if (s) {
transColour = s;
break;
}
}
fromhere = 0;
}
for (int y = 1; y < 1 + loadhere.sprites[i].height; y ++) {
for (int x = loadhere.sprites[i].tex_x; x < loadhere.sprites[i].tex_x+loadhere.sprites[i].width; x ++) {
GLubyte * target = tmp[loadhere.sprites[i].texNum] + 4*totalwidth[loadhere.sprites[i].texNum]*y + x*4;
if (spriteBankVersion < 3) {
s = spriteData[i][fromhere++];
if (s) {
target[0] = (GLubyte) loadhere.myPalette.r[s];
target[1] = (GLubyte) loadhere.myPalette.g[s];
target[2] = (GLubyte) loadhere.myPalette.b[s];
target[3] = (GLubyte) 255;
transColour = s;
} else if (transColour >=0) {
target[0] = (GLubyte) loadhere.myPalette.r[transColour];
target[1] = (GLubyte) loadhere.myPalette.g[transColour];
target[2] = (GLubyte) loadhere.myPalette.b[transColour];
target[3] = (GLubyte) 0;
}
if (isFont) {
target = tmp2[loadhere.sprites[i].texNum] + 4*totalwidth[loadhere.sprites[i].texNum]*y + x*4;
target[0] = (GLubyte) 255;
target[1] = (GLubyte) 255;
target[2] = (GLubyte) 255;
if (s)
target[3] = (GLubyte) loadhere.myPalette.r[s];
/*else
target[3] = (GLubyte) 0;*/
}
} else {
target[0] = (GLubyte) spriteData[i][fromhere++];
target[1] = (GLubyte) spriteData[i][fromhere++];
target[2] = (GLubyte) spriteData[i][fromhere++];
target[3] = (GLubyte) spriteData[i][fromhere++];
}
}
}
delete spriteData[i];
}
delete spriteData;
spriteData = NULL;
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glGenTextures (numTextures, loadhere.myPalette.tex_names);
if (isFont)
glGenTextures (numTextures, loadhere.myPalette.burnTex_names);
for (tex_num = 0; tex_num < numTextures; tex_num++) {
glBindTexture (GL_TEXTURE_2D, loadhere.myPalette.tex_names[tex_num]);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (gameSettings.antiAlias < 0) {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, totalwidth[tex_num], maxheight[tex_num], 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp[tex_num], loadhere.myPalette.tex_names[tex_num]);
delete tmp[tex_num];
tmp[tex_num] = NULL;
if (isFont) {
glBindTexture (GL_TEXTURE_2D, loadhere.myPalette.burnTex_names[tex_num]);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (gameSettings.antiAlias < 0) {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, totalwidth[tex_num], maxheight[tex_num], 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp2[tex_num], loadhere.myPalette.burnTex_names[tex_num]);
delete tmp2[tex_num];
tmp2[tex_num] = NULL;
}
}
finishAccess ();
setResourceForFatal (-1);
return true;
}
bool loadSpriteBank (const char * filename, spriteBank *loadhere) {
int i, total, picwidth, picheight, spriteBankVersion = 0, howmany,
startIndex;
int totalwidth[65535], maxheight[65535];
int numTextures = 0;
// Open the file
FILE * fp = fopen (filename, "rb");
if (fp == NULL) {
return errorBox ("Can't open sprite bank", "The file can't be opened. I don't know why.");
}
total = get2bytes(fp);
if (! total) {
spriteBankVersion = fgetc(fp);
if (spriteBankVersion == 1) {
total = 0;
} else {
total = get2bytes(fp);
}
}
if (spriteBankVersion > 3) return errorBox ("Error opening sprite bank", "Unsupported sprite bank file format");
if (total <= 0) return errorBox ("Error opening sprite bank", "No sprites in bank or invalid sprite bank file");
if (spriteBankVersion == 3) {
loadhere->type = 2;
loadhere->total = total;
loadhere->sprites = new sprite [total];
for (int index = 0; index < total; index ++) {
loadhere->sprites[index].xhot = getSigned (fp);
loadhere->sprites[index].yhot = getSigned (fp);
png_structp png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
fclose (fp);
return errorBox ("Can't open PNG file", "Error reading the file.");
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
fclose (fp);
return errorBox ("Can't open PNG file", "Error reading the file.");
}
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
fclose (fp);
return errorBox ("Can't open PNG file", "Error reading the file.");
}
png_init_io(png_ptr, fp); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // No sig
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
unsigned char * row_pointers[height];
unsigned char * data = new unsigned char [rowbytes*height];
for (int i = 0; i<height; i++)
row_pointers[i] = data + i*rowbytes;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
loadhere->sprites[index].data = data;
loadhere->sprites[index].width = width;
loadhere->sprites[index].height = height;
}
fclose(fp);
return true;
}
loadhere->type = 0;
loadhere->total = total;
loadhere->sprites = new sprite [total];
//if (! checkNew (loadhere->sprites)) return false;
if (spriteBankVersion) {
howmany = fgetc(fp);
startIndex = 1;
}
totalwidth[0] = maxheight[0] = 0;
for (i = 0; i < total; i ++) {
switch (spriteBankVersion) {
case 2:
picwidth = get2bytes(fp);
picheight = get2bytes(fp);
loadhere->sprites[i].xhot = getSigned (fp);
loadhere->sprites[i].yhot = getSigned (fp);
break;
default:
picwidth = (unsigned char) fgetc(fp);
picheight = (unsigned char) fgetc(fp);
loadhere->sprites[i].xhot = fgetc(fp);
loadhere->sprites[i].yhot = fgetc(fp);
break;
}
if (totalwidth[numTextures] + picwidth < 2048) {
loadhere->sprites[i].tex_x = totalwidth[numTextures];
totalwidth[numTextures] += (loadhere->sprites[i].width = picwidth);
if ((loadhere->sprites[i].height = picheight) > maxheight[numTextures]) maxheight[numTextures] = picheight;
} else {
numTextures++;
if (numTextures > 65535) return false;//fatal ("Can't open sprite bank / font - it's too big.");
loadhere->sprites[i].tex_x = 0;
totalwidth[numTextures] = (loadhere->sprites[i].width = picwidth);
maxheight[numTextures] = loadhere->sprites[i].height = picheight;
}
loadhere->sprites[i].texNum = numTextures;
loadhere->sprites[i].data = (unsigned char *) new unsigned char [picwidth * (picheight + 1)];
//if (! checkNew (data)) return false;
int ooo = picwidth * picheight;
for (int tt = 0; tt < picwidth; tt ++) {
loadhere->sprites[i].data[ooo ++] = 0;
}
switch (spriteBankVersion) {
case 2: // RUN LENGTH COMPRESSED DATA
{
unsigned size = picwidth * picheight;
unsigned pip = 0;
while (pip < size) {
unsigned char col = fgetc(fp);
int looper;
if (col > howmany) {
col -= howmany + 1;
looper = fgetc(fp) + 1;
} else looper = 1;
while (looper --) {
loadhere->sprites[i].data[pip ++] = col;
}
}
}
break;
default: // RAW DATA
size_t bytes_read = fread (loadhere->sprites[i].data, picwidth, picheight, fp);
if (bytes_read != picwidth * picheight && ferror (fp)) {
fprintf(stderr, "Reading error in loadSpriteBank.\n");
}
break;
}
}
numTextures++;
if (! spriteBankVersion) {
howmany = fgetc(fp);
startIndex = fgetc(fp);
}
if (! reserveSpritePal (&loadhere->myPalette, howmany + startIndex)) return false;
for (i = 0; i < howmany; i ++) {
loadhere->myPalette.r[i + startIndex] = (unsigned char) fgetc(fp);
loadhere->myPalette.g[i + startIndex] = (unsigned char) fgetc(fp);
loadhere->myPalette.b[i + startIndex] = (unsigned char) fgetc(fp);
loadhere->myPalette.pal[i + startIndex] = makeColour (loadhere->myPalette.r[i + startIndex], loadhere->myPalette.g[i + startIndex], loadhere->myPalette.b[i + startIndex]);
}
fclose(fp);
return true;
}
static void
createInternalClass0(CICcontext *context, ClassClass *cb,
struct Hjava_lang_ClassLoader *loader, char *name)
{
int i, j;
union cp_item_type *constant_pool;
unsigned char *type_table;
int attribute_count;
unsigned fields_count;
struct methodblock *mb;
struct fieldblock *fb;
struct Classjava_lang_Class *ucb = unhand(cb);
if (get4bytes(context) != JAVA_CLASSFILE_MAGIC)
JAVA_ERROR(context, "Bad magic number");
ucb->minor_version = get2bytes(context);
ucb->major_version = get2bytes(context);
ucb->loader = loader;
if (ucb->major_version != JAVA_VERSION)
JAVA_ERROR(context, "Bad major version number");
LoadConstantPool(context);
constant_pool = ucb->constantpool;
type_table = constant_pool[CONSTANT_POOL_TYPE_TABLE_INDEX].type;
ucb->access = get2bytes(context) & ACC_WRITTEN_FLAGS;
/* Work around javac bug */
if (ucb->access & ACC_INTERFACE) {
ucb->access |= ACC_ABSTRACT;
}
/* Get the name of the class */
i = get2bytes(context); /* index in constant pool of class */
ucb->name = getAscizFromClass(context, i);
if (name != NULL && strcmp(ucb->name, name) != 0)
JAVA_ERROR(context, "Wrong name");
constant_pool[i].clazz = cb;
CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(type_table, i);
if (loader) {
/* We don't trust a classloader to do the right thing. . . */
ClassClass **pcb, **end_pcb;
char *name = ucb->name;
if (name == NULL || !IsLegalClassname(name, FALSE)) {
JAVA_ERROR(context, "Bad name");
}
BINCLASS_LOCK();
for (pcb = binclasses, end_pcb = pcb + nbinclasses;
pcb < end_pcb; pcb++) {
ClassClass *cb = *pcb;
if ((cbLoader(cb) == loader) && (strcmp(name, cbName(cb)) == 0))
break;
}
BINCLASS_UNLOCK();
if (pcb < end_pcb)
/* There's already a class with the same name and loader */
JAVA_ERROR(context, "Duplicate name");
}
/* Get the super class name. */
i = get2bytes(context); /* index in constant pool of class */
if (i > 0) {
ucb->super_name = getAscizFromClass(context, i);
if (!IsLegalClassname(ucb->super_name, FALSE)) {
JAVA_ERROR(context, "Bad superclass name");
}
}
i = ucb->implements_count = get2bytes(context);
if (i > 0) {
int j;
ucb->implements = allocNBytes(context, i * sizeof(short));
for (j = 0; j < i; j++) {
ucb->implements[j] = get2bytes(context);
}
}
fields_count = ucb->fields_count = get2bytes(context);
if (fields_count > 0)
ucb->fields = (struct fieldblock *)
allocNBytes(context, ucb->fields_count * sizeof(struct fieldblock));
for (i = fields_count, fb = ucb->fields; --i >= 0; fb++) {
fieldclass(fb) = cb;
fb->access = get2bytes(context) & ACC_WRITTEN_FLAGS;
fb->name = getAsciz(context);
fb->signature = getAsciz(context);
attribute_count = get2bytes(context);
for (j = 0; j < (int)attribute_count; j++) {
char *name = getAsciz(context);
int length = get4bytes(context);
if ((fb->access & ACC_STATIC)
&& strcmp(name, "ConstantValue") == 0) {
if (length != 2)
JAVA_ERROR(context, "Wrong size for VALUE attribute");
fb->access |= ACC_VALKNOWN;
/* we'll change this below */
fb->u.offset = get2bytes(context);
} else {
getNbytes(context, length, NULL);
}
}
/*
if (fb->access & ACC_STATIC) {
InitializeStaticVar(fb, context);
}
*/
}
if ((ucb->methods_count = get2bytes(context)) > 0)
ucb->methods = (struct methodblock *)
allocNBytes(context, ucb->methods_count * sizeof(struct methodblock));
for (i = cbMethodsCount(cb), mb = cbMethods(cb); --i >= 0; mb++) {
fieldclass(&mb->fb) = cb;
mb->fb.access = get2bytes(context) & ACC_WRITTEN_FLAGS;
mb->fb.name = getAsciz(context);
mb->fb.signature = getAsciz(context);
if (strcmp(mb->fb.name, "<clinit>") == 0 &&
strcmp(mb->fb.signature, "()V") == 0)
context->in_clinit = TRUE;
mb->args_size = Signature2ArgsSize(mb->fb.signature)
+ ((mb->fb.access & ACC_STATIC) ? 0 : 1);
if (mb->args_size > 255)
JAVA_ERROR(context, "Too many arguments");
attribute_count = get2bytes(context);
for (j = 0; j < attribute_count; j++) {
char *attr_name = getAsciz(context);
if ((strcmp(attr_name, "Code") == 0)
&& ((mb->fb.access & (ACC_NATIVE | ACC_ABSTRACT))==0)) {
ReadInCode(context, mb);
} else if (strcmp(attr_name, "Exceptions") == 0) {
ReadExceptions(context, mb);
} else {
int length = get4bytes(context);
getNbytes(context, length, NULL);
}
}
context->in_clinit = FALSE;
}
/* See if there are class attributes */
attribute_count = get2bytes(context);
for (j = 0; j < attribute_count; j++) {
char *name = getAsciz(context);
int length = get4bytes(context);
if (strcmp(name, "SourceFile") == 0) {
if (length != 2) {
JAVA_ERROR(context, "Wrong size for VALUE attribute");
}
ucb->source_name = getAsciz(context);
#ifdef JCOV
} else if (strcmp(name, "AbsoluteSourcePath") == 0) {
if (length == 2) {
ucb->absolute_source_name = getAsciz(context);
} else
getNbytes(context, length, NULL);
} else if (strcmp(name, "TimeStamp") == 0) {
unsigned high;
unsigned low;
int64_t value;
Java8 t1;
if (length == 8) {
high = get4bytes(context);
low = get4bytes(context);
value = ll_add(ll_shl(uint2ll(high), 32), uint2ll(low));
SET_INT64(t1, &ucb->timestamp, value);
} else
getNbytes(context, length, NULL);
#endif
} else {
getNbytes(context, length, NULL);
}
}
}
static void LoadConstantPool(CICcontext *context)
{
ClassClass *cb = context->cb;
int nconstants = get2bytes(context);
cp_item_type *constant_pool;
unsigned char *type_table;
int i;
Java8 t1;
if (nconstants > 16384) {
JAVA_ERROR(context, "Preverifier only "
"handles constant pool size up to 16K");
}
t1.x[0] = 0; /* shut off warning */
if (nconstants < CONSTANT_POOL_UNUSED_INDEX) {
JAVA_ERROR(context, "Illegal constant pool size");
}
constant_pool = (cp_item_type *)
allocNBytes(context, nconstants * sizeof(cp_item_type));
type_table = allocNBytes(context, nconstants * sizeof(char));
for (i = CONSTANT_POOL_UNUSED_INDEX; i < nconstants; i++) {
int type = get1byte(context);
CONSTANT_POOL_TYPE_TABLE_PUT(type_table, i, type);
switch (type) {
case CONSTANT_Utf8: {
int length = get2bytes(context);
char *result = allocNBytes(context, length + 1);
getNbytes(context, length, result);
result[length] = '\0';
constant_pool[i].cp = result;
CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(type_table, i);
break;
}
case CONSTANT_Class:
case CONSTANT_String:
constant_pool[i].i = get2bytes(context);
break;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
case CONSTANT_NameAndType:
constant_pool[i].i = get4bytes(context);
break;
case CONSTANT_Float:
if (check_on) {
panic("floating-point constants should not appear");
}
case CONSTANT_Integer:
constant_pool[i].i = get4bytes(context);
CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(type_table, i);
break;
case CONSTANT_Double:
if (check_on) {
panic("floating-point constants should not appear");
}
case CONSTANT_Long: {
unsigned high = get4bytes(context);
unsigned low = get4bytes(context);
int64_t value;
value = ll_add(ll_shl(uint2ll(high), 32), uint2ll(low));
SET_INT64(t1, &constant_pool[i], value);
CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(type_table, i);
i++; /* increment i for loop, too */
if (i >= nconstants) {
JAVA_ERROR(context, "illegal constant pool entry");
}
/* Indicate that the next object in the constant pool cannot
* be accessed independently. */
CONSTANT_POOL_TYPE_TABLE_PUT(type_table, i, 0);
CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(type_table, i);
break;
}
default:
JAVA_ERROR(context, "Illegal constant pool type");
}
}
/* It is important to only set these after everything is setup,
so that the GC sees a consistent state.*/
cbConstantPool(cb) = constant_pool;
cbConstantPoolCount(cb) = nconstants;
constant_pool[CONSTANT_POOL_TYPE_TABLE_INDEX].type = type_table;
}
bool loadParallax (unsigned short v, unsigned short fracX, unsigned short fracY) {
setResourceForFatal (v);
if (! openFileFromNum (v)) return fatal ("Can't open parallax image");
parallaxLayer * nP = new parallaxLayer;
if (! checkNew (nP)) return false;
nP -> next = parallaxStuff;
parallaxStuff = nP;
if (nP -> next) {
nP -> next -> prev = nP;
}
nP -> prev = NULL;
int picWidth;
int picHeight;
long file_pointer = ftell (bigDataFile);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
size_t bytes_read = fread(tmp, 1, 8, bigDataFile);
if (bytes_read != 8 && ferror (bigDataFile)) {
debugOut("Reading error in loadParallax.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(bigDataFile, file_pointer, SEEK_SET);
picWidth = nP -> width = get2bytes (bigDataFile);
picHeight = nP -> height = get2bytes (bigDataFile);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, bigDataFile); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
picWidth = nP -> width = width;
picHeight = nP -> height = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
//int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
}
if (! NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
}
nP -> fileNum = v;
nP -> fractionX = fracX;
nP -> fractionY = fracY;
if (fracX == 65535) {
nP -> wrapS = false;
if (nP -> width < winWidth) {
fatal ("For AUTOFIT parallax backgrounds, the image must be at least as wide as the game window/screen.");
return false;
}
} else {
nP -> wrapS = true;
}
if (fracY == 65535) {
nP -> wrapT = false;
if (nP -> height < winHeight) {
fatal ("For AUTOFIT parallax backgrounds, the image must be at least as tall as the game window/screen.");
return false;
}
} else {
nP -> wrapT = true;
}
nP -> texture = new GLubyte [picHeight * picWidth * 4];
if (! checkNew (nP -> texture)) return false;
if (fileIsPNG) {
unsigned char * row_pointers[nP -> height];
for (int i = 0; i < nP -> height; i++)
row_pointers[i] = nP -> texture + 4*i*picWidth;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
int t1, t2, n;
unsigned short c;
GLubyte * target;
for (t2 = 0; t2 < nP -> height; t2 ++) {
t1 = 0;
while (t1 < nP -> width) {
c = (unsigned short) get2bytes (bigDataFile);
if (c & 32) {
n = fgetc (bigDataFile) + 1;
c -= 32;
} else {
n = 1;
}
while (n--) {
target = nP -> texture + 4*picWidth*t2 + t1*4;
if (c == 63519 || c == 2015) {
target[0] = (GLubyte) 0;
target[1] = (GLubyte) 0;
target[2] = (GLubyte) 0;
target[3] = (GLubyte) 0;
} else {
target[0] = (GLubyte) redValue(c);
target[1] = (GLubyte) greenValue(c);
target[2] = (GLubyte) blueValue(c);
target[3] = (GLubyte) 255;
}
t1 ++;
}
}
}
}
glGenTextures (1, &nP->textureName);
glBindTexture (GL_TEXTURE_2D, nP->textureName);
if (nP -> wrapS)
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
else
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
if (nP -> wrapT)
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
else
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (gameSettings.antiAlias < 0) {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, picWidth, picHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nP->texture, nP->textureName);
finishAccess ();
setResourceForFatal (-1);
return true;
}
bool setZBuffer (int y) {
int x, n;
uint32_t stillToGo = 0;
int yPalette[16], sorted[16], sortback[16];
killZBuffer ();
setResourceForFatal (y);
zBuffer.originalNum = y;
if (! openFileFromNum (y)) return false;
if (fgetc (bigDataFile) != 'S') return fatal ("Not a Z-buffer file");
if (fgetc (bigDataFile) != 'z') return fatal ("Not a Z-buffer file");
if (fgetc (bigDataFile) != 'b') return fatal ("Not a Z-buffer file");
switch (fgetc (bigDataFile)) {
case 0:
zBuffer.width = 640;
zBuffer.height = 480;
break;
case 1:
zBuffer.width = get2bytes (bigDataFile);
zBuffer.height = get2bytes (bigDataFile);
break;
default:
return fatal ("Extended Z-buffer format not supported in this version of the SLUDGE engine");
}
if (zBuffer.width != sceneWidth || zBuffer.height != sceneHeight) {
char tmp[256];
sprintf (tmp, "Z-w: %d Z-h:%d w: %d, h:%d", zBuffer.width, zBuffer.height, sceneWidth, sceneHeight);
return fatal ("Z-buffer width and height don't match scene width and height", tmp);
}
zBuffer.numPanels = fgetc (bigDataFile);
for (y = 0; y < zBuffer.numPanels; y ++) {
yPalette[y] = get2bytes (bigDataFile);
}
sortZPal (yPalette, sorted, zBuffer.numPanels);
for (y = 0; y < zBuffer.numPanels; y ++) {
zBuffer.panel[y] = yPalette[sorted[y]];
sortback[sorted[y]] = y;
}
int picWidth = sceneWidth;
int picHeight = sceneHeight;
if (! NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
}
zBuffer.tex = new GLubyte [picHeight*picWidth];
if (! checkNew (zBuffer.tex)) return false;
for (y = 0; y < sceneHeight; y ++) {
for (x = 0; x < sceneWidth; x ++) {
if (stillToGo == 0) {
n = fgetc (bigDataFile);
stillToGo = n >> 4;
if (stillToGo == 15) stillToGo = get2bytes (bigDataFile) + 16l;
else stillToGo ++;
n &= 15;
}
zBuffer.tex[y*picWidth + x] = sortback[n]*16;
stillToGo --;
}
}
int
convert_TI_records(
FILE *ifp,
char *inm,
FILE *ofp,
char *onm)
{
char buff[512];
char *p;
int c;
bool endrecord = FALSE;
bool eol;
buffer_rec tb;
while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
{
if (p[strlen(p)-1] == '\n') /* get rid of newline */
p[strlen(p)-1] = '\0';
if (p[strlen(p)-1] == '\r') /* get rid of any CR */
p[strlen(p)-1] = '\0';
tb.dl_count = 0;
p = &buff[0];
eol = FALSE;
while ( ! eol && ! endrecord)
{
switch (*p++)
{
case '9':
if (tb.dl_count)
write_record(&tb, ofp);
tb.dl_destaddr = get2bytes(&p);
break;
case 'B':
c = getbyte(&p);
filesum += c;
tb.dl_buf[tb.dl_count++] = c;
c = getbyte(&p);
filesum += c;
tb.dl_buf[tb.dl_count++] = c;
break;
case 'F':
eol = TRUE;
break;
case ':':
endrecord = TRUE;
break;
default:
badformat(p, inm, BADFMT);
}
}
if (tb.dl_count)
write_record(&tb, ofp);
}
return 0;
}
int
convert_S_records(
FILE *ifp,
char *inm,
FILE *ofp,
char *onm)
{
char buff[512];
char *p;
u8 cksum;
int incksum;
int c;
int len; /* data length of current line */
int rectype; /* record type */
u32 addr;
bool endrecord = FALSE;
buffer_rec tb;
while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
{
p = &buff[0];
if (p[strlen(p)-1] == '\n') /* get rid of newline */
p[strlen(p)-1] = '\0';
if (p[strlen(p)-1] == '\r') /* get rid of any CR */
p[strlen(p)-1] = '\0';
tb.dl_count = 0;
if (*p != 'S')
badformat(p, inm, BADFMT);
p++;
if ((rectype = getnibble(&p)) == -1) /* record type */
badformat(buff, inm, BADTYPE);
if ((len = getbyte(&p)) == -1) /* record len */
badformat(buff, inm, BADLEN);
cksum = len;
switch (rectype)
{
case 0x00: /* comment field, ignored */
goto write_it;
case 0x01: /* data record, 16 bit addr */
if ((addr = get2bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
len -= 3;
goto doit;
case 0x02: /* ... 24 bit addr */
if ((addr = get3bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
len -= 4;
goto doit;
case 0x03: /* ... 32 bit addr */
if ((addr = get4bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
len -= 5;
doit:
cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
tb.dl_destaddr = addr;
while (len--)
{
if ((c = getbyte(&p)) == -1)
badformat(buff, inm, BADDATA);
cksum += c;
filesum += c;
tb.dl_buf[tb.dl_count++] = c;
}
break;
case 0x07: /* 32 bit end record */
if ((addr = get4bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
goto end_rec;
case 0x08: /* 24 bit end record */
if ((addr = get3bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
goto end_rec;
case 0x09: /* 16 bit end record */
if ((addr = get2bytes(&p)) == -1L)
badformat(buff, inm, BADADDR);
end_rec:
cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
tb.dl_jumpaddr = addr;
break;
default:
error(0, "unknown Motorola-S record type: 0x%02x", rectype);
badformat(buff, inm, BADTYPE);
break;
}
/*
* Verify checksums are correct in file.
*/
cksum = (~cksum) & 0xff;
if ((incksum = getbyte(&p)) == -1)
badformat(buff, inm, BADCSUM);
if (((u8) incksum) != cksum)
badformat(buff, inm, MISCSUM);
write_it:
if (tb.dl_count)
write_record(&tb, ofp);
}
return 0;
}
bool loadHSI (FILE * fp, int x, int y, bool reserve) {
int t1, t2, n;
unsigned short c;
GLubyte * target;
int32_t transCol = reserve ? -1 : 63519;
int picWidth;
int picHeight;
int realPicWidth, realPicHeight;
long file_pointer = ftell (fp);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
size_t bytes_read = fread(tmp, 1, 8, fp);
if (bytes_read != 8 && ferror (fp)) {
debugOut("Reading error in loadHSI.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(fp, file_pointer, SEEK_SET);
picWidth = realPicWidth = get2bytes (fp);
picHeight = realPicHeight = get2bytes (fp);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, fp); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
picWidth = realPicWidth = width;
picHeight = realPicHeight = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
//int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
}
GLfloat texCoordW = 1.0;
GLfloat texCoordH = 1.0;
if (! NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
texCoordW = ((double)realPicWidth) / picWidth;
texCoordH = ((double)realPicHeight) / picHeight;
}
if (reserve) {
if (! resizeBackdrop (realPicWidth, realPicHeight)) return false;
}
if (x == IN_THE_CENTRE) x = (sceneWidth - realPicWidth) >> 1;
if (y == IN_THE_CENTRE) y = (sceneHeight - realPicHeight) >> 1;
if (x < 0 || x + realPicWidth > sceneWidth || y < 0 || y + realPicHeight > sceneHeight) return false;
if (fileIsPNG) {
unsigned char * row_pointers[realPicHeight];
for (int i = 0; i<realPicHeight; i++)
row_pointers[i] = backdropTexture + 4*i*picWidth;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
for (t2 = 0; t2 < realPicHeight; t2 ++) {
t1 = 0;
while (t1 < realPicWidth) {
c = (unsigned short) get2bytes (fp);
if (c & 32) {
n = fgetc (fp) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
target = backdropTexture + 4*picWidth*t2 + t1*4;
if (c == transCol || c == 2015) {
target[0] = (GLubyte) 0;
target[1] = (GLubyte) 0;
target[2] = (GLubyte) 0;
target[3] = (GLubyte) 0;
} else {
target[0] = (GLubyte) redValue(c);
target[1] = (GLubyte) greenValue(c);
target[2] = (GLubyte) blueValue(c);
target[3] = (GLubyte) 255;
}
t1++;
}
}
}
}
GLuint tmpTex;
glGenTextures (1, &tmpTex);
glBindTexture(GL_TEXTURE_2D, tmpTex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (gameSettings.antiAlias < 0) {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, picWidth, picHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, backdropTexture, tmpTex);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
float btx1;
float btx2;
float bty1;
float bty2;
if (! NPOT_textures) {
btx1 = backdropTexW * x / sceneWidth;
btx2 = backdropTexW * (x+realPicWidth) / sceneWidth;
bty1 = backdropTexH * y / sceneHeight;
bty2 = backdropTexH * (y+realPicHeight) / sceneHeight;
} else {
btx1 = (float) x / sceneWidth;
btx2 = (float) (x+realPicWidth) / sceneWidth;
bty1 = (float) y / sceneHeight;
bty2 = (float) (y+realPicHeight) / sceneHeight;
}
const GLfloat btexCoords[] = {
btx1, bty1,
btx2, bty1,
btx1, bty2,
btx2, bty2
};
setPixelCoords (true);
int xoffset = 0;
while (xoffset < realPicWidth) {
int w = (realPicWidth-xoffset < viewportWidth) ? realPicWidth-xoffset : viewportWidth;
int yoffset = 0;
while (yoffset < realPicHeight) {
int h = (realPicHeight-yoffset < viewportHeight) ? realPicHeight-yoffset : viewportHeight;
glClear(GL_COLOR_BUFFER_BIT); // Clear The Screen
const GLfloat vertices[] = {
(GLfloat)-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)realPicWidth-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)-xoffset, (GLfloat)-yoffset+realPicHeight, 0.,
(GLfloat)realPicWidth-xoffset, (GLfloat)-yoffset+realPicHeight, 0.
};
const GLfloat texCoords[] = {
0.0f, 0.0f,
texCoordW, 0.0f,
0.0f, texCoordH,
texCoordW, texCoordH
};
if (backdropExists) {
// Render the sprite to the backdrop
// (using mulitexturing, so the old backdrop is seen where alpha < 1.0)
glActiveTexture(GL_TEXTURE2);
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glActiveTexture(GL_TEXTURE0);
glUseProgram(shader.paste);
GLint uniform = glGetUniformLocation(shader.paste, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0); // No lighting
setPMVMatrix(shader.paste);
setPrimaryColor(1.0, 1.0, 1.0, 1.0);
glBindTexture(GL_TEXTURE_2D, tmpTex);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
drawQuad(shader.paste, vertices, 3, texCoords, NULL, btexCoords);
glUseProgram(0);
} else {
// It's all new - nothing special to be done.
glUseProgram(shader.texture);
setPMVMatrix(shader.texture);
glBindTexture(GL_TEXTURE_2D, tmpTex);
setPrimaryColor(1.0, 0.0, 0.0, 0.0);
drawQuad(shader.texture, vertices, 1, texCoords);
glUseProgram(0);
}
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, x+xoffset, y+yoffset, viewportOffsetX, viewportOffsetY, w, h, backdropTextureName);
yoffset += viewportHeight;
}
xoffset += viewportWidth;
}
deleteTextures(1, &tmpTex);
setPixelCoords (false);
backdropExists = true;
return true;
}
bool initSludge (char * filename) {
int a = 0;
mouseCursorAnim = makeNullAnim ();
FILE * fp = openAndVerify (filename, 'G', 'E', ERROR_BAD_HEADER, gameVersion);
if (! fp) return false;
if (fgetc (fp)) {
numBIFNames = get2bytes (fp);
allBIFNames = new char * [numBIFNames];
if (! checkNew (allBIFNames)) return false;
for (int fn = 0; fn < numBIFNames; fn ++) {
allBIFNames[fn] = readString (fp);
}
numUserFunc = get2bytes (fp);
allUserFunc = new char * [numUserFunc];
if (! checkNew (allUserFunc)) return false;
for (int fn = 0; fn < numUserFunc; fn ++) {
allUserFunc[fn] = readString (fp);
}
if (gameVersion >= VERSION(1,3)) {
numResourceNames = get2bytes (fp);
allResourceNames = new char * [numResourceNames];
if (! checkNew (allResourceNames)) return false;
for (int fn = 0; fn < numResourceNames; fn ++) {
allResourceNames[fn] = readString (fp);
}
}
}
winWidth = get2bytes (fp);
winHeight = get2bytes (fp);
specialSettings = fgetc (fp);
desiredfps = 1000/fgetc (fp);
delete[] readString (fp); // Unused - was used for registration purposes.
size_t bytes_read = fread (& fileTime, sizeof (FILETIME), 1, fp);
if (bytes_read != sizeof (FILETIME) && ferror (fp)) {
debugOut("Reading error in initSludge.\n");
}
char * dataFol = (gameVersion >= VERSION(1,3)) ? readString(fp) : joinStrings ("", "");
gameSettings.numLanguages = (gameVersion >= VERSION(1,3)) ? (fgetc (fp)) : 0;
makeLanguageTable (fp);
if (gameVersion >= VERSION(1,6))
{
fgetc(fp);
// aaLoad
fgetc (fp);
getFloat (fp);
getFloat (fp);
}
char * checker = readString (fp);
if (strcmp (checker, "okSoFar")) return fatal (ERROR_BAD_HEADER, filename);
delete checker;
checker = NULL;
unsigned char customIconLogo = fgetc (fp);
if (customIconLogo & 1) {
// There is an icon - read it!
int n;
long file_pointer = ftell (fp);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
bytes_read = fread(tmp, 1, 8, fp);
if (bytes_read != 8 && ferror (fp)) {
debugOut("Reading error in initSludge.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(fp, file_pointer, SEEK_SET);
iconW = get2bytes (fp);
iconH = get2bytes (fp);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, fp); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
iconW = width;
iconH = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
}
gameIcon = new unsigned char [iconW*iconH*4];
if (! gameIcon) return fatal ("Can't reserve memory for game icon.");
int32_t transCol = 63519;
Uint8 *p = (Uint8 *) gameIcon;
if (fileIsPNG) {
unsigned char * row_pointers[iconH];
for (int i = 0; i<iconH; i++)
row_pointers[i] = p + 4*i*iconW;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
for (int t2 = 0; t2 < iconH; t2 ++) {
int t1 = 0;
while (t1 < iconW) {
unsigned short c = (unsigned short) get2bytes (fp);
if (c & 32) {
n = fgetc (fp) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
*p++ = (Uint8) redValue(c);
*p++ = (Uint8) greenValue(c);
*p++ = (Uint8) blueValue(c);
*p++ = (Uint8) (c == transCol) ? 0 : 255;
t1++;
}
}
}
}
}
if (customIconLogo & 2) {
// There is an logo - read it!
int n;
long file_pointer = ftell (fp);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
bytes_read = fread(tmp, 1, 8, fp);
if (bytes_read != 8 && ferror (fp)) {
debugOut("Reading error in initSludge.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(fp, file_pointer, SEEK_SET);
logoW = get2bytes (fp);
logoH = get2bytes (fp);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, fp); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
logoW = width;
logoH = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
#ifdef WIN32
// Windows wants a BGR bitmap
if (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA)
png_set_bgr(png_ptr);
#endif
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
}
if ((logoW != 310) || (logoH != 88)) return fatal ("Game logo have wrong dimensions. (Should be 310x88)");
gameLogo = new unsigned char [logoW*logoH*4];
if (! gameLogo) return fatal ("Can't reserve memory for game logo.");
// int32_t transCol = 63519;
Uint8 *p = (Uint8 *) gameLogo;
if (fileIsPNG) {
unsigned char * row_pointers[logoH];
for (int i = 0; i<logoH; i++)
row_pointers[i] = p + 4*i*logoW;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
for (int t2 = 0; t2 < logoH; t2 ++) {
int t1 = 0;
while (t1 < logoW) {
unsigned short c = (unsigned short) get2bytes (fp);
if (c & 32) {
n = fgetc (fp) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
#ifdef WIN32
// Windows wants a BGR bitmap
*p++ = (Uint8) blueValue(c);
*p++ = (Uint8) greenValue(c);
*p++ = (Uint8) redValue(c);
#else
*p++ = (Uint8) redValue(c);
*p++ = (Uint8) greenValue(c);
*p++ = (Uint8) blueValue(c);
#endif
*p++ = (Uint8) /*(c == transCol) ? 0 :*/ 255;
t1++;
}
}
}
}
}
numGlobals = get2bytes (fp);
globalVars = new variable[numGlobals];
if (! checkNew (globalVars)) return false;
for (a = 0; a < numGlobals; a ++) initVarNew (globalVars[a]);
// Get the original (untranslated) name of the game and convert it to Unicode.
// We use this to find saved preferences and saved games.
setFileIndices (fp, gameSettings.numLanguages, 0);
char * gameNameOrig = getNumberedString(1);
char * gameName = encodeFilename (gameNameOrig);
delete gameNameOrig;
changeToUserDir ();
#ifdef _WIN32
mkdir (gameName);
#else
mkdir (gameName, 0000777);
#endif
if (chdir (gameName)) return fatal ("This game's preference folder is inaccessible!\nI can't access the following directory (maybe there's a file with the same name, or maybe it's read-protected):", gameName);
delete [] gameName;
// Get user settings
readIniFile (filename);
// There's no startup window on Linux and respecting this
// option from the ini file would disable commandline options.
#if defined __unix__ && !(defined __APPLE__)
if (! showSetupWindow()) return 0;
saveIniFile (filename);
#else
if (! gameSettings.noStartWindow) {
if (! showSetupWindow()) return 0;
saveIniFile (filename);
}
#endif
// Now set file indices properly to the chosen language.
languageNum = getLanguageForFileB ();
if (languageNum < 0) return fatal ("Can't find the translation data specified!");
setFileIndices (NULL, gameSettings.numLanguages, languageNum);
if (dataFol[0]) {
char *dataFolder = encodeFilename(dataFol);
#ifdef _WIN32
mkdir (dataFolder);
#else
mkdir (dataFolder, 0000777);
#endif
if (chdir (dataFolder)) return fatal ("This game's data folder is inaccessible!\nI can't access the following directory (maybe there's a file with the same name, or maybe it's read-protected):", dataFolder);
delete dataFolder;
}
positionStatus (10, winHeight - 15);
return true;
}
int
convert_Intel_records(
FILE *ifp,
char *inm,
FILE *ofp,
char *onm)
{
char buff[512];
char *p;
u8 cksum;
int incksum;
int c;
int rectype; /* record type */
int len; /* data length of current line */
u32 addr;
u32 base_address = 0;
bool endrecord = FALSE;
buffer_rec tb;
while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
{
p = &buff[0];
if (p[strlen(p)-1] == '\n') /* get rid of newline */
p[strlen(p)-1] = '\0';
if (p[strlen(p)-1] == '\r') /* get rid of any CR */
p[strlen(p)-1] = '\0';
tb.dl_count = 0;
if (*p != ':')
badformat(p, inm, BADFMT);
p++;
if ((len = getbyte(&p)) == -1) /* record len */
badformat(buff, inm, BADLEN);
if ((addr = get2bytes(&p)) == -1L) /* record addr */
badformat(buff, inm, BADADDR);
rectype = getbyte(&p);
cksum = len + B0(addr) + B1(addr) + rectype;
switch (rectype)
{
case 0x00: /* normal data record */
tb.dl_destaddr = base_address + addr;
while (len--)
{
if ((c = getbyte(&p)) == -1)
badformat(buff, inm, BADDATA);
cksum += c;
filesum += c;
tb.dl_buf[tb.dl_count++] = c;
}
break;
case 0x01: /* execution start address */
base_address = addr;
endrecord = TRUE;
break;
case 0x02: /* new base */
if ((base_address = get2bytes(&p)) == -1L)
badformat(buff, inm, BADBASE);
cksum += B0(base_address) + B1(base_address);
base_address <<= 4;
break;
case 0x03: /* seg/off execution start address */
{
u32 seg, off;
seg = get2bytes(&p);
off = get2bytes(&p);
if ((seg == -1L) || (off == -1L))
badformat(buff, inm, BADADDR);
cksum += B0(seg) + B1(seg) + B0(off) + B1(off);
tb.dl_jumpaddr = (seg << 4) + off;
break;
}
default:
error(0, "unknown Intel-hex record type: 0x%02x", rectype);
badformat(buff, inm, BADTYPE);
}
/*
* Verify checksums are correct in file.
*/
cksum = (-cksum) & 0xff;
if ((incksum = getbyte(&p)) == -1)
badformat(buff, inm, BADCSUM);
if (((u8) incksum) != cksum)
badformat(buff, inm, MISCSUM);
if (tb.dl_count)
write_record(&tb, ofp);
}
return 0;
}
bool loadPeople (FILE * fp) {
onScreenPerson * * pointy = & allPeople;
onScreenPerson * me;
scaleHorizon = getSigned (fp);
scaleDivide = getSigned (fp);
int countPeople = get2bytes (fp);
int a;
allPeople = NULL;
for (a = 0; a < countPeople; a ++) {
me = new onScreenPerson;
if (! checkNew (me)) return false;
me -> myPersona = new persona;
if (! checkNew (me -> myPersona)) return false;
me -> myAnim = new personaAnimation;
if (! checkNew (me -> myAnim)) return false;
me -> x = getFloat (fp);
me -> y = getFloat (fp);
loadCostume (me -> myPersona, fp);
loadAnim (me -> myAnim, fp);
me -> lastUsedAnim = fgetc (fp) ? me -> myAnim : NULL;
me -> scale = getFloat (fp);
me -> extra = get2bytes (fp);
me -> height = get2bytes (fp);
me -> walkToX = get2bytes (fp);
me -> walkToY = get2bytes (fp);
me -> thisStepX = get2bytes (fp);
me -> thisStepY = get2bytes (fp);
me -> frameNum = get2bytes (fp);
me -> frameTick = get2bytes (fp);
me -> walkSpeed = get2bytes (fp);
me -> spinSpeed = get2bytes (fp);
me -> floaty = getSigned (fp);
me -> show = fgetc (fp);
me -> walking = fgetc (fp);
me -> spinning = fgetc (fp);
if (fgetc (fp)) {
me -> continueAfterWalking = loadFunction (fp);
if (! me -> continueAfterWalking) return false;
} else {
me -> continueAfterWalking = NULL;
}
me -> direction = get2bytes(fp);
me -> angle = get2bytes(fp);
if (ssgVersion >= VERSION(2,0)) {
me -> angleOffset = get2bytes(fp);
} else {
me -> angleOffset = 0;
}
me -> wantAngle = get2bytes(fp);
me -> directionWhenDoneWalking = getSigned(fp);
me -> inPoly = getSigned(fp);
me -> walkToPoly = getSigned(fp);
if (ssgVersion >= VERSION(2,0)) {
me -> r = fgetc (fp);
me -> g = fgetc (fp);
me -> b = fgetc (fp);
me -> colourmix = fgetc (fp);
me -> transparency = fgetc (fp);
} else {
setMyDrawMode(me, get2bytes(fp));
}
me -> thisType = loadObjectRef (fp);
// Anti-aliasing settings
if (ssgVersion >= VERSION(1,6))
{
if (ssgVersion < VERSION (2,0)) {
// aaLoad
fgetc (fp);
getFloat (fp);
getFloat (fp);
}
}
me -> next = NULL;
* pointy = me;
pointy = & (me -> next);
}
// db ("End of loadPeople");
return true;
}
