RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

elim name conflicts

This commit is contained in:
cxgeorge 2001-06-06 23:18:58 +00:00
parent 85638d9636
commit 501b323ead
13 changed files with 139 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
panda/src/pnm/ppmcmap.h
View File

@ -3,6 +3,9 @@
/* Color histogram stuff. */
#ifndef PPMCMAP_H
#define PPMCMAP_H
typedef struct colorhist_item* colorhist_vector;
struct colorhist_item
{
@ -43,3 +46,5 @@ int ppm_addtocolorhash ARGS(( colorhash_table cht, pixel* colorP, int value ));
colorhash_table ppm_alloccolorhash ARGS(( void ));
void ppm_freecolorhash( colorhash_table cht );
#endif

32
panda/src/pnmimagetypes/pnmFileTypeAlias.cxx
View File

@ -27,10 +27,10 @@
// or height is larger than this, it must be bogus.
#define INSANE_SIZE 20000
static const char * const extensions[] = {
static const char * const extensions_ALIAS[] = {
"pix", "als"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_ALIAS = sizeof(extensions_ALIAS) / sizeof(const char *);
TypeHandle PNMFileTypeAlias::_type_handle;
@ -57,11 +57,11 @@ get_name() const {
// Function: PNMFileTypeAlias::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_ALIAS associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeAlias::
get_num_extensions() const {
return num_extensions;
return num_extensions_ALIAS;
}
////////////////////////////////////////////////////////////////////
@ -73,8 +73,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeAlias::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_ALIAS, string());
return extensions_ALIAS[n];
}
////////////////////////////////////////////////////////////////////
@ -124,7 +124,7 @@ read_ushort(FILE *file) {
}
inline unsigned char
read_uchar(FILE *file) {
read_uchar_ALIAS(FILE *file) {
int x;
x = getc(file);
return (x!=EOF) ? (unsigned char)x : 0;
@ -136,7 +136,7 @@ write_ushort(FILE *file, unsigned short x) {
}
inline void
write_uchar(FILE *file, unsigned char x) {
write_uchar_ALIAS(FILE *file, unsigned char x) {
putc(x, file);
}
@ -240,15 +240,15 @@ read_row(xel *row_data, xelval *) {
x = 0;
while (x < _x_size) {
num = read_uchar(_file);
num = read_uchar_ALIAS(_file);
if (num==0 || x+num > _x_size) {
return false;
}
blu = read_uchar(_file);
blu = read_uchar_ALIAS(_file);
if (get_color_type() == PNMImageHeader::CT_color) {
grn = read_uchar(_file);
red = read_uchar(_file);
grn = read_uchar_ALIAS(_file);
red = read_uchar_ALIAS(_file);
while (num>0) {
PPM_ASSIGN(row_data[x], red, grn, blu);
x++;
@ -272,10 +272,10 @@ static int num_count = 0;
static void
flush_color(FILE *file) {
if (num_count>0) {
write_uchar(file, num_count);
write_uchar(file, last_blu);
write_uchar(file, last_grn);
write_uchar(file, last_red);
write_uchar_ALIAS(file, num_count);
write_uchar_ALIAS(file, last_blu);
write_uchar_ALIAS(file, last_grn);
write_uchar_ALIAS(file, last_red);
num_count = 0;
}
}

12
panda/src/pnmimagetypes/pnmFileTypeBMP.cxx
View File

@ -22,10 +22,10 @@
#include <pnmFileTypeRegistry.h>
#include <bamReader.h>
static const char * const extensions[] = {
static const char * const extensions_BMP[] = {
"bmp"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_BMP = sizeof(extensions_BMP) / sizeof(const char *);
TypeHandle PNMFileTypeBMP::_type_handle;
@ -52,11 +52,11 @@ get_name() const {
// Function: PNMFileTypeBMP::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_BMP associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeBMP::
get_num_extensions() const {
return num_extensions;
return num_extensions_BMP;
}
////////////////////////////////////////////////////////////////////
@ -68,8 +68,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeBMP::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_BMP, string());
return extensions_BMP[n];
}
////////////////////////////////////////////////////////////////////

34
panda/src/pnmimagetypes/pnmFileTypeIMG.cxx
View File

@ -27,10 +27,10 @@
// larger than this, it must be bogus.
#define INSANE_SIZE 20000
static const char * const extensions[] = {
static const char * const extensionsIMG[] = {
"img"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_IMG = sizeof(extensionsIMG) / sizeof(const char *);
TypeHandle PNMFileTypeIMG::_type_handle;
@ -61,7 +61,7 @@ get_name() const {
////////////////////////////////////////////////////////////////////
int PNMFileTypeIMG::
get_num_extensions() const {
return num_extensions;
return num_extensions_IMG;
}
////////////////////////////////////////////////////////////////////
@ -73,8 +73,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeIMG::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_IMG, string());
return extensionsIMG[n];
}
////////////////////////////////////////////////////////////////////
@ -123,13 +123,13 @@ read_ulong(FILE *file) {
}
inline unsigned short
read_ushort(FILE *file) {
read_ushort_IMG(FILE *file) {
unsigned short x;
return pm_readbigshort(file, (short *)&x)==0 ? x : 0;
}
inline unsigned char
read_uchar(FILE *file) {
read_uchar_IMG(FILE *file) {
int x;
x = getc(file);
return (x!=EOF) ? (unsigned char)x : 0;
@ -141,12 +141,12 @@ write_ulong(FILE *file, unsigned long x) {
}
inline void
write_ushort(FILE *file, unsigned long x) {
write_ushort_IMG(FILE *file, unsigned long x) {
pm_writebigshort(file, (short)(long)x);
}
inline void
write_uchar(FILE *file, unsigned char x) {
write_uchar_IMG(FILE *file, unsigned char x) {
putc(x, file);
}
@ -258,9 +258,9 @@ read_row(xel *row_data, xelval *) {
int x;
xelval red, grn, blu;
for (x = 0; x < _x_size; x++) {
red = read_uchar(_file);
grn = read_uchar(_file);
blu = read_uchar(_file);
red = read_uchar_IMG(_file);
grn = read_uchar_IMG(_file);
blu = read_uchar_IMG(_file);
PPM_ASSIGN(row_data[x], red, grn, blu);
}
@ -314,8 +314,8 @@ write_header() {
write_ulong(_file, _x_size);
write_ulong(_file, _y_size);
} else if (img_header_type == IHT_short) {
write_ushort(_file, _x_size);
write_ushort(_file, _y_size);
write_ushort_IMG(_file, _x_size);
write_ushort_IMG(_file, _y_size);
}
return true;
}
@ -339,9 +339,9 @@ bool PNMFileTypeIMG::Writer::
write_row(xel *row_data, xelval *) {
int x;
for (x = 0; x < _x_size; x++) {
write_uchar(_file, (unsigned char)(255*PPM_GETR(row_data[x])/_maxval));
write_uchar(_file, (unsigned char)(255*PPM_GETG(row_data[x])/_maxval));
write_uchar(_file, (unsigned char)(255*PPM_GETB(row_data[x])/_maxval));
write_uchar_IMG(_file, (unsigned char)(255*PPM_GETR(row_data[x])/_maxval));
write_uchar_IMG(_file, (unsigned char)(255*PPM_GETG(row_data[x])/_maxval));
write_uchar_IMG(_file, (unsigned char)(255*PPM_GETB(row_data[x])/_maxval));
}
return true;

12
panda/src/pnmimagetypes/pnmFileTypeJPG.cxx
View File

@ -22,10 +22,10 @@
#include <pnmFileTypeRegistry.h>
#include <bamReader.h>
static const char * const extensions[] = {
static const char * const extensions_JPG[] = {
"jpg", "jpeg"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_JPG = sizeof(extensions_JPG) / sizeof(const char *);
TypeHandle PNMFileTypeJPG::_type_handle;
@ -52,11 +52,11 @@ get_name() const {
// Function: PNMFileTypeJPG::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_JPG associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeJPG::
get_num_extensions() const {
return num_extensions;
return num_extensions_JPG;
}
////////////////////////////////////////////////////////////////////
@ -68,8 +68,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeJPG::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_JPG, string());
return extensions_JPG[n];
}
////////////////////////////////////////////////////////////////////

12
panda/src/pnmimagetypes/pnmFileTypePNM.cxx
View File

@ -32,10 +32,10 @@ extern "C" {
#include "../pnm/libpbm.h"
}
static const char * const extensions[] = {
static const char * const extensions_PNM[] = {
"pbm", "ppm", "pnm"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_PNM = sizeof(extensions_PNM) / sizeof(const char *);
TypeHandle PNMFileTypePNM::_type_handle;
@ -62,11 +62,11 @@ get_name() const {
// Function: PNMFileTypePNM::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_PNM associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypePNM::
get_num_extensions() const {
return num_extensions;
return num_extensions_PNM;
}
////////////////////////////////////////////////////////////////////
@ -78,8 +78,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypePNM::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_PNM, string());
return extensions_PNM[n];
}
////////////////////////////////////////////////////////////////////

12
panda/src/pnmimagetypes/pnmFileTypeRadiance.cxx
View File

@ -39,10 +39,10 @@ extern "C" {
void gambs_colrs(COLR *, int);
}
static const char * const extensions[] = {
static const char * const extensions_RAD[] = {
"pic", "rad"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_RAD = sizeof(extensions_RAD) / sizeof(const char *);
TypeHandle PNMFileTypeRadiance::_type_handle;
@ -72,11 +72,11 @@ get_name() const {
// Function: PNMFileTypeRadiance::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_RAD associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeRadiance::
get_num_extensions() const {
return num_extensions;
return num_extensions_RAD;
}
////////////////////////////////////////////////////////////////////
@ -88,8 +88,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeRadiance::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_RAD, string());
return extensions_RAD[n];
}
////////////////////////////////////////////////////////////////////

12
panda/src/pnmimagetypes/pnmFileTypeSGI.cxx
View File

@ -23,10 +23,10 @@
#include <pnmFileTypeRegistry.h>
#include <bamReader.h>
static const char * const extensions[] = {
static const char * const extensions_SGI[] = {
"rgb", "rgba", "sgi"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_SGI = sizeof(extensions_SGI) / sizeof(const char *);
TypeHandle PNMFileTypeSGI::_type_handle;
@ -53,11 +53,11 @@ get_name() const {
// Function: PNMFileTypeSGI::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_SGI associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeSGI::
get_num_extensions() const {
return num_extensions;
return num_extensions_SGI;
}
////////////////////////////////////////////////////////////////////
@ -69,8 +69,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeSGI::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_SGI, string());
return extensions_SGI[n];
}
////////////////////////////////////////////////////////////////////

98
panda/src/pnmimagetypes/pnmFileTypeSoftImage.cxx
View File

@ -39,10 +39,10 @@ static const char imageComment[imageCommentLength+1] =
#define SOFTIMAGE_MAGIC1 0x5380
#define SOFTIMAGE_MAGIC2 0xf634
static const char * const extensions[] = {
static const char * const extensions_SI[] = {
"pic", "soft"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_SI = sizeof(extensions_SI) / sizeof(const char *);
TypeHandle PNMFileTypeSoftImage::_type_handle;
@ -58,25 +58,25 @@ read_float(FILE *file) {
}
inline unsigned short
read_ushort(FILE *file) {
read_ushort_SI(FILE *file) {
unsigned short x;
return pm_readbigshort(file, (short *)&x)==0 ? x : 0;
}
inline unsigned char
read_uchar(FILE *file) {
read_uchar_SI(FILE *file) {
int x;
x = getc(file);
return (x!=EOF) ? (unsigned char)x : 0;
}
inline void
write_ushort(FILE *file, unsigned short x) {
write_ushort_SI(FILE *file, unsigned short x) {
pm_writebigshort(file, (short)x);
}
inline void
write_uchar(FILE *file, unsigned char x) {
write_uchar_SI(FILE *file, unsigned char x) {
putc(x, file);
}
@ -88,10 +88,10 @@ write_float(FILE *file, float x) {
static int
read_channel_pkt(FILE *file,
int &chained, int &size, int &type, int &channel) {
chained = read_uchar(file);
size = read_uchar(file);
type = read_uchar(file);
channel = read_uchar(file);
chained = read_uchar_SI(file);
size = read_uchar_SI(file);
type = read_uchar_SI(file);
channel = read_uchar_SI(file);
if (feof(file)) {
return false;
@ -109,9 +109,9 @@ read_channel_pkt(FILE *file,
static void
read_rgb(xel *row_data, xelval *, FILE *file, int x, int repeat) {
xelval red, grn, blu;
red = read_uchar(file);
grn = read_uchar(file);
blu = read_uchar(file);
red = read_uchar_SI(file);
grn = read_uchar_SI(file);
blu = read_uchar_SI(file);
while (repeat>0) {
PPM_ASSIGN(row_data[x], red, grn, blu);
@ -122,7 +122,7 @@ read_rgb(xel *row_data, xelval *, FILE *file, int x, int repeat) {
static void
read_alpha(xel *, xelval *alpha_data, FILE *file, int x, int repeat) {
xelval alpha = read_uchar(file);
xelval alpha = read_uchar_SI(file);
while (repeat>0) {
alpha_data[x] = alpha;
@ -134,10 +134,10 @@ read_alpha(xel *, xelval *alpha_data, FILE *file, int x, int repeat) {
static void
read_rgba(xel *row_data, xelval *alpha_data, FILE *file, int x, int repeat) {
xelval red, grn, blu, alpha;
red = read_uchar(file);
grn = read_uchar(file);
blu = read_uchar(file);
alpha = read_uchar(file);
red = read_uchar_SI(file);
grn = read_uchar_SI(file);
blu = read_uchar_SI(file);
alpha = read_uchar_SI(file);
while (repeat>0) {
PPM_ASSIGN(row_data[x], red, grn, blu);
@ -164,7 +164,7 @@ read_scanline(xel *row_data, xelval *alpha_data, int cols, FILE *file,
x = 0;
while (x < cols) {
num = read_uchar(file);
num = read_uchar_SI(file);
if (num<128) {
// Sequence of non-repeated values.
@ -183,7 +183,7 @@ read_scanline(xel *row_data, xelval *alpha_data, int cols, FILE *file,
} else {
// Sequence of repeated values.
if (num==128) {
num = read_ushort(file);
num = read_ushort_SI(file);
} else {
num -= 127;
}
@ -225,11 +225,11 @@ get_name() const {
// Function: PNMFileTypeSoftImage::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_SI associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeSoftImage::
get_num_extensions() const {
return num_extensions;
return num_extensions_SI;
}
////////////////////////////////////////////////////////////////////
@ -241,8 +241,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeSoftImage::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_SI, string());
return extensions_SI[n];
}
////////////////////////////////////////////////////////////////////
@ -359,12 +359,12 @@ Reader(PNMFileType *type, FILE *file, bool owns_file, string magic_number) :
return;
}
_x_size = read_ushort(_file);
_y_size = read_ushort(_file);
_x_size = read_ushort_SI(_file);
_y_size = read_ushort_SI(_file);
/* float ratio = */ read_float(_file);
/* int fields = */ read_ushort(_file);
read_ushort(_file);
/* int fields = */ read_ushort_SI(_file);
read_ushort_SI(_file);
int chained, size, channel;
if (!read_channel_pkt(_file, chained, size, rgb_ctype, channel)) {
@ -494,17 +494,17 @@ read_row(xel *row_data, xelval *alpha_data) {
static void
write_channel_pkt(FILE *file,
int chained, int size, int type, int channel) {
write_uchar(file, chained);
write_uchar(file, size);
write_uchar(file, type);
write_uchar(file, channel);
write_uchar_SI(file, chained);
write_uchar_SI(file, size);
write_uchar_SI(file, type);
write_uchar_SI(file, channel);
}
static void
write_rgb(xel *row_data, xelval *, FILE *file, int x) {
write_uchar(file, PPM_GETR(row_data[x]));
write_uchar(file, PPM_GETG(row_data[x]));
write_uchar(file, PPM_GETB(row_data[x]));
write_uchar_SI(file, PPM_GETR(row_data[x]));
write_uchar_SI(file, PPM_GETG(row_data[x]));
write_uchar_SI(file, PPM_GETB(row_data[x]));
}
static int
@ -514,9 +514,9 @@ compare_rgb(xel *row_data, xelval *, int x1, int x2) {
static void
write_gray(xel *row_data, xelval *, FILE *file, int x) {
write_uchar(file, PPM_GETB(row_data[x]));
write_uchar(file, PPM_GETB(row_data[x]));
write_uchar(file, PPM_GETB(row_data[x]));
write_uchar_SI(file, PPM_GETB(row_data[x]));
write_uchar_SI(file, PPM_GETB(row_data[x]));
write_uchar_SI(file, PPM_GETB(row_data[x]));
}
static int
@ -526,7 +526,7 @@ compare_gray(xel *row_data, xelval *, int x1, int x2) {
static void
write_alpha(xel *, xelval *alpha_data, FILE *file, int x) {
write_uchar(file, alpha_data[x]);
write_uchar_SI(file, alpha_data[x]);
}
static int
@ -542,7 +542,7 @@ write_diff(xel *row_data, xelval *alpha_data, FILE *file,
if (length>0) {
nassertv(length<=128);
write_uchar(file, length-1);
write_uchar_SI(file, length-1);
while (length>0) {
length--;
write_data(row_data, alpha_data, file, tox-length);
@ -560,10 +560,10 @@ write_same(xel *row_data, xelval *alpha_data, FILE *file,
} else if (length>0) {
if (length<128) {
write_uchar(file, length+127);
write_uchar_SI(file, length+127);
} else {
write_uchar(file, 128);
write_ushort(file, length);
write_uchar_SI(file, 128);
write_ushort_SI(file, length);
}
write_data(row_data, alpha_data, file, tox);
}
@ -702,19 +702,19 @@ supports_write_row() const {
////////////////////////////////////////////////////////////////////
bool PNMFileTypeSoftImage::Writer::
write_header() {
write_ushort(_file, SOFTIMAGE_MAGIC1);
write_ushort(_file, SOFTIMAGE_MAGIC2);
write_ushort_SI(_file, SOFTIMAGE_MAGIC1);
write_ushort_SI(_file, SOFTIMAGE_MAGIC2);
write_float(_file, imageVersionNumber);
fwrite(imageComment, 1, imageCommentLength, _file);
fwrite("PICT", 1, 4, _file);
write_ushort(_file, _x_size);
write_ushort(_file, _y_size);
write_ushort_SI(_file, _x_size);
write_ushort_SI(_file, _y_size);
write_float(_file, 1.0); // pixel aspect ratio; we don't know.
write_ushort(_file, 3); // fields value; we don't really know either.
write_ushort(_file, 0); // padding
write_ushort_SI(_file, 3); // fields value; we don't really know either.
write_ushort_SI(_file, 0); // padding
// There doesn't seem to be a variation on SoftImage image formats for
// grayscale images. We'll write out grayscale as a 3-channel image.

12
panda/src/pnmimagetypes/pnmFileTypeTGA.cxx
View File

@ -55,10 +55,10 @@
#include <ppm.h>
#include <string.h>
static const char * const extensions[] = {
static const char * const extensions_TGA[] = {
"tga"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_TGA = sizeof(extensions_TGA) / sizeof(const char *);
TypeHandle PNMFileTypeTGA::_type_handle;
@ -123,11 +123,11 @@ get_name() const {
// Function: PNMFileTypeTGA::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_TGA associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeTGA::
get_num_extensions() const {
return num_extensions;
return num_extensions_TGA;
}
////////////////////////////////////////////////////////////////////
@ -139,8 +139,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeTGA::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_TGA, string());
return extensions_TGA[n];
}
////////////////////////////////////////////////////////////////////

12
panda/src/pnmimagetypes/pnmFileTypeTIFF.cxx
View File

@ -32,10 +32,10 @@ extern "C" {
#include "../tiff/tiffio.h"
}
static const char * const extensions[] = {
static const char * const extensions_TIFF[] = {
"tiff", "tif"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_TIFF = sizeof(extensions_TIFF) / sizeof(const char *);
// These are configurable parameters to specify TIFF details on output.
// See tools/drr/../pnm/libtiff/tiff.h or type man pnmtotiff for a better
@ -151,11 +151,11 @@ get_name() const {
// Function: PNMFileTypeTIFF::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_TIFF associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeTIFF::
get_num_extensions() const {
return num_extensions;
return num_extensions_TIFF;
}
////////////////////////////////////////////////////////////////////
@ -167,8 +167,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeTIFF::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_TIFF, string());
return extensions_TIFF[n];
}
////////////////////////////////////////////////////////////////////

12
panda/src/pnmimagetypes/pnmFileTypeYUV.cxx
View File

@ -70,10 +70,10 @@
/* x must be signed for the following to work correctly */
#define limit(x) (xelval)(((x>0xffffff)?0xff0000:((x<=0xffff)?0:x&0xff0000))>>16)
static const char * const extensions[] = {
static const char * const extensions_YUV[] = {
"yuv"
};
static const int num_extensions = sizeof(extensions) / sizeof(const char *);
static const int num_extensions_YUV = sizeof(extensions_YUV) / sizeof(const char *);
TypeHandle PNMFileTypeYUV::_type_handle;
@ -100,11 +100,11 @@ get_name() const {
// Function: PNMFileTypeYUV::get_num_extensions
// Access: Public, Virtual
// Description: Returns the number of different possible filename
// extensions associated with this particular file type.
// extensions_YUV associated with this particular file type.
////////////////////////////////////////////////////////////////////
int PNMFileTypeYUV::
get_num_extensions() const {
return num_extensions;
return num_extensions_YUV;
}
////////////////////////////////////////////////////////////////////
@ -116,8 +116,8 @@ get_num_extensions() const {
////////////////////////////////////////////////////////////////////
string PNMFileTypeYUV::
get_extension(int n) const {
nassertr(n >= 0 && n < num_extensions, string());
return extensions[n];
nassertr(n >= 0 && n < num_extensions_YUV, string());
return extensions_YUV[n];
}
////////////////////////////////////////////////////////////////////

5
panda/src/pnmimagetypes/sgi.h
View File

@ -16,6 +16,9 @@
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef SGI_IMAGE_H
#define SGI_IMAGE_H
typedef struct {
short magic;
char storage;
@ -42,4 +45,4 @@ typedef struct {
#define CMAP_SCREEN 2 /* not supported */
#define CMAP_COLORMAP 3 /* not supported */
#endif