This is TexturePalette.m in view mode; [Download] [Up]
#import "qedefs.h"
id texturepalette_i;
#define TYP_MIPTEX 67
int tex_count;
qtexture_t qtextures[MAX_TEXTURES];
typedef struct
{
char name[16];
unsigned width, height;
unsigned offsets[4]; // four mip maps stored
} miptex_t;
unsigned tex_palette[256];
unsigned badtex_d[] =
{
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
0,0,0,0,0,0,0,0,
0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff
};
qtexture_t badtex = {"notexture",16,16,NULL, badtex_d, {0,0,255,255}};
/*
==============
TEX_InitPalette
==============
*/
void TEX_InitPalette (byte *pal)
{
int r,g,b,v;
int i;
for (i=0 ; i<256 ; i++)
{
r = pal[0];
g = pal[1];
b = pal[2];
pal += 3;
v = (r<<24) + (g<<16) + (b<<8) + 255;
v = BigLong (v);
tex_palette[i] = v;
}
}
/*
=================
TEX_ImageFromMiptex
=================
*/
void TEX_ImageFromMiptex (miptex_t *qtex)
{
NXBitmapImageRep *bm;
byte *source;
unsigned *dest;
int width, height, i, count;
qtexture_t *q;
int tr, tg, tb;
width = LittleLong(qtex->width);
height = LittleLong(qtex->height);
bm = [[NXBitmapImageRep alloc]
initData: NULL
pixelsWide: width
pixelsHigh: height
bitsPerSample: 8
samplesPerPixel:3
hasAlpha: NO
isPlanar: NO
colorSpace: NX_RGBColorSpace
bytesPerRow: width*4
bitsPerPixel: 32];
dest = (unsigned *)[bm data];
count = width*height;
source = (byte *)qtex + LittleLong(qtex->offsets[0]);
q = &qtextures[tex_count];
tex_count++;
q->width = width;
q->height = height;
q->rep = bm;
q->data = dest;
tr = tg = tb = 0;
for (i=0 ; i<count ; i++)
{
dest[i] = tex_palette[source[i]];
tr += ((pixel32_t *)&dest[i])->chan[0];
tg += ((pixel32_t *)&dest[i])->chan[1];
tb += ((pixel32_t *)&dest[i])->chan[2];
}
q->flatcolor.chan[0] = tr / count;
q->flatcolor.chan[1] = tg / count;
q->flatcolor.chan[2] = tb / count;
q->flatcolor.chan[3] = 0xff;
}
//=============================================================================
typedef struct
{
char identification[4]; // should be WAD2 or 2DAW
int numlumps;
int infotableofs;
} wadinfo_t;
typedef struct
{
int filepos;
int disksize;
int size; // uncompressed
char type;
char compression;
char pad1, pad2;
char name[16]; // must be null terminated
} lumpinfo_t;
/*
=================
TEX_InitFromWad
=================
*/
void TEX_InitFromWad (char *path)
{
int i;
char local[1024];
char newpath[1024];
byte *wadfile;
wadinfo_t *wadinfo;
lumpinfo_t *lumpinfo;
int numlumps;
float start, stop;
start = I_FloatTime ();
strcpy(newpath, [preferences_i getProjectPath]);
strcat(newpath,"/");
strcat(newpath, path);
// free any textures
for (i=0 ; i<tex_count ; i++)
[qtextures[i].rep free];
tex_count = 0;
// try and use the cached wadfile
sprintf (local, "/qcache%s", newpath);
Sys_UpdateFile (local, newpath);
LoadFile (local, (void **)&wadfile);
wadinfo = (wadinfo_t *)wadfile;
if (strncmp (wadfile, "WAD2", 4))
{
unlink (local);
Error ("TEX_InitFromWad: %s isn't a wadfile", newpath);
}
numlumps = LittleLong (wadinfo->numlumps);
lumpinfo = (lumpinfo_t *)(wadfile + LittleLong (wadinfo->infotableofs));
if (strcmp (lumpinfo->name, "PALETTE"))
{
unlink (local);
Error ("TEX_InitFromWad: %s doesn't have palette as 0",path);
}
TEX_InitPalette (wadfile + LittleLong(lumpinfo->filepos));
lumpinfo++;
for (i=1 ; i<numlumps ; i++, lumpinfo++)
{
if (lumpinfo->type != TYP_MIPTEX)
Error ("TEX_InitFromWad: %s is not a miptex!",lumpinfo->name);
CleanupName (lumpinfo->name,qtextures[tex_count].name);
TEX_ImageFromMiptex ( (miptex_t *)(wadfile +
LittleLong(lumpinfo->filepos) ));
}
free (wadfile);
stop = I_FloatTime ();
qprintf ("loaded %s (%5.1f)", local, stop - start);
}
/*
=================
TEX_NumForName
=================
*/
qtexture_t *TEX_ForName (char *name)
{
char newname[16];
int i;
qtexture_t *q;
CleanupName (name, newname);
for (i=0,q = qtextures ; i< tex_count ; i++, q++)
{
if (!strcmp(name, q->name))
return q;
}
return &badtex;
}
//===========================================================================
@implementation TexturePalette
- init
{
[super init];
texturepalette_i = self;
selectedTexture = -1;
return self;
}
- display
{
[[textureView_i superview] display];
return self;
}
- (char *)currentWad
{
return currentwad;
}
- initPaletteFromWadfile:(char *)wf
{
int i;
texpal_t t;
qtexture_t *q;
strcpy (currentwad, wf);
[map_i makeGlobalPerform: @selector(flushTextures)];
selectedTexture = -1;
// Init textures WAD
TEX_InitFromWad(wf);
// Create STORAGE
if (textureList_i)
[textureList_i empty];
else
textureList_i = [[Storage alloc]
initCount:0
elementSize:sizeof(texpal_t)
description:NULL];
// Init STORAGE
for (i = 0,q=qtextures;i < tex_count; i++,q++)
{
t.image = q->rep;
t.r.size.width = [t.image pixelsWide];
if (t.r.size.width < 64)
t.r.size.width = 64;
t.r.size.height = [t.image pixelsHigh] + TEX_SPACING;
t.name = q->name;
t.index = i;
t.display = 1;
[textureList_i addElement:&t];
}
// Calculate size of TextureView
[self alphabetize];
[self computeTextureViewSize];
[textureView_i setParent:self];
[self setSelectedTexture:0];
return self;
}
// Return texture STORAGE list
- getList
{
return textureList_i;
}
// Alphabetize texture list - reverse order!
- alphabetize
{
int i;
int max;
texpal_t *t1p;
texpal_t *t2p;
texpal_t t1;
texpal_t t2;
int found;
max = [textureList_i count];
found = 1;
while(found)
{
found = 0;
for (i = 0;i < max-1;i++)
{
t1p = [textureList_i elementAt:i];
t2p = [textureList_i elementAt:i+1];
if (strcmp(t1p->name,t2p->name) < 0)
{
t1 = *t1p;
t2 = *t2p;
[textureList_i replaceElementAt:i with:&t2];
[textureList_i replaceElementAt:i+1 with:&t1];
found = 1;
}
}
}
return self;
}
- computeTextureViewSize
{
int i;
int max;
int x;
texpal_t *t;
int y;
id view;
NXRect b;
int maxwidth;
int maxheight;
NXPoint pt;
max = [textureList_i count];
y = 0;
maxheight = 0;
x = TEX_INDENT;
view = [textureView_i superview];
[view getBounds:&b];
maxwidth = b.size.width;
for (i = 0;i < max; i++)
{
t = [textureList_i elementAt:i];
if (x + t->r.size.width + TEX_INDENT > maxwidth)
{
x = TEX_INDENT;
y += maxheight;
maxheight = 0;
}
if (t->r.size.height > maxheight)
maxheight = t->r.size.height;
t->r.origin.x = x;
t->r.origin.y = y;
x += t->r.size.width + TEX_INDENT;
if (i == max - 1)
y += t->r.size.height;
}
viewWidth = maxwidth;
viewHeight = y + TEX_SPACING;
[textureView_i sizeTo:viewWidth :viewHeight];
pt.x = pt.y = 0;
[textureView_i scrollPoint:&pt];
return self;
}
- windowResized
{
[self computeTextureViewSize];
return self;
}
- texturedefChanged: sender
{
if ([map_i numSelected])
{
if ( [[map_i currentEntity] modifiable] )
{
[map_i makeSelectedPerform: @selector(takeCurrentTexture)];
[quakeed_i updateAll];
}
else
qprintf ("can't modify spawned entities");
}
[quakeed_i makeFirstResponder: quakeed_i];
return self;
}
- clearTexinfo: sender
{
[field_Xshift_i setFloatValue:0];
[field_Yshift_i setFloatValue:0];
[field_Xscale_i setFloatValue:1];
[field_Yscale_i setFloatValue:1];
[field_Rotate_i setFloatValue:0];
[self texturedefChanged: self];
return self;
}
//
// Set the selected texture
//
- setSelectedTexture:(int)which
{
texpal_t *t;
NXRect r;
char string[16];
// wipe the fields
[self clearTexinfo: self];
if (which != selectedTexture)
{
[textureView_i deselect];
selectedTexture = which;
t = [textureList_i elementAt:which];
r = t->r;
r.size.width += TEX_INDENT*2;
r.size.height += TEX_INDENT*2;
r.origin.x -= TEX_INDENT;
r.origin.y -= TEX_INDENT;
[textureView_i scrollRectToVisible:&r];
[textureView_i display];
sprintf(string,"%d x %d",(int)t->r.size.width,
(int)t->r.size.height - TEX_SPACING);
[sizeField_i setStringValue:string];
}
[self texturedefChanged:self];
return self;
}
//
// Return the selected texture index
//
- (int)getSelectedTexture
{
return selectedTexture;
}
//
// Return the original tex_ index of the selected texture
// so the texture info can be indexed from tex_images, etc.
//
- (int)getSelectedTexIndex
{
texpal_t *t;
if (selectedTexture == -1)
return -1;
t = [textureList_i elementAt:selectedTexture];
return t->index;
}
//
// Return the name of the selected texture
//
- (char *)getSelTextureName
{
texpal_t *t;
if (selectedTexture == -1)
return NULL;
t = [textureList_i elementAt:selectedTexture];
return t->name;
}
//
// Set selected texture by texture name
//
- setTextureByName:(char *)name
{
texpal_t *t;
int i;
int max;
max = [textureList_i count];
CleanupName(name,name);
for (i = 0;i < max;i++)
{
t = [textureList_i elementAt:i];
if (!strcmp(t->name,name))
{
[self setSelectedTexture: i];
return self;
}
}
return self;
}
//===================================================
//
// Action methods
//
//===================================================
//
// Search for texture named in searchField
//
- searchForTexture:sender
{
int i;
int max;
int len;
char name[32];
texpal_t *t;
if (selectedTexture == -1)
return self;
max = [textureList_i count];
strcpy(name,(const char *)[sender stringValue]);
[sender setStringValue:strupr(name)];
len = strlen(name);
for (i = selectedTexture-1;i >= 0; i--)
{
t = [textureList_i elementAt:i];
if (!strncmp(t->name,name,len))
{
[self setTextureByName:t->name];
[sender selectText:sender];
[self texturedefChanged:self];
return self;
}
}
for (i = max-1;i >= selectedTexture; i--)
{
t = [textureList_i elementAt:i];
if (!strncmp(t->name,name,len))
{
[self setTextureByName:t->name];
[sender selectText:sender];
[self texturedefChanged:self];
return self;
}
}
[self texturedefChanged:self];
return self;
}
//
// Set texture def from outside TexturePalette
//
- setTextureDef:(texturedef_t *)td
{
[self setTextureByName:td->texture];
[field_Xshift_i setFloatValue:td->shift[0]];
[field_Yshift_i setFloatValue:td->shift[1]];
[field_Xscale_i setFloatValue:td->scale[0]];
[field_Yscale_i setFloatValue:td->scale[1]];
[field_Rotate_i setFloatValue:td->rotate];
[self texturedefChanged:self];
return self;
}
//
// Return the current texture def to passed *
//
- getTextureDef:(texturedef_t *)td
{
if (selectedTexture == -1)
{
memset (td, 0, sizeof(*td));
strcpy (td->texture, "notexture");
return self;
}
strncpy(td->texture,[self getSelTextureName],16);
td->shift[0] = [field_Xshift_i floatValue];
td->shift[1] = [field_Yshift_i floatValue];
td->scale[0] = [field_Xscale_i floatValue];
td->scale[1] = [field_Yscale_i floatValue];
td->rotate = [field_Rotate_i floatValue];
return self;
}
//============================================================================
//
// Change value in a field
//
- changeField:(id)field by:(int)amount
{
int val;
val = [field intValue];
val += amount;
[field setIntValue:val];
[self texturedefChanged:self];
return self;
}
//
// Inc/Dec the XShift field
//
- incXShift:sender
{
[self changeField:field_Xshift_i by:8];
return self;
}
- decXShift:sender
{
[self changeField:field_Xshift_i by:-8];
return self;
}
//
// Inc/Dec the YShift field
//
- incYShift:sender
{
[self changeField:field_Yshift_i by:8];
return self;
}
- decYShift:sender
{
[self changeField:field_Yshift_i by:-8];
return self;
}
//
// Inc/Dec the Rotate field
//
- incRotate:sender
{
[self changeField:field_Rotate_i by:90];
return self;
}
- decRotate:sender
{
[self changeField:field_Rotate_i by:-90];
return self;
}
//
// Inc/Dec the Xscale field
//
- incXScale:sender
{
[field_Xscale_i setIntValue: 1];
[self texturedefChanged:self];
return self;
}
- decXScale:sender
{
[field_Xscale_i setIntValue: -1];
[self texturedefChanged:self];
return self;
}
//
// Inc/Dec the Yscale field
//
- incYScale:sender
{
[field_Yscale_i setIntValue: 1];
[self texturedefChanged:self];
return self;
}
- decYScale:sender
{
[field_Yscale_i setIntValue: -1];
[self texturedefChanged:self];
return self;
}
//============================================================================
//
// Search for texture in entire palette
// Return index of texturedef, or -1 if unsuccessful
//
- (int) searchForTextureInPalette:(char *)texture
{
int i;
int max;
char name[32];
texpal_t *t;
if (selectedTexture == -1)
return -1;
max = [textureList_i count];
strcpy(name,texture);
for (i = 0; i < max; i++)
{
t = [textureList_i elementAt:i];
if (!strcmp(t->name,name))
return i;
}
return -1;
};
//
// Scan thru map & only display textures that are in map
//
- onlyShowMapTextures:sender
{
int max;
int i;
int j;
id brushes;
SetBrush *b;
int numfaces;
face_t *f;
int index;
// Turn 'em off
if ([sender intValue])
{
max = [textureList_i count];
for (i = 0;i < max; i++)
[self setDisplayFlag:i to:0];
brushes = [map_i objectAt:0];
max = [brushes count];
for (i = 0;i < max; i++)
{
b = (SetBrush *)[brushes objectAt:i];
numfaces = [b getNumBrushFaces];
for (j = 0; j < numfaces; j++)
{
f = [b getBrushFace:j];
index = [self searchForTextureInPalette:f->texture.texture];
if (index >= 0)
[self setDisplayFlag:index to:1];
}
}
}
// Turn 'em on
else
{
max = [textureList_i count];
for (i = 0;i < max; i++)
[self setDisplayFlag:i to:1];
}
[textureView_i display];
return self;
}
- setDisplayFlag:(int)index to:(int)value
{
texpal_t *tp;
tp = [textureList_i elementAt:index];
tp->display = value;
return self;
};
@end
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.