Wolfenstein 3-D!

This is a port of Wolf4SDL, which is derived from the original id
software source release. The port runs on top of the SDL plugin
runtime and is loaded as an overlay.

Licensing of the game code is not an issue, as discussed below
(essentially, the Debian project treats Wolf4SDL as GPLv2, with an
email from John Carmack backing it up):

  http://forums.rockbox.org/index.php?topic=52872

Included is a copy of MAME's Yamaha OPL sound chip emulator
(fmopl_gpl.c).  This file was not part of the original Wolf4SDL source
(which includes a non-GPL'd version), but was rather rebased from from
a later MAME source which had been relicensed to GPLv2.

Change-Id: I64c2ba035e0be7e2f49252f40640641416613439

1 files changed, 435 insertions, 0 deletions

diff --git a/apps/plugins/sdl/progs/wolf3d/id_vh.c b/apps/plugins/sdl/progs/wolf3d/id_vh.c
new file mode 100644
index 0000000000..a63dd065a7
--- /dev/null
+++ b/apps/plugins/sdl/progs/wolf3d/id_vh.c
@@ -0,0 +1,435 @@
+#include "wl_def.h"
+
+
+pictabletype    *pictable;
+SDL_Surface     *latchpics[NUMLATCHPICS];
+
+int         px,py;
+byte    fontcolor,backcolor;
+int         fontnumber;
+
+//==========================================================================
+
+void VWB_DrawPropString(const char* string)
+{
+        fontstruct  *font;
+        int                 width, step, height;
+        byte        *source, *dest;
+        byte        ch;
+
+    byte *vbuf = LOCK();
+
+        font = (fontstruct *) grsegs[STARTFONT+fontnumber];
+        height = font->height;
+        dest = vbuf + scaleFactor * (py * curPitch + px);
+
+        while ((ch = (byte)*string++)!=0)
+        {
+                width = step = font->width[ch];
+                source = ((byte *)font)+font->location[ch];
+                while (width--)
+                {
+                        for(int i=0;i<height;i++)
+                        {
+                                if(source[i*step])
+                {
+                    for(unsigned sy=0; sy<scaleFactor; sy++)
+                        for(unsigned sx=0; sx<scaleFactor; sx++)
+                                                dest[(scaleFactor*i+sy)*curPitch+sx]=fontcolor;
+                }
+                        }
+
+                        source++;
+                        px++;
+                        dest+=scaleFactor;
+                }
+        }
+
+        UNLOCK();
+}
+
+/*
+=================
+=
+= VL_MungePic
+=
+=================
+*/
+
+void VL_MungePic (byte *source, unsigned width, unsigned height)
+{
+        unsigned x,y,plane,size,pwidth;
+        byte *temp, *dest, *srcline;
+
+        size = width*height;
+
+        if (width&3)
+                Quit ("VL_MungePic: Not divisable by 4!");
+
+//
+// copy the pic to a temp buffer
+//
+        temp=(byte *) malloc(size);
+    CHECKMALLOCRESULT(temp);
+        memcpy (temp,source,size);
+
+//
+// munge it back into the original buffer
+//
+        dest = source;
+        pwidth = width/4;
+
+        for (plane=0;plane<4;plane++)
+        {
+                srcline = temp;
+                for (y=0;y<height;y++)
+                {
+                        for (x=0;x<pwidth;x++)
+                                *dest++ = *(srcline+x*4+plane);
+                        srcline+=width;
+                }
+        }
+
+        free(temp);
+}
+
+void VWL_MeasureString (const char *string, word *width, word *height, fontstruct *font)
+{
+        *height = font->height;
+        for (*width = 0;*string;string++)
+                *width += font->width[*((byte *)string)];       // proportional width
+}
+
+void VW_MeasurePropString (const char *string, word *width, word *height)
+{
+        VWL_MeasureString(string,width,height,(fontstruct *)grsegs[STARTFONT+fontnumber]);
+}
+
+/*
+=============================================================================
+
+                                Double buffer management routines
+
+=============================================================================
+*/
+
+void VH_UpdateScreen()
+{
+        SDL_BlitSurface(screenBuffer, NULL, screen, NULL);
+        SDL_Flip(screen);
+}
+
+
+void VWB_DrawTile8 (int x, int y, int tile)
+{
+        LatchDrawChar(x,y,tile);
+}
+
+void VWB_DrawTile8M (int x, int y, int tile)
+{
+        VL_MemToScreen (((byte *)grsegs[STARTTILE8M])+tile*64,8,8,x,y);
+}
+
+void VWB_DrawPic (int x, int y, int chunknum)
+{
+        int     picnum = chunknum - STARTPICS;
+        unsigned width,height;
+
+        x &= ~7;
+
+        width = pictable[picnum].width;
+        height = pictable[picnum].height;
+
+        VL_MemToScreen (grsegs[chunknum],width,height,x,y);
+}
+
+void VWB_DrawPicScaledCoord (int scx, int scy, int chunknum)
+{
+        int     picnum = chunknum - STARTPICS;
+        unsigned width,height;
+
+        width = pictable[picnum].width;
+        height = pictable[picnum].height;
+
+    VL_MemToScreenScaledCoord (grsegs[chunknum],width,height,scx,scy);
+}
+
+
+void VWB_Bar (int x, int y, int width, int height, int color)
+{
+        VW_Bar (x,y,width,height,color);
+}
+
+void VWB_Plot (int x, int y, int color)
+{
+    if(scaleFactor == 1)
+        VW_Plot(x,y,color);
+    else
+        VW_Bar(x, y, 1, 1, color);
+}
+
+void VWB_Hlin (int x1, int x2, int y, int color)
+{
+    if(scaleFactor == 1)
+        VW_Hlin(x1,x2,y,color);
+    else
+        VW_Bar(x1, y, x2-x1+1, 1, color);
+}
+
+void VWB_Vlin (int y1, int y2, int x, int color)
+{
+    if(scaleFactor == 1)
+                VW_Vlin(y1,y2,x,color);
+    else
+        VW_Bar(x, y1, 1, y2-y1+1, color);
+}
+
+
+/*
+=============================================================================
+
+                                                WOLFENSTEIN STUFF
+
+=============================================================================
+*/
+
+/*
+=====================
+=
+= LatchDrawPic
+=
+=====================
+*/
+
+void LatchDrawPic (unsigned x, unsigned y, unsigned picnum)
+{
+        VL_LatchToScreen_ez (latchpics[2+picnum-LATCHPICS_LUMP_START], x*8, y);
+}
+
+void LatchDrawPicScaledCoord (unsigned scx, unsigned scy, unsigned picnum)
+{
+        VL_LatchToScreenScaledCoord_ez (latchpics[2+picnum-LATCHPICS_LUMP_START], scx*8, scy);
+}
+
+
+//==========================================================================
+
+/*
+===================
+=
+= LoadLatchMem
+=
+===================
+*/
+
+void LoadLatchMem (void)
+{
+        int     i,width,height,start,end;
+        byte *src;
+        SDL_Surface *surf;
+
+//
+// tile 8s
+//
+    surf = SDL_CreateRGBSurface(SDL_HWSURFACE, 8*8,
+        ((NUMTILE8 + 7) / 8) * 8, 8, 0, 0, 0, 0);
+    if(surf == NULL)
+    {
+        Quit("Unable to create surface for tiles!");
+    }
+    SDL_SetColors(surf, gamepal, 0, 256);
+
+        latchpics[0] = surf;
+        CA_CacheGrChunk (STARTTILE8);
+        src = grsegs[STARTTILE8];
+
+        for (i=0;i<NUMTILE8;i++)
+        {
+                VL_MemToLatch (src, 8, 8, surf, (i & 7) * 8, (i >> 3) * 8);
+                src += 64;
+        }
+        UNCACHEGRCHUNK (STARTTILE8);
+
+//
+// pics
+//
+        start = LATCHPICS_LUMP_START;
+        end = LATCHPICS_LUMP_END;
+
+        for (i=start;i<=end;i++)
+        {
+                width = pictable[i-STARTPICS].width;
+                height = pictable[i-STARTPICS].height;
+                surf = SDL_CreateRGBSurface(SDL_HWSURFACE, width, height, 8, 0, 0, 0, 0);
+        if(surf == NULL)
+        {
+            Quit("Unable to create surface for picture!");
+        }
+        SDL_SetColors(surf, gamepal, 0, 256);
+
+                latchpics[2+i-start] = surf;
+                CA_CacheGrChunk (i);
+                VL_MemToLatch (grsegs[i], width, height, surf, 0, 0);
+                UNCACHEGRCHUNK(i);
+        }
+}
+
+//==========================================================================
+
+/*
+===================
+=
+= FizzleFade
+=
+= returns true if aborted
+=
+= It uses maximum-length Linear Feedback Shift Registers (LFSR) counters.
+= You can find a list of them with lengths from 3 to 168 at:
+= http://www.xilinx.com/support/documentation/application_notes/xapp052.pdf
+= Many thanks to Xilinx for this list!!!
+=
+===================
+*/
+
+// XOR masks for the pseudo-random number sequence starting with n=17 bits
+static const uint32_t rndmasks[] = {
+                    // n    XNOR from (starting at 1, not 0 as usual)
+    0x00012000,     // 17   17,14
+    0x00020400,     // 18   18,11
+    0x00040023,     // 19   19,6,2,1
+    0x00090000,     // 20   20,17
+    0x00140000,     // 21   21,19
+    0x00300000,     // 22   22,21
+    0x00420000,     // 23   23,18
+    0x00e10000,     // 24   24,23,22,17
+    0x01200000,     // 25   25,22      (this is enough for 8191x4095)
+};
+
+static unsigned int rndbits_y;
+static unsigned int rndmask;
+
+extern SDL_Color curpal[256];
+
+// Returns the number of bits needed to represent the given value
+static int log2_ceil(uint32_t x)
+{
+    int n = 0;
+    uint32_t v = 1;
+    while(v < x)
+    {
+        n++;
+        v <<= 1;
+    }
+    return n;
+}
+
+void VH_Startup()
+{
+    int rndbits_x = log2_ceil(screenWidth);
+    rndbits_y = log2_ceil(screenHeight);
+
+    int rndbits = rndbits_x + rndbits_y;
+    if(rndbits < 17)
+        rndbits = 17;       // no problem, just a bit slower
+    else if(rndbits > 25)
+        rndbits = 25;       // fizzle fade will not fill whole screen
+
+    rndmask = rndmasks[rndbits - 17];
+}
+
+boolean FizzleFade (SDL_Surface *source, int x1, int y1,
+    unsigned width, unsigned height, unsigned frames, boolean abortable)
+{
+    unsigned x, y, frame, pixperframe;
+    int32_t  rndval, lastrndval;
+    int      first = 1;
+
+    lastrndval = 0;
+    pixperframe = width * height / frames;
+
+    IN_StartAck ();
+
+    frame = GetTimeCount();
+    byte *srcptr = VL_LockSurface(source);
+    do
+    {
+        if(abortable && IN_CheckAck ())
+        {
+            VL_UnlockSurface(source);
+            SDL_BlitSurface(source, NULL, screen, NULL);
+            SDL_Flip(screen);
+            return true;
+        }
+
+        byte *destptr = VL_LockSurface(screen);
+
+        rndval = lastrndval;
+
+        // When using double buffering, we have to copy the pixels of the last AND the current frame.
+        // Only for the first frame, there is no "last frame"
+        for(int i = first; i < 2; i++)
+        {
+            for(unsigned p = 0; p < pixperframe; p++)
+            {
+                //
+                // seperate random value into x/y pair
+                //
+
+                x = rndval >> rndbits_y;
+                y = rndval & ((1 << rndbits_y) - 1);
+
+                //
+                // advance to next random element
+                //
+
+                rndval = (rndval >> 1) ^ (rndval & 1 ? 0 : rndmask);
+
+                if(x >= width || y >= height)
+                {
+                    if(rndval == 0)     // entire sequence has been completed
+                        goto finished;
+                    p--;
+                    continue;
+                }
+
+                //
+                // copy one pixel
+                //
+
+                if(screenBits == 8)
+                {
+                    *(destptr + (y1 + y) * screen->pitch + x1 + x)
+                        = *(srcptr + (y1 + y) * source->pitch + x1 + x);
+                }
+                else
+                {
+                    byte col = *(srcptr + (y1 + y) * source->pitch + x1 + x);
+                    uint32_t fullcol = SDL_MapRGB(screen->format, curpal[col].r, curpal[col].g, curpal[col].b);
+                    memcpy(destptr + (y1 + y) * screen->pitch + (x1 + x) * screen->format->BytesPerPixel,
+                        &fullcol, screen->format->BytesPerPixel);
+                }
+
+                if(rndval == 0)         // entire sequence has been completed
+                    goto finished;
+            }
+
+            if(!i || first) lastrndval = rndval;
+        }
+
+        // If there is no double buffering, we always use the "first frame" case
+        if(usedoublebuffering) first = 0;
+
+        VL_UnlockSurface(screen);
+        SDL_Flip(screen);
+
+        frame++;
+        Delay(frame - GetTimeCount());        // don't go too fast
+    } while (1);
+
+finished:
+    VL_UnlockSurface(source);
+    VL_UnlockSurface(screen);
+    SDL_BlitSurface(source, NULL, screen, NULL);
+    SDL_Flip(screen);
+    return false;
+}