632 lines
27 KiB
C++
632 lines
27 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef IMATERIALSYSTEMFIXED_H
|
|
#define IMATERIALSYSTEMFIXED_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#define OVERBRIGHT 2.0f
|
|
#define OO_OVERBRIGHT (1.0f / 2.0f)
|
|
#define GAMMA 2.2f
|
|
#define TEXGAMMA 2.2f
|
|
|
|
#include "tier1/interface.h"
|
|
#include "tier1/refcount.h"
|
|
#include "mathlib/vector.h"
|
|
#include "mathlib/vector4d.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "appframework/IAppSystem.h"
|
|
#include "bitmap/imageformat.h"
|
|
#include "texture_group_names.h"
|
|
#include "vtf/vtf.h"
|
|
#include "materialsystem/deformations.h"
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
|
#include "materialsystem/IColorCorrection.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class IMaterial;
|
|
class IMesh;
|
|
class IVertexBuffer;
|
|
class IIndexBuffer;
|
|
struct MaterialSystem_Config_t;
|
|
class VMatrix;
|
|
struct matrix3x4_t;
|
|
class ITexture;
|
|
class ITextureCompositor;
|
|
struct MaterialSystemHardwareIdentifier_t;
|
|
class KeyValues;
|
|
class IShader;
|
|
class IVertexTexture;
|
|
class IMorph;
|
|
class IMatRenderContext;
|
|
class ICallQueue;
|
|
struct MorphWeight_t;
|
|
class IFileList;
|
|
|
|
abstract_class IMaterialSystemFixed : public IAppSystem
|
|
{
|
|
public:
|
|
// Placeholder for API revision
|
|
virtual bool Connect(CreateInterfaceFn factory) = 0;
|
|
virtual void Disconnect() = 0;
|
|
virtual void *QueryInterface(const char *pInterfaceName) = 0;
|
|
virtual InitReturnVal_t Init() = 0;
|
|
virtual void Shutdown() = 0;
|
|
|
|
//---------------------------------------------------------
|
|
// Initialization and shutdown
|
|
//---------------------------------------------------------
|
|
|
|
// Call this to initialize the material system
|
|
// returns a method to create interfaces in the shader dll
|
|
virtual CreateInterfaceFn Init(char const *pShaderAPIDLL,
|
|
IMaterialProxyFactory *pMaterialProxyFactory,
|
|
CreateInterfaceFn fileSystemFactory,
|
|
CreateInterfaceFn cvarFactory = NULL) = 0;
|
|
|
|
// Call this to set an explicit shader version to use
|
|
// Must be called before Init().
|
|
virtual void SetShaderAPI(char const *pShaderAPIDLL) = 0;
|
|
|
|
// Must be called before Init(), if you're going to call it at all...
|
|
virtual void SetAdapter(int nAdapter, int nFlags) = 0;
|
|
|
|
// Call this when the mod has been set up, which may occur after init
|
|
// At this point, the game + gamebin paths have been set up
|
|
virtual void ModInit() = 0;
|
|
virtual void ModShutdown() = 0;
|
|
|
|
//---------------------------------------------------------
|
|
//
|
|
//---------------------------------------------------------
|
|
virtual void SetThreadMode(MaterialThreadMode_t mode,
|
|
int nServiceThread = -1) = 0;
|
|
virtual MaterialThreadMode_t GetThreadMode() = 0;
|
|
virtual bool IsRenderThreadSafe() = 0;
|
|
virtual void ExecuteQueued() = 0;
|
|
|
|
//---------------------------------------------------------
|
|
// Config management
|
|
//---------------------------------------------------------
|
|
|
|
virtual IMaterialSystemHardwareConfig *GetHardwareConfig(
|
|
const char *pVersion, int *returnCode) = 0;
|
|
|
|
// Call this before rendering each frame with the current config
|
|
// for the material system.
|
|
// Will do whatever is necessary to get the material system into the correct
|
|
// state upon configuration change. .doesn't much else otherwise.
|
|
virtual bool UpdateConfig(bool bForceUpdate) = 0;
|
|
|
|
// Force this to be the config; update all material system convars to match
|
|
// the state return true if lightmaps need to be redownloaded
|
|
virtual bool OverrideConfig(const MaterialSystem_Config_t &config,
|
|
bool bForceUpdate) = 0;
|
|
|
|
// Get the current config for this video card (as last set by UpdateConfig)
|
|
virtual const MaterialSystem_Config_t &GetCurrentConfigForVideoCard()
|
|
const = 0;
|
|
|
|
// Gets *recommended* configuration information associated with the display
|
|
// card, given a particular dx level to run under. Use dxlevel 0 to use the
|
|
// recommended dx level. The function returns false if an invalid dxlevel
|
|
// was specified
|
|
|
|
// UNDONE: To find out all convars affected by configuration, we'll need to
|
|
// change the dxsupport.pl program to output all column headers into a
|
|
// single keyvalue block and then we would read that in, and send it back to
|
|
// the client
|
|
virtual bool GetRecommendedConfigurationInfo(int nDXLevel,
|
|
KeyValues *pKeyValues) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Device methods
|
|
// -----------------------------------------------------------
|
|
|
|
// Gets the number of adapters...
|
|
virtual int GetDisplayAdapterCount() const = 0;
|
|
|
|
// Returns the current adapter in use
|
|
virtual int GetCurrentAdapter() const = 0;
|
|
|
|
// Returns info about each adapter
|
|
virtual void GetDisplayAdapterInfo(int adapter, MaterialAdapterInfo_t &info)
|
|
const = 0;
|
|
|
|
// Returns the number of modes
|
|
virtual int GetModeCount(int adapter) const = 0;
|
|
|
|
// Returns mode information..
|
|
virtual void GetModeInfo(int adapter, int mode, MaterialVideoMode_t &info)
|
|
const = 0;
|
|
|
|
virtual void AddModeChangeCallBack(ModeChangeCallbackFunc_t func) = 0;
|
|
|
|
// Returns the mode info for the current display device
|
|
virtual void GetDisplayMode(MaterialVideoMode_t & mode) const = 0;
|
|
|
|
// Sets the mode...
|
|
virtual bool SetMode(void *hwnd, const MaterialSystem_Config_t &config) = 0;
|
|
|
|
virtual bool SupportsMSAAMode(int nMSAAMode) = 0;
|
|
|
|
// FIXME: REMOVE! Get video card identitier
|
|
virtual const MaterialSystemHardwareIdentifier_t &GetVideoCardIdentifier(
|
|
void) const = 0;
|
|
|
|
// Use this to spew information about the 3D layer
|
|
virtual void SpewDriverInfo() const = 0;
|
|
|
|
virtual void GetDXLevelDefaults(uint & max_dxlevel,
|
|
uint & recommended_dxlevel) = 0;
|
|
|
|
// Get the image format of the back buffer. . useful when creating render
|
|
// targets, etc.
|
|
virtual void GetBackBufferDimensions(int &width, int &height) const = 0;
|
|
virtual ImageFormat GetBackBufferFormat() const = 0;
|
|
|
|
virtual bool SupportsHDRMode(HDRType_t nHDRModede) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Window methods
|
|
// -----------------------------------------------------------
|
|
|
|
// Creates/ destroys a child window
|
|
virtual bool AddView(void *hwnd) = 0;
|
|
virtual void RemoveView(void *hwnd) = 0;
|
|
|
|
// Sets the view
|
|
virtual void SetView(void *hwnd) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Control flow
|
|
// -----------------------------------------------------------
|
|
|
|
virtual void BeginFrame(float frameTime) = 0;
|
|
virtual void EndFrame() = 0;
|
|
virtual void Flush(bool flushHardware = false) = 0;
|
|
|
|
/// FIXME: This stuff needs to be cleaned up and abstracted.
|
|
// Stuff that gets exported to the launcher through the engine
|
|
virtual void SwapBuffers() = 0;
|
|
|
|
// Flushes managed textures from the texture cacher
|
|
virtual void EvictManagedResources() = 0;
|
|
|
|
virtual void ReleaseResources(void) = 0;
|
|
virtual void ReacquireResources(void) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Device loss/restore
|
|
// -----------------------------------------------------------
|
|
|
|
// Installs a function to be called when we need to release vertex buffers +
|
|
// textures
|
|
virtual void AddReleaseFunc(MaterialBufferReleaseFunc_t func) = 0;
|
|
virtual void RemoveReleaseFunc(MaterialBufferReleaseFunc_t func) = 0;
|
|
|
|
// Installs a function to be called when we need to restore vertex buffers
|
|
virtual void AddRestoreFunc(MaterialBufferRestoreFunc_t func) = 0;
|
|
virtual void RemoveRestoreFunc(MaterialBufferRestoreFunc_t func) = 0;
|
|
|
|
// Release temporary HW memory...
|
|
virtual void ResetTempHWMemory(bool bExitingLevel = false) = 0;
|
|
|
|
// For dealing with device lost in cases where SwapBuffers isn't called all
|
|
// the time (Hammer)
|
|
virtual void HandleDeviceLost() = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Shaders
|
|
// -----------------------------------------------------------
|
|
|
|
// Used to iterate over all shaders for editing purposes
|
|
// GetShaders returns the number of shaders it actually found
|
|
virtual int ShaderCount() const = 0;
|
|
virtual int GetShaders(int nFirstShader, int nMaxCount,
|
|
IShader **ppShaderList) const = 0;
|
|
|
|
// FIXME: Is there a better way of doing this?
|
|
// Returns shader flag names for editors to be able to edit them
|
|
virtual int ShaderFlagCount() const = 0;
|
|
virtual const char *ShaderFlagName(int nIndex) const = 0;
|
|
|
|
// Gets the actual shader fallback for a particular shader
|
|
virtual void GetShaderFallback(const char *pShaderName,
|
|
char *pFallbackShader,
|
|
int nFallbackLength) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Material proxies
|
|
// -----------------------------------------------------------
|
|
|
|
virtual IMaterialProxyFactory *GetMaterialProxyFactory() = 0;
|
|
|
|
// Sets the material proxy factory. Calling this causes all materials to be
|
|
// uncached.
|
|
virtual void SetMaterialProxyFactory(IMaterialProxyFactory * pFactory) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Editor mode
|
|
// -----------------------------------------------------------
|
|
|
|
// Used to enable editor materials. Must be called before Init.
|
|
virtual void EnableEditorMaterials() = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Stub mode mode
|
|
// -----------------------------------------------------------
|
|
|
|
// Force it to ignore Draw calls.
|
|
virtual void SetInStubMode(bool bInStubMode) = 0;
|
|
|
|
//---------------------------------------------------------
|
|
// Debug support
|
|
//---------------------------------------------------------
|
|
|
|
virtual void DebugPrintUsedMaterials(const char *pSearchSubString,
|
|
bool bVerbose) = 0;
|
|
virtual void DebugPrintUsedTextures(void) = 0;
|
|
|
|
virtual void ToggleSuppressMaterial(char const *pMaterialName) = 0;
|
|
virtual void ToggleDebugMaterial(char const *pMaterialName) = 0;
|
|
|
|
//---------------------------------------------------------
|
|
// Misc features
|
|
//---------------------------------------------------------
|
|
// returns whether fast clipping is being used or not - needed to be exposed
|
|
// for better per-object clip behavior
|
|
virtual bool UsingFastClipping(void) = 0;
|
|
|
|
virtual int StencilBufferBits(
|
|
void) = 0; // number of bits per pixel in the stencil buffer
|
|
|
|
// CATHOOK - missing VFuncs
|
|
virtual void SuspendTextureStreaming(void);
|
|
virtual void ResumeTextureStreaming(void);
|
|
|
|
//---------------------------------------------------------
|
|
// Material and texture management
|
|
//---------------------------------------------------------
|
|
|
|
// uncache all materials. . good for forcing reload of materials.
|
|
virtual void UncacheAllMaterials() = 0;
|
|
|
|
// Remove any materials from memory that aren't in use as determined
|
|
// by the IMaterial's reference count.
|
|
virtual void UncacheUnusedMaterials(bool bRecomputeStateSnapshots =
|
|
false) = 0;
|
|
|
|
// Load any materials into memory that are to be used as determined
|
|
// by the IMaterial's reference count.
|
|
virtual void CacheUsedMaterials() = 0;
|
|
|
|
// Force all textures to be reloaded from disk.
|
|
virtual void ReloadTextures() = 0;
|
|
|
|
// Reloads materials
|
|
virtual void ReloadMaterials(const char *pSubString = NULL) = 0;
|
|
|
|
// Create a procedural material. The keyvalues looks like a VMT file
|
|
virtual IMaterial *CreateMaterial(const char *pMaterialName,
|
|
KeyValues *pVMTKeyValues) = 0;
|
|
|
|
// Find a material by name.
|
|
// The name of a material is a full path to
|
|
// the vmt file starting from "hl2/materials" (or equivalent) without
|
|
// a file extension.
|
|
// eg. "dev/dev_bumptest" refers to somethign similar to:
|
|
// "d:/hl2/hl2/materials/dev/dev_bumptest.vmt"
|
|
//
|
|
// Most of the texture groups for pTextureGroupName are listed in
|
|
// texture_group_names.h.
|
|
//
|
|
// Note: if the material can't be found, this returns a checkerboard
|
|
// material. You can find out if you have that material by calling
|
|
// IMaterial::IsErrorMaterial(). (Or use the global IsErrorMaterial
|
|
// function, which checks if it's null too).
|
|
virtual IMaterial *FindMaterial(
|
|
char const *pMaterialName, const char *pTextureGroupName,
|
|
bool complain = true, const char *pComplainPrefix = NULL) = 0;
|
|
|
|
// Query whether a material is loaded (eg, whether FindMaterial will be
|
|
// nonblocking)
|
|
virtual bool IsMaterialLoaded(char const *pMaterialName) = 0;
|
|
|
|
//---------------------------------
|
|
// This is the interface for knowing what materials are available
|
|
// is to use the following functions to get a list of materials. The
|
|
// material names will have the full path to the material, and that is the
|
|
// only way that the directory structure of the materials will be seen
|
|
// through this interface. NOTE: This is mostly for worldcraft to get a
|
|
// list of materials to put in the "texture" browser.in Worldcraft
|
|
virtual MaterialHandle_t FirstMaterial() const = 0;
|
|
|
|
// returns InvalidMaterial if there isn't another material.
|
|
// WARNING: you must call GetNextMaterial until it returns NULL,
|
|
// otherwise there will be a memory leak.
|
|
virtual MaterialHandle_t NextMaterial(MaterialHandle_t h) const = 0;
|
|
|
|
// This is the invalid material
|
|
virtual MaterialHandle_t InvalidMaterial() const = 0;
|
|
|
|
// Returns a particular material
|
|
virtual IMaterial *GetMaterial(MaterialHandle_t h) const = 0;
|
|
|
|
// Get the total number of materials in the system. These aren't just the
|
|
// used materials, but the complete collection.
|
|
virtual int GetNumMaterials() const = 0;
|
|
|
|
//---------------------------------
|
|
|
|
virtual void SetAsyncTextureLoadCache(void *hFileCache) = 0;
|
|
|
|
virtual ITexture *FindTexture(
|
|
char const *pTextureName, const char *pTextureGroupName,
|
|
bool complain = true, int nAdditionalCreationFlags = 0) = 0;
|
|
|
|
// Checks to see if a particular texture is loaded
|
|
virtual bool IsTextureLoaded(char const *pTextureName) const = 0;
|
|
|
|
// Creates a procedural texture
|
|
virtual ITexture *CreateProceduralTexture(
|
|
const char *pTextureName, const char *pTextureGroupName, int w, int h,
|
|
ImageFormat fmt, int nFlags) = 0;
|
|
|
|
//
|
|
// Render targets
|
|
//
|
|
virtual void BeginRenderTargetAllocation() = 0;
|
|
virtual void EndRenderTargetAllocation() = 0; // Simulate an Alt-Tab in
|
|
// here, which causes a
|
|
// release/restore of all
|
|
// resources
|
|
|
|
// Creates a render target
|
|
// If depth == true, a depth buffer is also allocated. If not, then
|
|
// the screen's depth buffer is used.
|
|
// Creates a texture for use as a render target
|
|
virtual ITexture *CreateRenderTargetTexture(
|
|
int w, int h,
|
|
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and
|
|
// regenerated on video mode change).
|
|
ImageFormat format,
|
|
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED) = 0;
|
|
|
|
virtual ITexture *CreateNamedRenderTargetTextureEx(
|
|
const char *pRTName, // Pass in NULL here for an unnamed render target.
|
|
int w, int h,
|
|
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and
|
|
// regenerated on video mode change).
|
|
ImageFormat format,
|
|
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED,
|
|
unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
|
|
unsigned int renderTargetFlags = 0) = 0;
|
|
|
|
virtual ITexture *CreateNamedRenderTargetTexture(
|
|
const char *pRTName, int w, int h,
|
|
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and
|
|
// regenerated on video mode change).
|
|
ImageFormat format,
|
|
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED,
|
|
bool bClampTexCoords = true, bool bAutoMipMap = false) = 0;
|
|
|
|
// Must be called between the above Begin-End calls!
|
|
virtual ITexture *CreateNamedRenderTargetTextureEx2(
|
|
const char *pRTName, // Pass in NULL here for an unnamed render target.
|
|
int w, int h,
|
|
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and
|
|
// regenerated on video mode change).
|
|
ImageFormat format,
|
|
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED,
|
|
unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
|
|
unsigned int renderTargetFlags = 0) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Lightmaps
|
|
// -----------------------------------------------------------
|
|
|
|
// To allocate lightmaps, sort the whole world by material twice.
|
|
// The first time through, call AllocateLightmap for every surface.
|
|
// that has a lightmap.
|
|
// The second time through, call AllocateWhiteLightmap for every
|
|
// surface that expects to use shaders that expect lightmaps.
|
|
virtual void BeginLightmapAllocation() = 0;
|
|
virtual void EndLightmapAllocation() = 0;
|
|
|
|
// returns the sorting id for this surface
|
|
virtual int AllocateLightmap(int width, int height,
|
|
int offsetIntoLightmapPage[2],
|
|
IMaterial *pMaterial) = 0;
|
|
// returns the sorting id for this surface
|
|
virtual int AllocateWhiteLightmap(IMaterial * pMaterial) = 0;
|
|
|
|
// lightmaps are in linear color space
|
|
// lightmapPageID is returned by GetLightmapPageIDForSortID
|
|
// lightmapSize and offsetIntoLightmapPage are returned by AllocateLightmap.
|
|
// You should never call UpdateLightmap for a lightmap allocated through
|
|
// AllocateWhiteLightmap.
|
|
virtual void UpdateLightmap(
|
|
int lightmapPageID, int lightmapSize[2], int offsetIntoLightmapPage[2],
|
|
float *pFloatImage, float *pFloatImageBump1, float *pFloatImageBump2,
|
|
float *pFloatImageBump3) = 0;
|
|
|
|
// fixme: could just be an array of ints for lightmapPageIDs since the
|
|
// material for a surface is already known.
|
|
virtual int GetNumSortIDs() = 0;
|
|
virtual void GetSortInfo(MaterialSystem_SortInfo_t * sortInfoArray) = 0;
|
|
|
|
// Read the page size of an existing lightmap by sort id (returned from
|
|
// AllocateLightmap())
|
|
virtual void GetLightmapPageSize(int lightmap, int *width, int *height)
|
|
const = 0;
|
|
|
|
virtual void ResetMaterialLightmapPageInfo() = 0;
|
|
|
|
virtual void ClearBuffers(bool bClearColor, bool bClearDepth,
|
|
bool bClearStencil = false) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// X360 specifics
|
|
// -----------------------------------------------------------
|
|
|
|
#if defined(_X360)
|
|
virtual void ListUsedMaterials(void) = 0;
|
|
virtual HXUIFONT OpenTrueTypeFont(const char *pFontname, int tall,
|
|
int style) = 0;
|
|
virtual void CloseTrueTypeFont(HXUIFONT hFont) = 0;
|
|
virtual bool GetTrueTypeFontMetrics(HXUIFONT hFont,
|
|
XUIFontMetrics * pFontMetrics,
|
|
XUICharMetrics charMetrics[256]) = 0;
|
|
// Render a sequence of characters and extract the data into a buffer
|
|
// For each character, provide the width+height of the font texture subrect,
|
|
// an offset to apply when rendering the glyph, and an offset into a buffer
|
|
// to receive the RGBA data
|
|
virtual bool GetTrueTypeGlyphs(HXUIFONT hFont, int numChars, wchar_t *pWch,
|
|
int *pOffsetX, int *pOffsetY, int *pWidth,
|
|
int *pHeight, unsigned char *pRGBA,
|
|
int *pRGBAOffset) = 0;
|
|
virtual void PersistDisplay() = 0;
|
|
virtual void *GetD3DDevice() = 0;
|
|
virtual bool OwnGPUResources(bool bEnable) = 0;
|
|
#endif
|
|
|
|
// -----------------------------------------------------------
|
|
// Access the render contexts
|
|
// -----------------------------------------------------------
|
|
virtual IMatRenderContext *GetRenderContext() = 0;
|
|
|
|
virtual bool SupportsShadowDepthTextures(void) = 0;
|
|
virtual void BeginUpdateLightmaps(void) = 0;
|
|
virtual void EndUpdateLightmaps(void) = 0;
|
|
|
|
// -----------------------------------------------------------
|
|
// Methods to force the material system into non-threaded, non-queued mode
|
|
// -----------------------------------------------------------
|
|
virtual MaterialLock_t Lock() = 0;
|
|
virtual void Unlock(MaterialLock_t) = 0;
|
|
|
|
// Vendor-dependent shadow depth texture format
|
|
virtual ImageFormat GetShadowDepthTextureFormat() = 0;
|
|
|
|
virtual bool SupportsFetch4(void) = 0;
|
|
|
|
// Create a custom render context. Cannot be used to create
|
|
// MATERIAL_HARDWARE_CONTEXT
|
|
virtual IMatRenderContext *CreateRenderContext(
|
|
MaterialContextType_t type) = 0;
|
|
|
|
// Set a specified render context to be the global context for the thread.
|
|
// Returns the prior context.
|
|
virtual IMatRenderContext *SetRenderContext(IMatRenderContext *) = 0;
|
|
|
|
virtual bool SupportsCSAAMode(int nNumSamples, int nQualityLevel) = 0;
|
|
|
|
virtual void RemoveModeChangeCallBack(ModeChangeCallbackFunc_t func) = 0;
|
|
|
|
// Finds or create a procedural material.
|
|
virtual IMaterial *FindProceduralMaterial(const char *pMaterialName,
|
|
const char *pTextureGroupName,
|
|
KeyValues *pVMTKeyValues) = 0;
|
|
|
|
virtual ImageFormat GetNullTextureFormat() = 0;
|
|
|
|
virtual void AddTextureAlias(const char *pAlias, const char *pRealName) = 0;
|
|
virtual void RemoveTextureAlias(const char *pAlias) = 0;
|
|
|
|
// returns a lightmap page ID for this allocation, -1 if none available
|
|
// frameID is a number that should be changed every frame to prevent locking
|
|
// any textures that are being used to draw in the previous frame
|
|
virtual int AllocateDynamicLightmap(
|
|
int lightmapSize[2], int *pOutOffsetIntoPage, int frameID) = 0;
|
|
|
|
virtual void SetExcludedTextures(const char *pScriptName) = 0;
|
|
virtual void UpdateExcludedTextures(void) = 0;
|
|
|
|
virtual bool IsInFrame() const = 0;
|
|
|
|
virtual void CompactMemory() = 0;
|
|
|
|
// For sv_pure mode. The filesystem figures out which files the client needs
|
|
// to reload to be "pure" ala the server's preferences.
|
|
virtual void ReloadFilesInList(IFileList * pFilesToReload) = 0;
|
|
virtual bool AllowThreading(bool bAllow, int nServiceThread) = 0;
|
|
|
|
// Extended version of FindMaterial().
|
|
// Contains context in so it can make decisions (i.e. if it's a model,
|
|
// ignore certain cheat parameters)
|
|
virtual IMaterial *FindMaterialEx(
|
|
char const *pMaterialName, const char *pTextureGroupName, int nContext,
|
|
bool complain = true, const char *pComplainPrefix = NULL) = 0;
|
|
|
|
#ifdef DX_TO_GL_ABSTRACTION
|
|
virtual void DoStartupShaderPreloading(void) = 0;
|
|
#endif
|
|
|
|
// Sets the override sizes for all render target size tests. These replace
|
|
// the frame buffer size. Set them when you are rendering primarily to
|
|
// something larger than the frame buffer (as in VR mode).
|
|
virtual void SetRenderTargetFrameBufferSizeOverrides(int nWidth,
|
|
int nHeight) = 0;
|
|
|
|
// Returns the (possibly overridden) framebuffer size for render target
|
|
// sizing.
|
|
virtual void GetRenderTargetFrameBufferDimensions(int &nWidth,
|
|
int &nHeight) = 0;
|
|
|
|
// returns the display device name that matches the adapter index we were
|
|
// started with
|
|
virtual char *GetDisplayDeviceName() const = 0;
|
|
|
|
// creates a texture suitable for use with materials from a raw stream of
|
|
// bits. The bits will be retained by the material system and can be freed
|
|
// upon return.
|
|
virtual ITexture *CreateTextureFromBits(int w, int h, int mips,
|
|
ImageFormat fmt, int srcBufferSize,
|
|
byte *srcBits) = 0;
|
|
|
|
// Lie to the material system to pretend to be in render target allocation
|
|
// mode at the beginning of time. This was a thing that mattered a lot to
|
|
// old hardware, but doesn't matter at all to new hardware, where new is
|
|
// defined to be "anything from the last decade." However, we want to
|
|
// preserve legacy behavior for the old games because it's easier than
|
|
// testing them.
|
|
virtual void OverrideRenderTargetAllocation(bool rtAlloc) = 0;
|
|
|
|
// creates a texture compositor that will attempt to composite a new textuer
|
|
// from the steps of the specified KeyValues.
|
|
virtual ITextureCompositor *NewTextureCompositor(
|
|
int w, int h, const char *pCompositeName, int nTeamNum,
|
|
uint64 randomSeed, KeyValues *stageDesc,
|
|
uint32 texCompositeCreateFlags = 0) = 0;
|
|
|
|
// Loads the texture with the specified name, calls
|
|
// pRecipient->OnAsyncFindComplete with the result from the main thread.
|
|
// once the texture load is complete. If the texture cannot be found, the
|
|
// returned texture will return true for IsError().
|
|
virtual void AsyncFindTexture(
|
|
const char *pFilename, const char *pTextureGroupName,
|
|
IAsyncTextureOperationReceiver *pRecipient, void *pExtraArgs,
|
|
bool bComplain = true, int nAdditionalCreationFlags = 0) = 0;
|
|
|
|
// creates a texture suitable for use with materials from a raw stream of
|
|
// bits. The bits will be retained by the material system and can be freed
|
|
// upon return.
|
|
virtual ITexture *CreateNamedTextureFromBitsEx(
|
|
const char *pName, const char *pTextureGroupName, int w, int h,
|
|
int mips, ImageFormat fmt, int srcBufferSize, byte *srcBits,
|
|
int nFlags) = 0;
|
|
};
|
|
|
|
#endif // IMATERIALSYSTEMFIXED_H
|