Superpower (Alt)/SUPERPOWER.iso/q/source/texturep.m

Text File | 1996-08-08 | 14.5 KB | 819 lines

#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