qzdoom-gpl/src/textures/automaptexture.cpp
Christoph Oelckers 2536eca01d - Changed: Patch and IMGZ textures now initialize their dimensions upon creation.
The lump is open anyway at that time so deferring this action until the information
  is needed doesn't give any speed improvements. Now GetDimensions and all its
  associated overhead is gone.
- Added support for TGA textures. It can handle all of the common variations
  of this format.
- Changed: GI_PAGESARERAW is no longer checked. It wasn't really necessary before
  because the chance of texture misidentification is absolutely minimal.
  But raw pages are now restricted to textures of type TEX_MiscPatch only.
- Changed the automap parchment to use a regular texture. The previous 
  FAutomapTexture is only used as a last resort fallback now. If the code
  finds a recognizable graphic it will create a proper texture for it now.
- Fixed: Flats were only auto-scaled when in Doom flat format.
- Fixed: FMultiPatchTexture::CheckForHacks blindly assumed that all patches
  were FPstchTextures. Since the texture code does not have any type information
  I added a new flag bIsPatch for this purpose.
- Moved all texture classes into their own source files and created a new
  subdirectory 'textures' for that.
- Cleaned up the texture management code and added some stricter checks for
  the validity of Doom patches. The old code liked to crash when being passed
  some non-graphic data.

SVN r300 (trunk)
2006-08-20 12:55:46 +00:00

122 lines
3.4 KiB
C++

/*
** automaptexture.cpp
** Texture class for Raven's automap parchment
**
**---------------------------------------------------------------------------
** Copyright 2004-2006 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
** This texture type is only used as a last resort when everything else has failed for creating
** the AUTOPAGE texture. That's because Raven used a raw lump of non-standard proportions to define it.
**
*/
#include "doomtype.h"
#include "files.h"
#include "r_data.h"
#include "w_wad.h"
bool FAutomapTexture::Check(FileReader & data)
{
if (data.GetLength() < 320) return false;
return true;
}
FTexture *FAutomapTexture::Create(FileReader & file, int lumpnum)
{
return new FAutomapTexture(lumpnum);
}
FAutomapTexture::FAutomapTexture (int lumpnum)
: Pixels(NULL), LumpNum(lumpnum)
{
Width = 320;
Height = Wads.LumpLength(lumpnum) / 320;
CalcBitSize ();
DummySpan[0].TopOffset = 0;
DummySpan[0].Length = Height;
DummySpan[1].TopOffset = 0;
DummySpan[1].Length = 0;
}
FAutomapTexture::~FAutomapTexture ()
{
Unload ();
}
void FAutomapTexture::Unload ()
{
if (Pixels != NULL)
{
delete[] Pixels;
Pixels = NULL;
}
}
void FAutomapTexture::MakeTexture ()
{
int x, y;
FMemLump data = Wads.ReadLump (LumpNum);
const BYTE *indata = (const BYTE *)data.GetMem();
Pixels = new BYTE[Width * Height];
for (x = 0; x < Width; ++x)
{
for (y = 0; y < Height; ++y)
{
Pixels[x*Height+y] = indata[x+320*y];
}
}
}
const BYTE *FAutomapTexture::GetPixels ()
{
if (Pixels == NULL)
{
MakeTexture ();
}
return Pixels;
}
const BYTE *FAutomapTexture::GetColumn (unsigned int column, const Span **spans_out)
{
if (Pixels == NULL)
{
MakeTexture ();
}
if ((unsigned)column >= (unsigned)Width)
{
column %= Width;
}
if (spans_out != NULL)
{
*spans_out = DummySpan;
}
return Pixels + column*Height;
}