sird.c File Reference

#include "sw.h"
#include "rand1k.h"

Go to the source code of this file.

Macros
#define	R_SIRDw   144
#define	R_SIRDh   50
#define	R_SIRDmaxDiff   (R_SIRDw / 3)
#define	R_SIRDIgnoreExponents   5
#define	R_SIRDExponents   6
#define	R_SIRDstepsPerExponent   (R_SIRDmaxDiff / R_SIRDExponents)
#define	R_SIRD_ZofSky   0x8ccc
#define	R_SIRDnumRand   103

Functions
static int	UShortLog (int val)
static int	R_SIRDZFunc (int sub)
void	R_ApplySIRDAlgorithum (void)

Variables
static byte	r_SIRDBackground [R_SIRDw *R_SIRDh *VID_BYTES]
static const byte	r_SIRDrandValues []

Macro Definition Documentation

R_SIRD_ZofSky

#define R_SIRD_ZofSky   0x8ccc

Definition at line 60 of file sird.c.

R_SIRDExponents

#define R_SIRDExponents   6

Definition at line 52 of file sird.c.

R_SIRDh

#define R_SIRDh   50

Definition at line 36 of file sird.c.

R_SIRDIgnoreExponents

#define R_SIRDIgnoreExponents   5

Definition at line 48 of file sird.c.

R_SIRDmaxDiff

#define R_SIRDmaxDiff   (R_SIRDw / 3)

Definition at line 45 of file sird.c.

R_SIRDnumRand

#define R_SIRDnumRand   103

Definition at line 64 of file sird.c.

R_SIRDstepsPerExponent

#define R_SIRDstepsPerExponent   (R_SIRDmaxDiff / R_SIRDExponents)

Definition at line 55 of file sird.c.

R_SIRDw

#define R_SIRDw   144

Definition at line 33 of file sird.c.

Function Documentation

R_ApplySIRDAlgorithum()

void R_ApplySIRDAlgorithum

(

void

)

Definition at line 155 of file sird.c.

{
    short* curz, *oldz;
    short cz = 0, lastz = 0;
    byte* curp;
    byte* curbp, j = 0;
    int x, y, i, zinc, k;
    int mode = sw_drawsird->integer;
 
    //note of interest: I've made this static so that
    //if you like you could make it not static and see
    //what would happen if you didn't change the background
    static int ji = 0;
 
    //create the background image to tile
    //basically done by shifting the values around
    //each time and xoring them with a randomly
    //selected pixel
    for (i = 0; i < R_SIRDw * R_SIRDh * VID_BYTES; i++) {
        if ((i % R_SIRDnumRand) == 0) {
            ji++;
            ji %= R_SIRDnumRand;
            j = r_SIRDrandValues[r_SIRDrandValues[ji] % R_SIRDnumRand];
        }
        r_SIRDBackground[i] = r_SIRDrandValues[(i % R_SIRDnumRand) ] ^ j;
    }
 
    //if we are under water:
    if ((r_dowarp) && (vid.width != WARP_WIDTH)) {
        //the rendering is only in the top left
        //WARP_WIDTH by WARP_HEIGHT area, so scale the z-values
        //to span over the whole screen
 
 
        //why are we going backwards? so that we don't write over the
        //values before we read from them
 
        zinc = ((WARP_WIDTH * 0x10000) / vid.width);
        for (y = vid.height - 1; y >= 0; y--) {
            curz = (d_pzbuffer + (vid.width * y));
            oldz = (d_pzbuffer + (vid.width * ((y * WARP_HEIGHT) / vid.height)));
            k = (zinc * (vid.width - 1));
 
            for (x = vid.width - 1; x >= 0; x--) {
                curz[x] = oldz[k >> 16];
                k -= zinc;
            }
        }
    }
 
 
    //SIRDify each line
    for (y = 0; y < vid.height; y++) {
        curp = (vid.buffer + (vid.rowbytes * y));
        curz = (d_pzbuffer + (vid.width * y));
 
        if (mode != 3) {
            // draw the SIRD
 
            // copy the background into the left most column
            curbp = &(r_SIRDBackground[ R_SIRDw * (y % R_SIRDh) ]);
            for (x = 0; x < R_SIRDw; x++) {
                curp[0] = curbp[0];
                curp[1] = curbp[1];
                curp[2] = curbp[2];
 
                curp += VID_BYTES;
                curbp += VID_BYTES;
            }
 
            lastz = 0;
            cz = 0;
            curz += R_SIRDw;
            curbp = curp - R_SIRDw * VID_BYTES;
 
            // now calculate the SIRD
            for (x = R_SIRDw; x < vid.width; x++) {
                //only call the z-function with a new
                //value, it is slow so this saves quite
                //some time.
                if (lastz != *curz) {
                    lastz = *curz;
 
                    //convert from z to height offset
                    cz = (mode == 2) ? R_SIRDmaxDiff - R_SIRDZFunc(lastz) : R_SIRDZFunc(lastz);
 
                    //the "height offset" used in making SIRDS
                    //can be considered an adjustment of the
                    //frequency of repetition in the pattern.
                    //so here we are copying from bp to p, and so
                    //it simply increases or decreases the distance
                    //between the two.
                    curbp = (curp - R_SIRDw * VID_BYTES + cz * VID_BYTES);
                }
 
                curp[0] = curbp[0];
                curp[1] = curbp[1];
                curp[2] = curbp[2];
 
                curp += VID_BYTES;
                curbp += VID_BYTES;
                curz++;
            }
        } else {
            //if we are just drawing the height map
            //this lets you see which layers are used to
            //create the SIRD
            //
            //NOTE: even though it may sort of look like
            //a grey-scale height map, that is merely a
            //coincidence because of how the colours are
            //organized in the pallette.
 
            for (x = 0; x < vid.width; x++) {
                if (lastz != *curz) {
                    lastz = *curz;
                    cz = R_SIRDZFunc(*curz);
                }
 
                curp[0] = cz;
                curp[1] = cz;
                curp[2] = cz;
 
                curp += VID_BYTES;
                curz++;
            }
        }
    }
}

Referenced by R_RenderFrame().

R_SIRDZFunc()

static int R_SIRDZFunc ( int  sub )

static

Definition at line 101 of file sird.c.

{
    int e;
 
    //special case the sky.
    if (sub ==  R_SIRD_ZofSky)
        return 0;
 
#if id386 && (defined _MSC_VER)
    e = sub;
    //calculate the log (base 2) of the number. In other
    //words the index of the highest set bit. bsr is undefined
    //if it's input is 0, so special case that.
    if (e != 0) {
        __asm {
            mov ebx, e
            bsr eax, ebx
            mov e, eax
        }
    }
#else
    e = UShortLog(sub);
#endif
 
    //clip the exponent
    if (e < R_SIRDIgnoreExponents)
        return 0;
 
    // based on the power, shift the z so that
    // it's as high as it can get while still staying
    // under 0x100
    if (e > 8) {
        sub >>= (e - 8);
    } else {
        if (e < 8) {
            sub <<= (8 - e);
        }
    }
 
    // Lower the power of the number, this helps scaling and removes
    // small z values.
    e -= R_SIRDIgnoreExponents;
 
    // contruct the height value. The power is used as the primary calculator,
    // and then the extra bits are used to offset. In this way you
    // get more detail than just the log of the z value, and it works
    // as a pretty good approximation of it.
    e *= R_SIRDstepsPerExponent;
    e += ((sub * R_SIRDstepsPerExponent) >> 8);
 
    //make sure we stay under maximum height.
    return ((e <= R_SIRDmaxDiff) ? e : R_SIRDmaxDiff);
}

Referenced by R_ApplySIRDAlgorithum().

UShortLog()

static int UShortLog ( int  val )

static

Definition at line 81 of file sird.c.

{
    int mask = 0xff00;
    int p = 0;
    int b = 8;
    while (b) {
        if (val & mask) {
            p += b;
            b >>= 1;
            mask &= (mask << b);
        } else {
            mask &= (mask << (b >> 1));
            mask >>= b;
            b >>= 1;
        }
    }
    return p;
}

Referenced by R_SIRDZFunc().

Variable Documentation

r_SIRDBackground

byte r_SIRDBackground[R_SIRDw *R_SIRDh *VID_BYTES]

static

Definition at line 67 of file sird.c.

Referenced by R_ApplySIRDAlgorithum().

r_SIRDrandValues

const byte r_SIRDrandValues[]

static

Initial value:

= {
}

Definition at line 70 of file sird.c.

Referenced by R_ApplySIRDAlgorithum().