tf2/tf2_src/hammer/wadtexture.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implementation of the IEditorTexture interface for WAD textures.
//
//=============================================================================//


#include "stdafx.h"
#include <process.h>
#include <afxtempl.h>
#include <io.h>
#include <sys\stat.h>
#include <fcntl.h>
#include "hammer.h"
#include "MapDoc.h"
#include "Options.h"
#include "MainFrm.h"
#include "GlobalFunctions.h"
#include "WADTypes.h"
#include "BSPFile.h"
#include "bitmap/imageformat.h" // hack : don't want to include this just for ImageFormat
#include "TextureSystem.h"
#include "WADTexture.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>


#pragma warning(disable:4244)


#define _GraphicCacheAllocate(n)	malloc(n)


//-----------------------------------------------------------------------------
// Stuff for loading WAD3 files.
//-----------------------------------------------------------------------------
typedef struct WAD3miptex_s
{
	char		name[16];
	unsigned	width, height;
	unsigned	offsets[4];			// four mip maps stored
} WAD3miptex_t;


//-----------------------------------------------------------------------------
// Stuff for loading WAL files.
//-----------------------------------------------------------------------------
typedef struct					// Mip Graphic
{
	char name[32];				// Name of the Graphic.
	DWORD width;				// width of picture, must be a multiple of 8
	DWORD height;				// height of picture, must be a multiple of 8
	DWORD offset1;				// offset to u_char Pix[width   * height]
	DWORD offset2;				// offset to u_char Pix[width/2 * height/2]
	DWORD offset4;				// offset to u_char Pix[width/4 * height/4]
	DWORD offset8;				// offset to u_char Pix[width/8 * height/8]
	char animname[32];
	DWORD surface;
	DWORD contents;
	DWORD value;
} walhdr_t;


static char *g_pLoadBuf = NULL;
static int g_nLoadSize = 128 * 1024;


extern void ScaleBitmap(CSize sizeSrc, CSize sizeDest, char *src, char *dest);


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nSize - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
static bool AllocateLoadBuffer(int nSize)
{
	if (nSize > g_nLoadSize)
	{
		g_nLoadSize = nSize;

		if (g_pLoadBuf != NULL)
		{
			delete[] g_pLoadBuf;
			g_pLoadBuf = NULL;
		}
	}

	if (g_pLoadBuf == NULL)
	{
		g_pLoadBuf = new char[g_nLoadSize];
	}

	if (g_pLoadBuf == NULL)
	{
		return(false);
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: Constructor. Initializes data members.
//-----------------------------------------------------------------------------
CWADTexture::CWADTexture(void)
{
	memset(m_szName, 0, sizeof(m_szName));
	memset(m_szFileName, 0, sizeof(m_szFileName));

	m_datawidth = 0;
	m_dataheight = 0;

	m_WALsurface = 0;
	m_WALvalue = 0;
	m_WALcontents = 0;

	m_ulFileOffset = 0;
	m_ulFileID = 0;

	memset(&format, 0, sizeof(format));

	m_pPalette = NULL;
	m_bLocalPalette = false;

	m_nWidth = 0;
	m_nHeight = 0;

	m_pData = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Destructor. Frees texture image data and palette.
//-----------------------------------------------------------------------------
CWADTexture::~CWADTexture(void)
{
	//
	// Free image data.
	//
	if (m_pData != NULL)
	{
		free(m_pData);
		m_pData = NULL;
	}

	//
	// Free palette.
	//
	if (m_pPalette != NULL)
	{
		free(m_pPalette);
		m_pPalette = NULL;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the full path of the file (WAD, PAK, or WAL) from which this
//			texture was loaded.
//-----------------------------------------------------------------------------
const char *CWADTexture::GetFileName( void ) const
{
	return(m_szFileName);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : fd - 
//			ulFileID - 
//			bLoad - 
//			pszName - 
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CWADTexture::Init(int fd, DWORD ulFileID, BOOL bLoad, LPCTSTR pszName)
{
	//
	// Load header and copy needed data into members variables.
	//
	GRAPHICSFILESTRUCT FileInfo;
	bool bFound = g_Textures.FindGraphicsFile(&FileInfo, ulFileID);
	if (!bFound)
	{
		miptex_t hdr;
		_read(fd, (char *)&hdr, sizeof(hdr));

		m_nWidth = hdr.width;
		m_nHeight = hdr.height;
	}
	else if (FileInfo.format == tfWAD3)
	{
		WAD3miptex_t hdr;
		_read(fd, (char *)&hdr, sizeof(hdr));

		m_nWidth = hdr.width;
		m_nHeight = hdr.height;

		if (m_nHeight < 0)
		{
			return(FALSE);
		}
	}
	else
	{
		return(FALSE);
	}

	m_ulFileID = ulFileID;

	strcpy(m_szName, pszName);

	if (bFound)
	{
		strcpy(m_szFileName, FileInfo.filename);
	}

	if (m_nWidth * m_nHeight > MAX_TEXTURESIZE)
	{
		return(FALSE);
	}

	if (!m_szName[0])
	{
		return(FALSE);
	}

	// set offset
	m_ulFileOffset = _tell(fd);
	
	if (bLoad)
	{
		return(Load());
	}

	return(TRUE);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : CPalette *
//-----------------------------------------------------------------------------
CPalette *CWADTexture::GetPalette(void) const
{
	static CPalette pal;
	pal.DeleteObject();
	pal.CreatePalette(m_pPalette);
	return &pal;
}


//-----------------------------------------------------------------------------
// Purpose: Returns a string of comma delimited keywords associated with this
//			material.
// Input  : pszKeywords - Buffer to receive keywords, NULL to query string length.
// Output : Returns the number of characters in the keyword string.
//-----------------------------------------------------------------------------
int CWADTexture::GetKeywords(char *pszKeywords) const
{
	//
	// Set the keywords to the WAD file name.
	//
	if (pszKeywords != NULL)
	{
		const char *pszLastSlash = strrchr(m_szFileName, '\\');
		if (pszLastSlash != NULL)
		{
			pszLastSlash++;
			strcpy(pszKeywords, pszLastSlash);
		}
		else
		{
			strcpy(pszKeywords, m_szFileName);
		}
	}

	return(strlen(m_szFileName));
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pszName - 
// Output : Returns the length of the short name in characters.
//-----------------------------------------------------------------------------
int CWADTexture::GetShortName(char *pszName) const
{
	char szBuf[MAX_PATH];
	szBuf[0] = '\0';

	if (pszName == NULL)
	{
		pszName = szBuf;
	}

	if (format == tfWAL)
	{
		const char *pszCopy = strstr(m_szName, "textures");
		if (pszCopy == NULL)
		{
			pszCopy = m_szName;
		}
		else
		{
			pszCopy += strlen("textures\\");
		}

		strcpy(pszName, pszCopy);

		// remove extension
		char *psz = strstr(szBuf, ".wal");
		if (psz != NULL)
		{
			*psz = 0;
		}
	}
	else
	{
		strcpy(pszName, m_szName);
	}

	return(strlen(pszName));
}


//-----------------------------------------------------------------------------
// Purpose: Resizes a texture to be even powers of 2 in width and height.
// Input  : pLoadBuf - 
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CWADTexture::AdjustTexture(char *pLoadBuf)
{
	// make height/width power of two
	int i, i2;

	for (i = 0; ; i++)
	{
		i2 = 1 << i;
		if (i2 >= m_nWidth)
		{
			m_datawidth = i2;
			break;
		}
	}

	for (i = 0; ; i++)
	{
		i2 = 1 << i;
		if (i2 >= m_nHeight)
		{
			m_dataheight = i2;	
			break;
		}
	}

	// allocate data
	m_pData = _GraphicCacheAllocate(m_datawidth * m_dataheight);

	if (m_pData == NULL)
	{
		CString errmsg;
		errmsg.Format(IDS_ERRLOADGRAPHIC, m_szName);
		AfxMessageBox(errmsg);
		return FALSE;
	}

	// scale up to data
	ScaleBitmap(CSize(m_nWidth, m_nHeight), CSize(m_datawidth, m_dataheight), pLoadBuf, (char *)m_pData);

	return TRUE;
}

bool CWADTexture::IsLoaded() const
{
	return (m_pData != NULL);
}

//-----------------------------------------------------------------------------
// Purpose: Load data from file associated with m_ulFileID.
// Input  : fd - 
//			hFile - 
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CWADTexture::Load(int fd, HANDLE hFile)
{
	if (m_pData)
	{
		return TRUE;	// already loaded
	}
	
	// if fd is -1, get it from base file.. otherwise we've been
	//  given an fd by caller, so use that in loading
	GRAPHICSFILESTRUCT fileInfo;
	Q_memset( &fileInfo, 0, sizeof(fileInfo));


	if (fd == -1)
	{
		// find graphics file - different loading based on wad type.
		if (!g_Textures.FindGraphicsFile(&fileInfo, m_ulFileID))
		{	
			return(FALSE);
		}

		// keep fd
		fd = fileInfo.fd;
		
		// seek to offset
		_lseek(fd, m_ulFileOffset, SEEK_SET);
	}

	m_bLocalPalette = FALSE;

	// dvs: if fd != -1, using FileInfo without initializing it!!
	if (!AllocateLoadBuffer(m_nWidth * m_nHeight))
	{
		AfxMessageBox("Couldn't allocate a texture loading buffer.");
		return FALSE;
	}

	// load bitmap
	_read(fd, g_pLoadBuf, m_nWidth * m_nHeight);

	//
	// If WAD3, read the palette.
	//
	if (fileInfo.format == tfWAD3)
	{
		WORD nPal;

		_lseek(fd, (m_nWidth / 2 * m_nHeight / 2) + (m_nWidth / 4 * m_nHeight / 4) + (m_nWidth / 8 * m_nHeight / 8), SEEK_CUR);

		_read(fd, &nPal, sizeof nPal);

		Assert(nPal <= 256);

		if ((nPal > 0) && (nPal < 1024))
		{
			m_bLocalPalette = TRUE;
			
			// setup palette
			m_pPalette = (LOGPALETTE *)malloc(sizeof(WORD) * 2 + sizeof(PALETTEENTRY) * nPal);

			// fast load - throw into buffer
			static unsigned char PalBuf[3 * 1024];
			_read(fd, PalBuf, nPal * 3);

			// convert to LOGPALETTE
			for (int i = 0; i < nPal; i++)
			{
				m_pPalette->palPalEntry[i].peRed = PalBuf[i*3];
				m_pPalette->palPalEntry[i].peGreen = PalBuf[i*3+1];
				m_pPalette->palPalEntry[i].peBlue = PalBuf[i*3+2];
				m_pPalette->palPalEntry[i].peFlags = D3DRMPALETTE_READONLY | PC_NOCOLLAPSE;
			}

			m_pPalette->palVersion = 0x300;
			m_pPalette->palNumEntries = nPal;
		}
	}

	AdjustTexture(g_pLoadBuf);

	return TRUE;
}


//-----------------------------------------------------------------------------
// Purpose: If the buffer pointer passed in is not NULL, copies the image data
//			in RGB format to the buffer
// Input  : pImageRGB - Pointer to buffer that receives the image data. If the
//				pointer is NULL, no data is copied, only the data size is returned.
// Output : Returns a the size of the RGB image in bytes.
//-----------------------------------------------------------------------------
int CWADTexture::GetImageDataRGB( void *pImageRGB )
{
	if ( pImageRGB != NULL )
	{
		Load();

		unsigned char *puchImage = ( unsigned char * )m_pData;
		unsigned char *pIndex = ( unsigned char * )pImageRGB;

		for (int y = 0; y < m_dataheight; y++)
		{
			for (int x = 0; x < m_datawidth; x++)
			{
				unsigned char chPaletteEntry = puchImage[y * m_datawidth + x];

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peRed;
				pIndex++;

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peGreen;
				pIndex++;

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peBlue;
				pIndex++;
			}
		}
	}

	return(	m_datawidth * m_dataheight * 3 );
}


//-----------------------------------------------------------------------------
// Purpose: If the buffer pointer passed in is not NULL, copies the image data
//			in RGBA format to the buffer
// Input  : pImageRGBA - Pointer to buffer that receives the image data. If the
//				pointer is NULL, no data is copied, only the data size is returned.
// Output : Returns a the size of the RGBA image in bytes.
//-----------------------------------------------------------------------------
int CWADTexture::GetImageDataRGBA( void *pImageRGBA )
{
	if ( pImageRGBA != NULL )
	{
		unsigned char *puchImage = (unsigned char *)m_pData;
		unsigned char *pIndex = (unsigned char *)pImageRGBA;

		for (int y = 0; y < m_dataheight; y++)
		{
			for (int x = 0; x < m_datawidth; x++)
			{
				unsigned char chPaletteEntry = puchImage[y * m_datawidth + x];

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peRed;
				pIndex++;

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peGreen;
				pIndex++;

				*pIndex = m_pPalette->palPalEntry[chPaletteEntry].peBlue;
				pIndex++;

				*pIndex = 0;
				pIndex++;
			}
		}
	}

	return(	m_datawidth * m_dataheight * 4 );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : size - 
//-----------------------------------------------------------------------------
void CWADTexture::GetSize(SIZE& size)
{
	size.cx = m_nWidth;
	size.cy = m_nHeight;
}


//-----------------------------------------------------------------------------
// Purpose: Draws white "No Image" text in a black rectangle.
// Input  : pDC - 
//			rect - 
//			iFontHeight - 
//			dwFlags - 
//-----------------------------------------------------------------------------
void CWADTexture::DrawNoImage(CDC *pDC, RECT& rect, int iFontHeight)
{
	// draw "no data"
	CFont *pOldFont = (CFont*) pDC->SelectStockObject(ANSI_VAR_FONT);
	COLORREF cr = pDC->SetTextColor(RGB(0xff, 0xff, 0xff));
	COLORREF cr2 = pDC->SetBkColor(RGB(0, 0, 0));

	// draw black rect first
	pDC->FillRect(&rect, CBrush::FromHandle(HBRUSH(GetStockObject(BLACK_BRUSH))));

	// then text
	pDC->TextOut(rect.left+2, rect.top+2, "No Image", 8);
	pDC->SelectObject(pOldFont);
	pDC->SetTextColor(cr);
	pDC->SetBkColor(cr2);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pDC - 
//			rect - 
//			iFontHeight - 
//			dwFlags - 
//-----------------------------------------------------------------------------
void CWADTexture::Draw(CDC *pDC, RECT& rect, int iFontHeight, int iIconHeight, DrawTexData_t &DrawTexData)
{
	if (!m_nWidth)
	{
		DrawNoImage(pDC, rect, iFontHeight);
		return;
	}

	// no data -
	if (!m_pData)
	{
		// try to load -
		if (!Load())
		{
			DrawNoImage(pDC, rect, iFontHeight);
			return;
		}
	}

	static struct
	{
		BITMAPINFOHEADER bmih;
		unsigned short colorindex[256];
	} bmi;

	BITMAPINFOHEADER& bmih = bmi.bmih;
	memset(&bmih, 0, sizeof bmih);
	bmih.biSize = sizeof(bmih);
	bmih.biWidth = m_datawidth;
	bmih.biHeight = -m_dataheight;	// top-down DIB
	bmih.biCompression = BI_RGB;
	bmih.biBitCount = 8;

	bmih.biPlanes = 1;

	static BOOL bInit = FALSE;
	if (!bInit)
	{
		bInit = TRUE;
		for (int i = 0; i < 256; i++)
		{
			bmi.colorindex[i] = i;
		}
	}

	int dest_width = rect.right - rect.left;
	int dest_height = rect.bottom - rect.top;

	if (DrawTexData.nFlags & drawCaption)
	{
		dest_height -= iFontHeight + 4;
	}

	if (!(DrawTexData.nFlags & drawResizeAlways))
	{
		if (m_nWidth < dest_width)
		{
			dest_width = m_nWidth;
		}

		if (m_nHeight < dest_height)
		{
			dest_height = m_nHeight;
		}
	}

	SetStretchBltMode(pDC->m_hDC, COLORONCOLOR);

	if (StretchDIBits(pDC->m_hDC, rect.left, rect.top, dest_width, dest_height, 0, 0, m_datawidth, m_dataheight, m_pData, (BITMAPINFO*)&bmi, DIB_PAL_COLORS, SRCCOPY) == GDI_ERROR)
	{
		Msg(mwError, "CWADTexture::Draw(): StretchDIBits failed.");
	}

	//
	// Caption.
	//
	if (DrawTexData.nFlags & drawCaption)
	{
		// draw background for name
		CBrush brCaption(RGB(0, 0, 255));
		CRect rcCaption(rect);
		
		rcCaption.top = rcCaption.bottom - (iFontHeight + 5);
		pDC->FillRect(rcCaption, &brCaption);

		// draw name
		char szShortName[MAX_PATH];
		int iLen = GetShortName(szShortName);
		pDC->TextOut(rect.left, rect.bottom - (iFontHeight + 4), szShortName, iLen);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Frees the static load buffer.
//-----------------------------------------------------------------------------
bool CWADTexture::Initialize(void)
{
	return(AllocateLoadBuffer(g_nLoadSize));
}


//-----------------------------------------------------------------------------
// Purpose: Loads this texture from disk, if it is not already loaded.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWADTexture::Load( void )
{
	if (m_pData != NULL)
	{
		// Already loaded.
		return(true);
	}

	return(Load(-1, NULL) == TRUE);
}


//-----------------------------------------------------------------------------
// Purpose: Frees the static load buffer.
//-----------------------------------------------------------------------------
void CWADTexture::ShutDown(void)
{
	if (g_pLoadBuf != NULL)
	{
		delete[] g_pLoadBuf;
		g_pLoadBuf = NULL;
	}
}