static int load_frame_binary(cst_track *t, int i, cst_tokenstream *ts,
int swap)
{
float val;
int j;
if (cst_fread(ts->fd, &val, sizeof(float), 1) != 1)
return -1;
if (swap)
swapfloat(&val);
t->times[i] = val;
/* Ignore the 'breaks' field */
if (cst_fread(ts->fd, &val, sizeof(float), 1) != 1)
return -1;
for (j = 0; j < t->num_channels; j++)
{
if (cst_fread(ts->fd, &val, sizeof(float), 1) != 1)
return -1;
if (swap)
swapfloat(&val);
t->frames[i][j] = val;
}
return 0;
}
void swaphead(PICTURE *pic)
{ pic->fileid = swapint(pic->fileid);
pic->x = swapint(pic->x);
pic->y = swapint(pic->y);
pic->xorigin = swapfloat(pic->xorigin);
pic->yorigin = swapfloat(pic->yorigin);
pic->items = swapint(pic->items);
pic->samples = swapint(pic->samples);
}
void swapvertices(Mesh *m)
{
int np=m->np;
float3D *p=m->p;
int i;
for(i=0;i<np;i++)
{
swapfloat(&p[i].x);
swapfloat(&p[i].y);
swapfloat(&p[i].z);
}
}
/* instantiates *(pic->data), swaps as needed, readhead called before */
int readdata(PICTURE *pic, FILE *fp)
{
int magic = pic->magic;
if ((pic->data) == NULL)
{ if (newdata(pic)) return(-1); }
switch (magic) {
case PGM_ASCI_MAGIC: case PPM_ASCI_MAGIC: case VISA_MAGIC: case VISA_SWMAGIC:
readascidata(pic,fp); break;
case VIS_MAGIC: case PGM_MAGIC: case PPM_MAGIC:
if ( fread(pic->data,sizeofdata(pic),1,fp) == 0)
{
(void)fprintf(stderr,"readdata: failed to read binary data\n");
return(-1);
} break;
case VIS_SWMAGIC: /* now does endian swapping */
{
int x, sz = (pic->items)*(pic->samples);
switch (pic->fileid) {
case IMAGE_ID: break; /* no need to swap individual chars */
case INT_ID: {
INT_TYPE *buf = (INT_TYPE *)(pic->data);
for (x=0; x<sz; x++) { *buf = swapint(*buf); buf++; } }
break;
case FIMAGE_ID: {
FIMAGE_TYPE *buf = (FIMAGE_TYPE *)(pic->data);
for (x=0; x<sz; x++) { *buf = swapfloat(*buf); buf++; } }
break;
default: (void)fprintf(stderr,
"readdata: please recreate the input file on this architecture\n");
return(-1); }
} break;
default: (void)fprintf(stderr,"readdata: strange magic\n"); return(-1); }
return(0);
}
static void WRITE_PLAYERSTATS(int x, rankstats_t *os)
{
rankstats_t ns;
int i;
VFS_SEEK(rankfile, sizeof(rankfileheader_t)+sizeof(rankheader_t)+((x-1)*sizeof(rankinfo_t)));
ns.kills = swaplong(os->kills);
ns.deaths = swaplong(os->deaths);
for (i = 0; i < NUM_RANK_SPAWN_PARMS; i++)
ns.parm[i] = swapfloat(os->parm[i]);
ns.timeonserver = swapfloat(os->timeonserver);
ns.flags1 = (os->flags1);
ns.trustlevel = (os->trustlevel);
ns.pad2 = (os->pad2);
ns.pad3 = (os->pad3);
VFS_WRITE(rankfile, &ns, sizeof(rankstats_t));
}
static void READ_PLAYERSTATS(int x, rankstats_t *os)
{
int i;
size_t result;
VFS_SEEK(rankfile, sizeof(rankfileheader_t)+sizeof(rankheader_t)+((x-1)*sizeof(rankinfo_t)));
result = VFS_READ(rankfile, os, sizeof(rankstats_t));
if (result != sizeof(rankstats_t))
Con_Printf("READ_PLAYERSTATS() fread: expected %lu, result was %u\n",(long unsigned int)sizeof(rankstats_t),(unsigned int)result);
os->kills = swaplong(os->kills);
os->deaths = swaplong(os->deaths);
for (i = 0; i < NUM_RANK_SPAWN_PARMS; i++)
os->parm[i] = swapfloat(os->parm[i]);
os->timeonserver = swapfloat(os->timeonserver);
// os->flags1 = (os->flags1);
// os->trustlevel = (os->trustlevel);
// os->pad2 = (os->pad2);
// os->pad3 = (os->pad3);
}
static void WRITE_PLAYERHEADER(int x, rankheader_t *oh)
{
rankheader_t nh;
VFS_SEEK(rankfile, sizeof(rankfileheader_t)+((x-1)*sizeof(rankinfo_t)));
nh.prev = swaplong(oh->prev); //score is held for convineance.
nh.next = swaplong(oh->next);
Q_strncpyz(nh.name, oh->name, sizeof(nh.name));
nh.pwd = swaplong(oh->pwd);
nh.score = swapfloat(oh->score);
VFS_WRITE(rankfile, &nh, sizeof(rankheader_t));
}
static void READ_PLAYERHEADER(int x, rankheader_t *oh)
{
size_t result;
VFS_SEEK(rankfile, sizeof(rankfileheader_t)+((x-1)*sizeof(rankinfo_t)));
result = VFS_READ(rankfile, oh, sizeof(rankheader_t));
if (result != sizeof(rankheader_t))
Con_Printf("READ_PLAYERHEADER() fread: expected %lu, result was %u\n",(long unsigned int)sizeof(rankheader_t),(unsigned int)result);
oh->prev = swaplong(oh->prev); //score is held for convineance.
oh->next = swaplong(oh->next);
// strcpy(oh->name, oh->name);
oh->pwd = swaplong(oh->pwd);
oh->score = swapfloat(oh->score);
}
void *pfm_readpfm_type(FILE *fp,
int *cols,
int *rows,
float *minval,
float *maxval,
int storageType,
PFMConvert *convFunc)
{
/* int compressed;*/
void *ret_val;
char buffer[1024];
char *data=0;
float *floatbuffer=0;
double *doublebuffer=0;
int *intbuffer=0;
uint16 *int16buffer=0;
grey *greybuffer=0;
PFM3Byte *ppmbuffer=0;
int byte_order=BYTEORDER;
int r,c;
int type;
int storage_size[]={
sizeof(float),
sizeof(signed int),
sizeof(unsigned int),
sizeof(sint16),
sizeof(uint16),
sizeof(grey),
sizeof(unsigned char),
sizeof(unsigned char),
sizeof(double)
};
ConvertFunc* double2[]={
double2float,
double2sint,
double2sint,
double2uint16,
double2uint16,
0,0,0,
double2double,
0};
ConvertFunc* float2[]={
float2float,
float2sint,
float2sint,
float2uint16,
float2uint16,
0,0,0,
float2double,
0};
ConvertFunc* uint162[]={
uint162float,
uint162sint,
uint162sint,
uint162uint16,
uint162uint16,
0,0,0,
uint162double,
0};
ConvertFunc* sint2[]={
sint2float,
sint2sint,
sint2sint,
sint2uint16,
sint2uint16,
0,0,0,
sint2double,
0};
ConvertFunc* pgm2[]={
pgm2float,
pgm2sint,
pgm2sint,
pgm2uint16,
pgm2uint16,
pgm2pgm,
0,0,
pgm2double,
0};
ConvertFunc* pbm2[]={
0,0,0,0,0,0,0,0,0,0
};
memset(buffer, 0, 1024);
pfmGeoRead_=0;
if (pfmCommentRead_) free(pfmCommentRead_);
pfmCommentRead_=0;
pfmGeoSet_=0;
fp=check_compression(buffer,fp);
#ifdef DEBUG
printf("pfm_readpfm: %s\n",buffer);
#endif
switch (buffer[0]) {
case 'F':
switch (buffer[1]) {
case '0':
type=PFM_FLOAT_ASCII;
break;
case '1':
type=PFM_INT_ASCII;
break;
case '2':
type=PFM_INT16_ASCII;
break;
case '3':
type=PFM_DOUBLE_ASCII;
break;
case '4':
type=PFM_FLOAT_BIN;
break;
case '5':
type=PFM_INT_BIN;
break;
case '6':
type=PFM_INT16_BIN;
break;
case '7':
type=PFM_DOUBLE_BIN;
break;
default:
fprintf(stderr,"pfm_readpfm: Wrong fileformat!\n");
ret_val=0;
goto exit_read_pfm;
}
break;
case 'P':
switch (buffer[1]) {
case '1':
type=PFM_PBM_ASCII;
break;
case '2':
type=PFM_PGM_ASCII;
break;
case '3':
type=PFM_PPM_ASCII;
break;
case '4':
type=PFM_PBM_BIN;
break;
case '5':
type=PFM_PGM_BIN;
break;
case '6':
type=PFM_PPM_BIN;
break;
default:
fprintf(stderr,"pfm_readpfm: Wrong fileformat!\n");
ret_val=0;
goto exit_read_pfm;
}
break;
default:
{
fprintf(stderr,"pfm_readpfm: Wrong fileformat!\n");
ret_val=0;
goto exit_read_pfm;
}
}
if ((type>=PFM_FLOAT_BIN) && (type<=PFM_DOUBLE_BIN))
{
read_buffer(buffer,1023,fp);
#ifdef DEBUG
printf("pfm_readpfm: %s\n",buffer);
#endif
if (buffer[0] == 'L') {
byte_order=PFM_LittleEndian;
}
else {
byte_order=PFM_BigEndian;
}
}
read_buffer(buffer,1023,fp);
#ifdef DEBUG
printf("pfm_readpfm: %s\n",buffer);
#endif
sscanf(buffer,"%d %d",cols,rows);
read_buffer(buffer,1023,fp);
#ifdef DEBUG
printf("pfm_readpfm: %s\n",buffer);
#endif
pfm_mult=0.0;
pfm_offset=0.0;
if (sscanf(buffer,"%f %f %f %f",minval,maxval,&pfm_mult,&pfm_offset)<2) {
*maxval=*minval;
*minval=0.0;
}
if (type==PFM_PGM_BIN && *maxval>255) {
type=PFM_INT16_BIN;
byte_order=PFM_BigEndian;
}
if (type==PFM_PGM_ASCII && *maxval>255 && *maxval<=65535) {
type=PFM_INT16_ASCII;
byte_order=PFM_BigEndian;
}
if (pfm_mult!=0.0) convFunc=StretchConvert;
#ifdef DEBUG
printf("pfm_readpfm: cols=%d rows=%d min=%f max=%f byte_order=%s\n",
*cols,*rows,*minval,*maxval,(byte_order==PFM_BigEndian ? "BE" : "LE"));
#endif
if (type==PFM_PPM_BIN) {
ppmbuffer=(PFM3Byte*)malloc(sizeof(PFM3Byte));
ppmbuffer->r=(unsigned char*)calloc(*cols*(*rows),storage_size[storageType]);
ppmbuffer->g=(unsigned char*)calloc(*cols*(*rows),storage_size[storageType]);
ppmbuffer->b=(unsigned char*)calloc(*cols*(*rows),storage_size[storageType]);
if (ppmbuffer && ppmbuffer->r && ppmbuffer->g && ppmbuffer->b)
data=(void*)ppmbuffer;
}
else data =(void*)calloc(*cols*(*rows),storage_size[storageType]);
if (!data)
{
fprintf(stderr,"pfm_readpfm: Out of memory while allocating input buffer!\n");
ret_val=0;
goto exit_read_pfm;
}
switch (type)
{
case PFM_FLOAT_ASCII:
if (!float2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from float to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
floatbuffer=(float*)calloc(*cols,sizeof(float));
if (!floatbuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary float buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
for (c=0; c<*cols; c++) {
fscanf(fp,"%f",&(floatbuffer[c]));
}
float2[storageType](&data[r*(*cols)*storage_size[storageType]],
floatbuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(floatbuffer);
break;
case PFM_FLOAT_BIN:
if (!float2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from float to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
floatbuffer=(float*)calloc(*cols,sizeof(float));
if (!floatbuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary float buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(floatbuffer,sizeof(float),*cols,fp);
swapfloat(floatbuffer,*cols,byte_order);
float2[storageType](&data[r*(*cols)*storage_size[storageType]],
floatbuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(floatbuffer);
break;
case PFM_DOUBLE_ASCII:
if (!double2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from double to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
doublebuffer=(double*)calloc(*cols,sizeof(double));
if (!doublebuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary double buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
for (c=0; c<*cols; c++) {
fscanf(fp,"%lf",&(doublebuffer[c]));
}
double2[storageType](&data[r*(*cols)*storage_size[storageType]],
doublebuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(doublebuffer);
break;
case PFM_DOUBLE_BIN:
if (!double2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from double to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
doublebuffer=(double*)calloc(*cols,sizeof(double));
if (!doublebuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary double buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(doublebuffer,sizeof(double),*cols,fp);
swapdouble(doublebuffer,*cols,byte_order);
double2[storageType](&data[r*(*cols)*storage_size[storageType]],
doublebuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(doublebuffer);
break;
case PFM_INT_ASCII:
if (!sint2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from int to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
intbuffer =(int*)calloc(*cols,sizeof(int));
if (!intbuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary int buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
for (c=0; c<*cols; c++) {
fscanf(fp,"%d",&(intbuffer[c]));
}
sint2[storageType](&data[r*(*cols)*storage_size[storageType]],
intbuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(intbuffer);
break;
case PFM_INT_BIN:
if (!sint2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from int to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
intbuffer =(int*)calloc(*cols,sizeof(int));
if (!intbuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary int buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(intbuffer,sizeof(int),*cols,fp);
swapint(intbuffer,*cols,byte_order);
sint2[storageType](&data[r*(*cols)*storage_size[storageType]],
intbuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(intbuffer);
break;
case PFM_INT16_ASCII:
if (!uint162[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from int16 to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
int16buffer =(uint16*)calloc(*cols,sizeof(uint16));
if (!int16buffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary int16 buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
for (c=0; c<*cols; c++) {
fscanf(fp,"%hd",&(int16buffer[c])); /* "%d" -> "%hd" (T. Wiebesiek, 31.3.2005) */
}
uint162[storageType](&data[r*(*cols)*storage_size[storageType]],
int16buffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(int16buffer);
break;
case PFM_INT16_BIN:
if (!uint162[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from int16 to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
int16buffer =(uint16*)calloc(*cols,sizeof(uint16));
if (!int16buffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary int16 buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(int16buffer,sizeof(uint16),*cols,fp);
swapint16(int16buffer,*cols,byte_order);
uint162[storageType](&data[r*(*cols)*storage_size[storageType]],
int16buffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(int16buffer);
break;
case PFM_PGM_ASCII:
fprintf(stderr,"pfm_readpfm: PGM ASCII not implemented!\n");
ret_val=0;
goto exit_read_pfm;
break;
case PFM_PGM_BIN:
if (!pgm2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from pgm to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
greybuffer =(grey*)calloc(*cols,sizeof(grey));
if (!greybuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary pgm buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(greybuffer,sizeof(grey),*cols,fp);
pgm2[storageType](&data[r*(*cols)*storage_size[storageType]],
greybuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(greybuffer);
break;
case PFM_PBM_ASCII:
fprintf(stderr,"pfm_readpfm: PBM ASCII not implented!\n");
ret_val=0;
goto exit_read_pfm;
break;
case PFM_PBM_BIN:
fprintf(stderr,"pfm_readpfm: PBM BIN not implented!\n");
ret_val=0;
goto exit_read_pfm;
if (!pbm2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from pgm to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
greybuffer =(grey*)calloc(*cols,sizeof(grey));
if (!greybuffer) {
fprintf(stderr,"pfm_readpfm: Out of memory (temporary pgm buffer)!\n");
ret_val=0;
goto exit_read_pfm;
}
for (r=0; r<*rows; r++) {
fread(greybuffer,sizeof(grey),*cols,fp);
pgm2[storageType](&data[r*(*cols)*storage_size[storageType]],
greybuffer,
*cols,
convFunc,
*minval,
*maxval);
}
free(greybuffer);
break;
case PFM_PPM_BIN:
pfm_read_ppm(fp,*cols,*rows,ppmbuffer);
#if 0
if (!pgm2[storageType]) {
fprintf(stderr,"pfm_readpfm: conversion from pgm to type %d not implemented\n",storageType);
ret_val=0;
goto exit_read_pfm;
}
#endif
break;
}
exit_read_pfm:
if (compressed_) fp=stop_decompression(fp);
return data;
}
bool TerrainMgr::LoadCellInformation(uint32 x, uint32 y)
{
#ifdef USE_MEMORY_MAPPING_FOR_MAPS
if(CellOffsets[x][y]==0)
return false;
else
return true;
#else
if(!FileDescriptor)
return false;
// Make sure that we're not already loaded.
assert(CellInformation[x][y] == 0);
// Find our offset in our cached header.
uint32 Offset = CellOffsets[x][y];
// If our offset = 0, it means we don't have cell information for
// these coords.
if(Offset == 0)
return false;
// Check that we haven't been loaded by another thread.
if(CellInformation[x][y] != 0)
{
return true;
}
// Seek to our specified offset.
if(fseek(FileDescriptor, Offset, SEEK_SET) == 0)
{
// Allocate the cell information.
CellInformation[x][y] = new CellTerrainInformation;
// Read from our file into this newly created struct.
fread(CellInformation[x][y], sizeof(CellTerrainInformation), 1, FileDescriptor);
#ifdef USING_BIG_ENDIAN
uint32 i,j;
/* Swap all the data */
for(i = 0; j < 2; ++j) {
for(j = 0; j < 2; ++j) {
CellInformation[x][y]->AreaID[i][j] = swap16(CellInformation[x][y]->AreaID[i][j]);
CellInformation[x][y]->LiquidLevel[i][j] = swapfloat(CellInformation[x][y]->LiquidLevel[i][j]);
}
}
for(i = 0; i < 32; ++j) {
for(j = 0; j < 32; ++j) {
CellInformation[x][y]->Z[i][j] = swapfloat(CellInformation[x][y]->Z[i][j]);
}
}
#endif
}
// If we don't equal 0, it means the load was successful.
if(CellInformation[x][y] != 0)
return true;
else
return false;
#endif
}
void drawtpolyperspsubtri(TPolytri *poly)
{
float x1, y1, x2, y2, x3, y3;
float iz1, uiz1, viz1, iz2, uiz2, viz2, iz3, uiz3, viz3;
float dxdy1, dxdy2, dxdy3;
float tempf;
float denom;
float dy;
int y1i, y2i, y3i;
int side;
// Shift XY coordinate system (+0.5, +0.5) to match the subpixeling
// technique
x1 = poly->x1 + 0.5;
y1 = poly->y1 + 0.5;
x2 = poly->x2 + 0.5;
y2 = poly->y2 + 0.5;
x3 = poly->x3 + 0.5;
y3 = poly->y3 + 0.5;
// Calculate alternative 1/Z, U/Z and V/Z values which will be
// interpolated
iz1 = 1 / poly->z1;
iz2 = 1 / poly->z2;
iz3 = 1 / poly->z3;
uiz1 = poly->u1 * iz1;
viz1 = poly->v1 * iz1;
uiz2 = poly->u2 * iz2;
viz2 = poly->v2 * iz2;
uiz3 = poly->u3 * iz3;
viz3 = poly->v3 * iz3;
texture = poly->texture;
// Sort the vertices in ascending Y order
#define swapfloat(x, y) tempf = x; x = y; y = tempf;
if (y1 > y2)
{
swapfloat(x1, x2);
swapfloat(y1, y2);
swapfloat(iz1, iz2);
swapfloat(uiz1, uiz2);
swapfloat(viz1, viz2);
}
if (y1 > y3)
{
swapfloat(x1, x3);
swapfloat(y1, y3);
swapfloat(iz1, iz3);
swapfloat(uiz1, uiz3);
swapfloat(viz1, viz3);
}
if (y2 > y3)
{
swapfloat(x2, x3);
swapfloat(y2, y3);
swapfloat(iz2, iz3);
swapfloat(uiz2, uiz3);
swapfloat(viz2, viz3);
}
#undef swapfloat
y1i = y1;
y2i = y2;
y3i = y3;
// Skip poly if it's too thin to cover any pixels at all
if ((y1i == y2i && y1i == y3i)
|| ((int) x1 == (int) x2 && (int) x1 == (int) x3))
return;
// Calculate horizontal and vertical increments for UV axes (these
// calcs are certainly not optimal, although they're stable
// (handles any dy being 0)
denom = ((x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1));
if (!denom) // Skip poly if it's an infinitely thin line
return;
denom = 1 / denom; // Reciprocal for speeding up
dizdx = ((iz3 - iz1) * (y2 - y1) - (iz2 - iz1) * (y3 - y1)) * denom;
duizdx = ((uiz3 - uiz1) * (y2 - y1) - (uiz2 - uiz1) * (y3 - y1)) * denom;
dvizdx = ((viz3 - viz1) * (y2 - y1) - (viz2 - viz1) * (y3 - y1)) * denom;
dizdy = ((iz2 - iz1) * (x3 - x1) - (iz3 - iz1) * (x2 - x1)) * denom;
duizdy = ((uiz2 - uiz1) * (x3 - x1) - (uiz3 - uiz1) * (x2 - x1)) * denom;
dvizdy = ((viz2 - viz1) * (x3 - x1) - (viz3 - viz1) * (x2 - x1)) * denom;
// Calculate X-slopes along the edges
if (y2 > y1)
dxdy1 = (x2 - x1) / (y2 - y1);
if (y3 > y1)
dxdy2 = (x3 - x1) / (y3 - y1);
if (y3 > y2)
dxdy3 = (x3 - x2) / (y3 - y2);
// Determine which side of the poly the longer edge is on
side = dxdy2 > dxdy1;
if (y1 == y2)
side = x1 > x2;
if (y2 == y3)
side = x3 > x2;
if (!side) // Longer edge is on the left side
{
// Calculate slopes along left edge
dxdya = dxdy2;
dizdya = dxdy2 * dizdx + dizdy;
duizdya = dxdy2 * duizdx + duizdy;
dvizdya = dxdy2 * dvizdx + dvizdy;
// Perform subpixel pre-stepping along left edge
dy = 1 - (y1 - y1i);
xa = x1 + dy * dxdya;
iza = iz1 + dy * dizdya;
uiza = uiz1 + dy * duizdya;
viza = viz1 + dy * dvizdya;
if (y1i < y2i) // Draw upper segment if possibly visible
{
// Set right edge X-slope and perform subpixel pre-
// stepping
xb = x1 + dy * dxdy1;
dxdyb = dxdy1;
drawtpolyperspsubtriseg(y1i, y2i);
}
if (y2i < y3i) // Draw lower segment if possibly visible
{
// Set right edge X-slope and perform subpixel pre-
// stepping
xb = x2 + (1 - (y2 - y2i)) * dxdy3;
dxdyb = dxdy3;
drawtpolyperspsubtriseg(y2i, y3i);
}
}
else // Longer edge is on the right side
{
// Set right edge X-slope and perform subpixel pre-stepping
dxdyb = dxdy2;
dy = 1 - (y1 - y1i);
xb = x1 + dy * dxdyb;
if (y1i < y2i) // Draw upper segment if possibly visible
{
// Set slopes along left edge and perform subpixel
// pre-stepping
dxdya = dxdy1;
dizdya = dxdy1 * dizdx + dizdy;
duizdya = dxdy1 * duizdx + duizdy;
dvizdya = dxdy1 * dvizdx + dvizdy;
xa = x1 + dy * dxdya;
iza = iz1 + dy * dizdya;
uiza = uiz1 + dy * duizdya;
viza = viz1 + dy * dvizdya;
drawtpolyperspsubtriseg(y1i, y2i);
}
if (y2i < y3i) // Draw lower segment if possibly visible
{
// Set slopes along left edge and perform subpixel
// pre-stepping
dxdya = dxdy3;
dizdya = dxdy3 * dizdx + dizdy;
duizdya = dxdy3 * duizdx + duizdy;
dvizdya = dxdy3 * dvizdx + dvizdy;
dy = 1 - (y2 - y2i);
xa = x2 + dy * dxdya;
iza = iz2 + dy * dizdya;
uiza = uiz2 + dy * duizdya;
viza = viz2 + dy * dvizdya;
drawtpolyperspsubtriseg(y2i, y3i);
}
}
}
int main(int argc,char **argv)
{
char reserved[100]; /* buffer to skip reserved bytes */
short f_type; /* MCS file type */
char trigger; /* Trigger Flag */
char dwell_flag; /* External Dwell Flag */
char dwell_units; /* 0=us, 1=ms, 2=sec, 3=ns */
char acq_mode; /* Acquisition mode flag 0=replace, 1=sum */
unsigned long dwell_913; /* Dwell time in old 913 format */
unsigned short pass_length; /* pass length in channels */
unsigned long pass_count;
unsigned long pass_count_preset;
char acq_time[9]; /* buffer for acquisition time */
char acq_date[9]; /* buffer for acquisition date */
unsigned short mark_chan; /* first marker channel */
char mcs_num; /* 1-8 are valid */
char cal_flag; /* 0=no calibration */
char cal_units[4]; /* calibration units */
float cal_zero; /* calibration zero intercept */
float cal_slope; /* calibration slope */
char id_byte; /* always 0xaa */
char detector_len; /* Detector description length */
char detector[65]; /* detector description */
char sample_len; /* Sample description length */
char sample[65]; /* Sample description */
char disc_sel; /* 0=SCA otherwise Disc */
char disc_edge; /* 0=falling else rising */
float disc; /* disc setting in volts */
float sca_uld; /* sca upper-level in volts */
float sca_lld; /* sca lower-level in volts */
float dwell; /* dwell time in dwell_units */
char consistent; /* settings consistent flag */
char mcs_id[9]; /* MCS ID string "0914-001" */
FILE *fpi;
char *input, *output;
SDDS_DATASET SDDS_dataset;
SCANNED_ARG *scanned;
long i, i_arg;
char ts1[256], ts2[256], ts3[256], ts4[256];
unsigned long *ucount;
long *count, *channel;
long ascii;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&scanned, argc, argv);
if (argc<3)
bomb(NULL, USAGE);
input = output = NULL;
ascii = 0;
for (i_arg=1; i_arg<argc; i_arg++) {
if (scanned[i_arg].arg_type==OPTION) {
switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) {
case SET_ASCII:
ascii = 1;
break;
default:
bomb("invalid option seen", USAGE);
break;
}
}
else {
if (!input)
input = scanned[i_arg].list[0];
else if (!output)
output = scanned[i_arg].list[0];
else
bomb("too many filenames", USAGE);
}
}
if (!input)
SDDS_Bomb("input file not seen");
if (!output)
SDDS_Bomb("output file not seen");
fpi = fopen_e(input, "r", 0);
/***************************************************************************/
/* Header Data */
/* Read header info from MCS file */
/***************************************************************************/
/* Read filetype -4 (MCS) */
fread(&f_type,sizeof(short),1,fpi);
swapshort(&f_type);
if (f_type != MCS) {
fprintf(stderr, "Not a valid file: f_type = %hx\n", f_type);
exit(1);
}
fread(&trigger,sizeof(char),1,fpi); /* Read Trigger Flag */
fread(&dwell_flag,sizeof(char),1,fpi); /* Read dwell flag */
fread(&dwell_units,sizeof(char),1,fpi);/* Read dwell units */
fread(&acq_mode,sizeof(char),1,fpi);
fread(&dwell_913,sizeof(long),1,fpi);
swapulong(&dwell_913);
fread(&pass_length,sizeof(short),1,fpi);
swapushort(&pass_length);
fread(&pass_count,sizeof(long),1,fpi);
swapulong(&pass_count);
fread(&pass_count_preset,sizeof(long),1,fpi);
swapulong(&pass_count_preset);
fread(acq_time,sizeof(char),8,fpi);
fread(acq_date,sizeof(char),8,fpi);
fread(&mark_chan,sizeof(short),1,fpi);
swapushort(&mark_chan);
fread(&mcs_num,sizeof(char),1,fpi);
fread(&cal_flag,sizeof(char),1,fpi);
fread(cal_units,sizeof(char),4,fpi);
fread(&cal_zero,sizeof(float),1,fpi);
swapfloat(&cal_zero);
fread(&cal_slope,sizeof(float),1,fpi);
swapfloat(&cal_slope);
fread(reserved,sizeof(char),10,fpi);
fread(&id_byte,sizeof(char),1,fpi);
fread(reserved,sizeof(char),1,fpi);
fread(&detector_len,sizeof(char),1,fpi);
fread(detector,sizeof(char),63,fpi);
fread(&sample_len,sizeof(char),1,fpi);
fread(sample,sizeof(char),63,fpi);
fread(reserved,sizeof(char),16,fpi); /* skip view info & reserved */
fread(&disc_sel,sizeof(char),1,fpi);
fread(&disc_edge,sizeof(char),1,fpi);
fread(&disc,sizeof(float),1,fpi);
swapfloat(&disc);
fread(&sca_uld,sizeof(float),1,fpi);
swapfloat(&sca_uld);
fread(&sca_lld,sizeof(float),1,fpi);
swapfloat(&sca_lld);
fread(&dwell,sizeof(float),1,fpi);
swapfloat(&dwell);
fread(&consistent,sizeof(char),1,fpi);
fread(reserved,sizeof(char),21,fpi);
fread(mcs_id,sizeof(char),8,fpi);
mcs_id[8]=0;
sprintf(ts1, "%hd", mcs_num+1);
sprintf(ts2, "%hd", pass_length);
sprintf(ts3, "%ld", pass_count);
sprintf(ts4, "%ld", pass_count_preset);
if (!SDDS_InitializeOutput(&SDDS_dataset, ascii?SDDS_ASCII:SDDS_BINARY, 1, "Turbo MCS data", "Turbo MCS data", output) ||
SDDS_DefineParameter(&SDDS_dataset, "MCSNumber", NULL, NULL, "MCS number", NULL, SDDS_SHORT,
ts1)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "MCSID", NULL, NULL, "MCS ID", NULL, SDDS_STRING, mcs_id)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "PassLength", NULL, NULL, "Pass length", NULL, SDDS_SHORT,
ts2)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "PassCount", NULL, NULL, "Pass count", NULL, SDDS_LONG,
ts3)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "PassCountPreset", NULL, NULL, "Pass count preset", NULL, SDDS_LONG,
ts4)<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
if (dwell_flag == 0) {
if (dwell_units==0)
dwell *= 1e-6;
else if (dwell_units==1)
dwell *= 1e-3;
else if (dwell_units==3)
dwell *= 1e-9;
}
else
dwell = -1;
sprintf(ts1, "%15.8e", dwell);
sprintf(ts2, "%8s %8s", acq_time,acq_date);
if (SDDS_DefineParameter(&SDDS_dataset, "DwellTime", NULL, "s", "Dwell time", NULL, SDDS_DOUBLE,
ts1)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "TriggerMode", NULL, NULL, "Trigger mode", NULL, SDDS_STRING,
trigger?"external":"internal")<0 ||
SDDS_DefineParameter(&SDDS_dataset, "AcquisitionMode", NULL, NULL, "Acquisition mode", NULL, SDDS_STRING,
acq_mode?"sum":"replace")<0 ||
SDDS_DefineParameter(&SDDS_dataset, "TimeStamp", NULL, NULL, "Time at which data collection started", NULL, SDDS_STRING,
ts2)<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
sprintf(ts1, "%15.8e", cal_slope);
sprintf(ts2, "%15.8e", cal_zero);
if (cal_flag &&
(SDDS_DefineParameter(&SDDS_dataset, "CalibrationSlope", NULL, cal_units, "Spectrum calibration slope", NULL, SDDS_DOUBLE, ts1)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "CalibrationOffset", NULL, cal_units, "Spectrum calibration slope", NULL, SDDS_DOUBLE, ts2)<0))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
if (detector_len) {
detector[(unsigned)detector_len] = 0;
if (SDDS_DefineParameter(&SDDS_dataset, "HardwareDescription", NULL, NULL,
NULL, NULL, SDDS_DOUBLE, detector)<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
}
if (sample_len) {
sample[(unsigned)sample_len] = 0;
if (SDDS_DefineParameter(&SDDS_dataset, "DataDescription", NULL, NULL,
NULL, NULL, SDDS_STRING, sample)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "mplTitle", NULL, NULL,
NULL, NULL, SDDS_STRING, sample)<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
}
if (disc_sel == 0) {
sprintf(ts1, "%15.8e", sca_lld);
sprintf(ts2, "%15.8e", sca_uld);
if (SDDS_DefineParameter(&SDDS_dataset, "SCA-LLD", NULL, "V", "SCA Lower-Level Discriminator Setting",
NULL, SDDS_DOUBLE, ts1)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "SCA-ULD", NULL, "V", "SCA Upper-Level Discriminator Setting",
NULL, SDDS_DOUBLE, ts2)<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
}
else {
sprintf(ts1, "%15.8e", disc);
if (SDDS_DefineParameter(&SDDS_dataset, "DiscrimLevel", NULL, "V", "Discriminator Level",
NULL, SDDS_DOUBLE, ts1)<0 ||
SDDS_DefineParameter(&SDDS_dataset, "DiscrimSlope", NULL, NULL, "Discriminator Slope",
NULL, SDDS_LONG, disc_edge?"+1":"-1")<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
}
if (consistent==0) {
if (SDDS_DefineParameter(&SDDS_dataset, "Inconsistent", NULL, NULL,
"Flag indicating whether data and settings are inconsistent",
NULL, SDDS_LONG, "1")<0)
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
fprintf(stderr, "WARNING: Settings are not consistent with data\n");
}
if (SDDS_DefineColumn(&SDDS_dataset, "ChannelNumber", NULL, NULL, "Channel number", NULL, SDDS_LONG, 0)<0 ||
SDDS_DefineColumn(&SDDS_dataset, "EventCount", NULL, NULL, "Number of events", NULL, SDDS_LONG, 0)<0 ||
!SDDS_WriteLayout(&SDDS_dataset) || !SDDS_StartPage(&SDDS_dataset, (long)pass_length))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
/***************************************************************************/
/* Channel Data */
/* Output channel data from MCS file */
/***************************************************************************/
channel = tmalloc(sizeof(*channel)*pass_length);
count = tmalloc(sizeof(*count)*pass_length);
ucount = tmalloc(sizeof(*ucount)*pass_length);
if (fread(ucount, sizeof(*ucount), pass_length, fpi)!=pass_length)
SDDS_Bomb("unable to read channel data");
for (i=0; i<(long)pass_length; i++) {
swapulong(ucount+i);
count[i] = (long)ucount[i];
channel[i] = i;
}
if (!SDDS_SetColumn(&SDDS_dataset, SDDS_SET_BY_NAME, channel, (long)pass_length, "ChannelNumber") ||
!SDDS_SetColumn(&SDDS_dataset, SDDS_SET_BY_NAME, count, (long)pass_length, "EventCount") ||
!SDDS_WritePage(&SDDS_dataset) || !SDDS_Terminate(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
fclose(fpi);
return(0);
}
