HL2Overcharged/utils/vrad/macro_texture.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "tier1/strtools.h"
#include "macro_texture.h"
#include "bsplib.h"
#include "cmdlib.h"
#include "vtf/vtf.h"
#include "tier1/utldict.h"
#include "tier1/utlbuffer.h"
#include "bitmap/imageformat.h"


class CMacroTextureData
{
public:
	int m_Width, m_Height;
	CUtlMemory<unsigned char> m_ImageData;
};


CMacroTextureData *g_pGlobalMacroTextureData = NULL;

// Which macro texture each map face uses.
static CUtlDict<CMacroTextureData*, int> g_MacroTextureLookup;	// Stores a list of unique macro textures.
static CUtlVector<CMacroTextureData*> g_FaceMacroTextures;		// Which macro texture each face wants to use.
static Vector g_MacroWorldMins, g_MacroWorldMaxs;


CMacroTextureData* FindMacroTexture(const char *pFilename)
{
	int index = g_MacroTextureLookup.Find(pFilename);
	if (g_MacroTextureLookup.IsValidIndex(index))
		return g_MacroTextureLookup[index];
	else
		return NULL;
}


CMacroTextureData* LoadMacroTextureFile(const char *pFilename)
{
	FileHandle_t hFile = g_pFileSystem->Open(pFilename, "rb");
	if (hFile == FILESYSTEM_INVALID_HANDLE)
		return NULL;

	// Read the file in.
	CUtlVector<char> tempData;
	tempData.SetSize(g_pFileSystem->Size(hFile));
	g_pFileSystem->Read(tempData.Base(), tempData.Count(), hFile);
	g_pFileSystem->Close(hFile);


	// Now feed the data into a CUtlBuffer (great...)
	CUtlBuffer buf;
	buf.Put(tempData.Base(), tempData.Count());


	// Now make a texture out of it.
	IVTFTexture *pTex = CreateVTFTexture();
	if (!pTex->Unserialize(buf))
		Error("IVTFTexture::Unserialize( %s ) failed.", pFilename);

	pTex->ConvertImageFormat(IMAGE_FORMAT_RGBA8888, false);	// Get it in a format we like.


	// Now convert to a CMacroTextureData.
	CMacroTextureData *pData = new CMacroTextureData;
	pData->m_Width = pTex->Width();
	pData->m_Height = pTex->Height();
	pData->m_ImageData.EnsureCapacity(pData->m_Width * pData->m_Height * 4);
	memcpy(pData->m_ImageData.Base(), pTex->ImageData(), pData->m_Width * pData->m_Height * 4);

	DestroyVTFTexture(pTex);

	Msg("-- LoadMacroTextureFile: %s\n", pFilename);
	return pData;
}


void InitMacroTexture(const char *pBSPFilename)
{
	// Get the world bounds (same ones used by minimaps and level designers know how to use).
	int i = 0;
	for (i; i < num_entities; ++i)
	{
		char* pEntity = ValueForKey(&entities[i], "classname");
		if (!strcmp(pEntity, "worldspawn"))
		{
			GetVectorForKey(&entities[i], "world_mins", g_MacroWorldMins);
			GetVectorForKey(&entities[i], "world_maxs", g_MacroWorldMaxs);
			break;
		}
	}

	if (i == num_entities)
	{
		Warning("MaskOnMacroTexture: can't find worldspawn");
		return;
	}


	// Load the macro texture that is mapped onto everything.
	char mapName[512], vtfFilename[512];
	Q_FileBase(pBSPFilename, mapName, sizeof(mapName));
	Q_snprintf(vtfFilename, sizeof(vtfFilename), "materials/macro/%s/base.vtf", mapName);
	g_pGlobalMacroTextureData = LoadMacroTextureFile(vtfFilename);


	// Now load the macro texture for each face.
	g_FaceMacroTextures.SetSize(numfaces);
	for (int iFace = 0; iFace < numfaces; iFace++)
	{
		g_FaceMacroTextures[iFace] = NULL;

		if (iFace < g_FaceMacroTextureInfos.Count())
		{
			unsigned short stringID = g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID;
			if (stringID != 0xFFFF)
			{
				const char *pMacroTextureName = &g_TexDataStringData[g_TexDataStringTable[stringID]];
				Q_snprintf(vtfFilename, sizeof(vtfFilename), "%smaterials/%s.vtf", gamedir, pMacroTextureName);

				g_FaceMacroTextures[iFace] = FindMacroTexture(vtfFilename);
				if (!g_FaceMacroTextures[iFace])
				{
					g_FaceMacroTextures[iFace] = LoadMacroTextureFile(vtfFilename);
					if (g_FaceMacroTextures[iFace])
					{
						g_MacroTextureLookup.Insert(vtfFilename, g_FaceMacroTextures[iFace]);
					}
				}
			}
		}
	}
}


inline Vector SampleMacroTexture(const CMacroTextureData *t, const Vector &vWorldPos)
{
	int ix = (int)RemapVal(vWorldPos.x, g_MacroWorldMins.x, g_MacroWorldMaxs.x, 0, t->m_Width - 0.00001);
	int iy = (int)RemapVal(vWorldPos.y, g_MacroWorldMins.y, g_MacroWorldMaxs.y, 0, t->m_Height - 0.00001);
	ix = clamp(ix, 0, t->m_Width - 1);
	iy = t->m_Height - 1 - clamp(iy, 0, t->m_Height - 1);

	const unsigned char *pInputColor = &t->m_ImageData[(iy*t->m_Width + ix) * 4];
	return Vector(pInputColor[0] / 255.0, pInputColor[1] / 255.0, pInputColor[2] / 255.0);
}


void ApplyMacroTextures(int iFace, const Vector &vWorldPos, Vector &outLuxel)
{
	// Add the global macro texture.
	Vector vGlobal;
	if (g_pGlobalMacroTextureData)
		outLuxel *= SampleMacroTexture(g_pGlobalMacroTextureData, vWorldPos);

	// Now add the per-material macro texture.
	if (g_FaceMacroTextures[iFace])
		outLuxel *= SampleMacroTexture(g_FaceMacroTextures[iFace], vWorldPos);
}