tf2/tf2_src/materialsystem/texturemanager.h

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

#ifndef TEXTUREMANAGER_H
#define TEXTUREMANAGER_H

#ifdef _WIN32
#pragma once
#endif

#include "itextureinternal.h"
class ITexture;
class ITextureInternal;
class IVTFTexture;

enum
{
	COLOR_CORRECTION_MAX_TEXTURES = 4,
	COLOR_CORRECTION_TEXTURE_SIZE = 32
};

class CTextureCompositorTemplate;

//-----------------------------------------------------------------------------
// Texture manager interface
//-----------------------------------------------------------------------------
abstract_class ITextureManager
{
public:
	// Initialization + shutdown
	virtual void Init( int nFlags ) = 0;
	virtual void Shutdown() = 0;

	// Allocate, free standard render target textures
	virtual void AllocateStandardRenderTargets( ) = 0;
	virtual void FreeStandardRenderTargets() = 0;

	//Some render targets are managed by code outside of the materialsystem but are used by the materialsystem all the time.
	virtual void CacheExternalStandardRenderTargets() = 0;

	// Creates a procedural texture
	// NOTE: Passing in NULL as a texture name will cause it to not
	// be able to be looked up by name using FindOrLoadTexture.
	// Also, you may not get a texture with the requested size or format;
	// you'll get something close though.
	virtual ITextureInternal *CreateProceduralTexture( 
		const char			*pTextureName, 
		const char			*pTextureGroupName,
		int					w,
		int					h, 
		int					d,
		ImageFormat			fmt,
		int					nFlags,
		ITextureRegenerator *generator = NULL) = 0;

	// Creates a texture which is a render target
	virtual ITextureInternal *CreateRenderTargetTexture( 
		const char				*pRTName,	// NULL for auto-generated name
		int						w, 
		int						h, 
		RenderTargetSizeMode_t	sizeMode, 
		ImageFormat				fmt, 
		RenderTargetType_t		type, 
		unsigned int			textureFlags,
		unsigned int			renderTargetFlags ) = 0;

	// Loads a texture from disk
	virtual ITextureInternal *FindOrLoadTexture( const char *pTextureName, const char *pTextureGroupName, int nAdditionalCreationFlags = 0 ) = 0;

	// Call this to reset the filtering state
	virtual void ResetTextureFilteringState() = 0;

	// Reload all textures
	virtual void ReloadTextures( void ) = 0;

	// These two are used when we lose our video memory due to a mode switch etc
	virtual void ReleaseTextures( void ) = 0;
	virtual void RestoreRenderTargets( void ) = 0;
	virtual void RestoreNonRenderTargetTextures( void ) = 0;

	// Suspend or resume texture streaming requests
	virtual void SuspendTextureStreaming( void ) = 0;
	virtual void ResumeTextureStreaming( void ) = 0;

	// delete any texture that has a refcount <= 0
	virtual void RemoveUnusedTextures( void ) = 0;
	virtual void DebugPrintUsedTextures( void ) = 0;

	// Request a texture ID
	virtual int	RequestNextTextureID() = 0;

	// Get at a couple standard textures
	virtual ITextureInternal *ErrorTexture() = 0;
	virtual ITextureInternal *NormalizationCubemap() = 0;
	virtual ITextureInternal *SignedNormalizationCubemap() = 0;
	virtual ITextureInternal *ColorCorrectionTexture( int index ) = 0;
	virtual ITextureInternal *ShadowNoise2D() = 0;
	virtual ITextureInternal *IdentityLightWarp() = 0;
	virtual ITextureInternal *FullFrameDepthTexture() = 0;
	virtual ITextureInternal *DebugLuxels2D() = 0;

	// Generates an error texture pattern
	virtual void GenerateErrorTexture( ITexture *pTexture, IVTFTexture *pVTFTexture ) = 0;

	// Updates the color correction state
	virtual void SetColorCorrectionTexture( int i, ITextureInternal *pTexture ) = 0;

	virtual void ForceAllTexturesIntoHardware( void ) = 0;

	virtual bool IsTextureLoaded( const char *pTextureName ) = 0;

	// Mark a texture as now-unreferenced, so it can be checked for removal at a later (and thread-safe) time.
	virtual void MarkUnreferencedTextureForCleanup( ITextureInternal *pTexture ) = 0;

	virtual void RemoveTexture( ITextureInternal *pTexture ) = 0;

	// start with -1, list terminates with -1
	virtual int	FindNext( int iIndex, ITextureInternal **ppTexture ) = 0;

	virtual void AddTextureAlias( const char *pAlias, const char *pRealName ) = 0;
	virtual void RemoveTextureAlias( const char *pAlias ) = 0;

	virtual void SetExcludedTextures( const char *pScriptName ) = 0;
	virtual void UpdateExcludedTextures( void ) = 0;

	//Releases texture memory bits for temporary render targets, does NOT destroy the CTexture entirely
	virtual void ReleaseTempRenderTargetBits( void ) = 0;

	// See CL_HandlePureServerWhitelist for a description of the pure server stuff.
	virtual void ReloadFilesInList( IFileList *pFilesToReload ) = 0;

	// Called once per frame by material system "somewhere."
	virtual void Update( ) = 0;

	// Load a texture asynchronously and then call the provided callback.
	virtual void AsyncFindOrLoadTexture( const char *pTextureName, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain, int nAdditionalCreationFlags ) = 0;

	// Stream a render target back to system memory, perform format conversion to the specified destination format, 
	virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs ) = 0;

	virtual void WarmTextureCache() = 0;
	virtual void CoolTextureCache() = 0;

	virtual void RequestAllMipmaps( ITextureInternal* pTex ) = 0;
	
	virtual void EvictAllTextures() = 0;

	virtual void UpdatePostAsync() = 0;

	virtual void ReleaseAsyncScratchVTF( IVTFTexture* pScratchVTF ) = 0;

	virtual bool ThreadInAsyncLoadThread() const = 0;
	virtual bool ThreadInAsyncReadThread() const = 0;

	virtual bool HasPendingTextureDestroys() const = 0;

	virtual bool AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc ) = 0;
	virtual bool VerifyTextureCompositorTemplates() = 0;

	virtual CTextureCompositorTemplate* FindTextureCompositorTemplate( const char* pName ) = 0;

};


//-----------------------------------------------------------------------------
// Singleton instance
//-----------------------------------------------------------------------------
inline ITextureManager *TextureManager()
{
	extern ITextureManager *g_pTextureManager;
	return g_pTextureManager;
}


#endif // TEXTUREMANAGER_H