You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1826 lines
70 KiB
1826 lines
70 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
// |
|
//===========================================================================// |
|
|
|
#ifndef IMATERIALSYSTEM_H |
|
#define IMATERIALSYSTEM_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 "mathlib/vector.h" |
|
#include "mathlib/vector4d.h" |
|
#include "mathlib/vmatrix.h" |
|
#include "tier1/interface.h" |
|
#include "tier1/refcount.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" |
|
#include "tier1/memhelpers.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; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// The vertex format type |
|
//----------------------------------------------------------------------------- |
|
typedef uint64 VertexFormat_t; |
|
|
|
//----------------------------------------------------------------------------- |
|
// important enumeration |
|
//----------------------------------------------------------------------------- |
|
|
|
// NOTE NOTE NOTE!!!! If you up this, grep for "NEW_INTERFACE" to see if there is anything |
|
// waiting to be enabled during an interface revision. |
|
|
|
// V081 - 10/25/2016 - Added new Suspend/Resume texture streaming interfaces. Might also have added more calls here due |
|
// to the streaming work that didn't get bumped, but we're not guarding versions on the TF branch |
|
// very judiciously since we need to audit them when merging to SDK branch either way. |
|
#define MATERIAL_SYSTEM_INTERFACE_VERSION "VMaterialSystem081" |
|
|
|
#ifdef POSIX |
|
#define ABSOLUTE_MINIMUM_DXLEVEL 90 |
|
#else |
|
#define ABSOLUTE_MINIMUM_DXLEVEL 80 |
|
#endif |
|
|
|
enum ShaderParamType_t |
|
{ |
|
SHADER_PARAM_TYPE_TEXTURE, |
|
SHADER_PARAM_TYPE_INTEGER, |
|
SHADER_PARAM_TYPE_COLOR, |
|
SHADER_PARAM_TYPE_VEC2, |
|
SHADER_PARAM_TYPE_VEC3, |
|
SHADER_PARAM_TYPE_VEC4, |
|
SHADER_PARAM_TYPE_ENVMAP, // obsolete |
|
SHADER_PARAM_TYPE_FLOAT, |
|
SHADER_PARAM_TYPE_BOOL, |
|
SHADER_PARAM_TYPE_FOURCC, |
|
SHADER_PARAM_TYPE_MATRIX, |
|
SHADER_PARAM_TYPE_MATERIAL, |
|
SHADER_PARAM_TYPE_STRING, |
|
SHADER_PARAM_TYPE_MATRIX4X2 |
|
}; |
|
|
|
enum MaterialMatrixMode_t |
|
{ |
|
MATERIAL_VIEW = 0, |
|
MATERIAL_PROJECTION, |
|
|
|
// Texture matrices |
|
MATERIAL_TEXTURE0, |
|
MATERIAL_TEXTURE1, |
|
MATERIAL_TEXTURE2, |
|
MATERIAL_TEXTURE3, |
|
MATERIAL_TEXTURE4, |
|
MATERIAL_TEXTURE5, |
|
MATERIAL_TEXTURE6, |
|
MATERIAL_TEXTURE7, |
|
|
|
MATERIAL_MODEL, |
|
|
|
// Total number of matrices |
|
NUM_MATRIX_MODES = MATERIAL_MODEL+1, |
|
|
|
// Number of texture transforms |
|
NUM_TEXTURE_TRANSFORMS = MATERIAL_TEXTURE7 - MATERIAL_TEXTURE0 + 1 |
|
}; |
|
|
|
// FIXME: How do I specify the actual number of matrix modes? |
|
const int NUM_MODEL_TRANSFORMS = 53; |
|
const int MATERIAL_MODEL_MAX = MATERIAL_MODEL + NUM_MODEL_TRANSFORMS; |
|
|
|
enum MaterialPrimitiveType_t |
|
{ |
|
MATERIAL_POINTS = 0x0, |
|
MATERIAL_LINES, |
|
MATERIAL_TRIANGLES, |
|
MATERIAL_TRIANGLE_STRIP, |
|
MATERIAL_LINE_STRIP, |
|
MATERIAL_LINE_LOOP, // a single line loop |
|
MATERIAL_POLYGON, // this is a *single* polygon |
|
MATERIAL_QUADS, |
|
MATERIAL_INSTANCED_QUADS, // (X360) like MATERIAL_QUADS, but uses vertex instancing |
|
|
|
// This is used for static meshes that contain multiple types of |
|
// primitive types. When calling draw, you'll need to specify |
|
// a primitive type. |
|
MATERIAL_HETEROGENOUS |
|
}; |
|
|
|
enum MaterialPropertyTypes_t |
|
{ |
|
MATERIAL_PROPERTY_NEEDS_LIGHTMAP = 0, // bool |
|
MATERIAL_PROPERTY_OPACITY, // int (enum MaterialPropertyOpacityTypes_t) |
|
MATERIAL_PROPERTY_REFLECTIVITY, // vec3_t |
|
MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS // bool |
|
}; |
|
|
|
// acceptable property values for MATERIAL_PROPERTY_OPACITY |
|
enum MaterialPropertyOpacityTypes_t |
|
{ |
|
MATERIAL_ALPHATEST = 0, |
|
MATERIAL_OPAQUE, |
|
MATERIAL_TRANSLUCENT |
|
}; |
|
|
|
enum MaterialBufferTypes_t |
|
{ |
|
MATERIAL_FRONT = 0, |
|
MATERIAL_BACK |
|
}; |
|
|
|
enum MaterialCullMode_t |
|
{ |
|
MATERIAL_CULLMODE_CCW, // this culls polygons with counterclockwise winding |
|
MATERIAL_CULLMODE_CW // this culls polygons with clockwise winding |
|
}; |
|
|
|
enum MaterialIndexFormat_t |
|
{ |
|
MATERIAL_INDEX_FORMAT_UNKNOWN = -1, |
|
MATERIAL_INDEX_FORMAT_16BIT = 0, |
|
MATERIAL_INDEX_FORMAT_32BIT, |
|
}; |
|
|
|
enum MaterialFogMode_t |
|
{ |
|
MATERIAL_FOG_NONE, |
|
MATERIAL_FOG_LINEAR, |
|
MATERIAL_FOG_LINEAR_BELOW_FOG_Z, |
|
}; |
|
|
|
enum MaterialHeightClipMode_t |
|
{ |
|
MATERIAL_HEIGHTCLIPMODE_DISABLE, |
|
MATERIAL_HEIGHTCLIPMODE_RENDER_ABOVE_HEIGHT, |
|
MATERIAL_HEIGHTCLIPMODE_RENDER_BELOW_HEIGHT |
|
}; |
|
|
|
enum MaterialNonInteractiveMode_t |
|
{ |
|
MATERIAL_NON_INTERACTIVE_MODE_NONE = -1, |
|
MATERIAL_NON_INTERACTIVE_MODE_STARTUP = 0, |
|
MATERIAL_NON_INTERACTIVE_MODE_LEVEL_LOAD, |
|
|
|
MATERIAL_NON_INTERACTIVE_MODE_COUNT, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Special morph used in decalling pass |
|
//----------------------------------------------------------------------------- |
|
#define MATERIAL_MORPH_DECAL ( (IMorph*)1 ) |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
enum MaterialThreadMode_t |
|
{ |
|
MATERIAL_SINGLE_THREADED, |
|
MATERIAL_QUEUED_SINGLE_THREADED, |
|
MATERIAL_QUEUED_THREADED |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
enum MaterialContextType_t |
|
{ |
|
MATERIAL_HARDWARE_CONTEXT, |
|
MATERIAL_QUEUED_CONTEXT, |
|
MATERIAL_NULL_CONTEXT |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
enum MaterialFindContext_t |
|
{ |
|
MATERIAL_FINDCONTEXT_NONE, |
|
MATERIAL_FINDCONTEXT_ISONAMODEL, |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Light structure |
|
//----------------------------------------------------------------------------- |
|
#include "mathlib/lightdesc.h" |
|
|
|
#if 0 |
|
enum LightType_t |
|
{ |
|
MATERIAL_LIGHT_DISABLE = 0, |
|
MATERIAL_LIGHT_POINT, |
|
MATERIAL_LIGHT_DIRECTIONAL, |
|
MATERIAL_LIGHT_SPOT, |
|
}; |
|
|
|
enum LightType_OptimizationFlags_t |
|
{ |
|
LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0 = 1, |
|
LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1 = 2, |
|
LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2 = 4, |
|
}; |
|
|
|
|
|
struct LightDesc_t |
|
{ |
|
LightType_t m_Type; |
|
Vector m_Color; |
|
Vector m_Position; |
|
Vector m_Direction; |
|
float m_Range; |
|
float m_Falloff; |
|
float m_Attenuation0; |
|
float m_Attenuation1; |
|
float m_Attenuation2; |
|
float m_Theta; |
|
float m_Phi; |
|
// These aren't used by DX8. . used for software lighting. |
|
float m_ThetaDot; |
|
float m_PhiDot; |
|
unsigned int m_Flags; |
|
|
|
|
|
LightDesc_t() {} |
|
|
|
private: |
|
// No copy constructors allowed |
|
LightDesc_t(const LightDesc_t& vOther); |
|
}; |
|
#endif |
|
|
|
#define CREATERENDERTARGETFLAGS_HDR 0x00000001 |
|
#define CREATERENDERTARGETFLAGS_AUTOMIPMAP 0x00000002 |
|
#define CREATERENDERTARGETFLAGS_UNFILTERABLE_OK 0x00000004 |
|
// XBOX ONLY: |
|
#define CREATERENDERTARGETFLAGS_NOEDRAM 0x00000008 // inhibit allocation in 360 EDRAM |
|
#define CREATERENDERTARGETFLAGS_TEMP 0x00000010 // only allocates memory upon first resolve, destroyed at level end |
|
|
|
//----------------------------------------------------------------------------- |
|
// allowed stencil operations. These match the d3d operations |
|
//----------------------------------------------------------------------------- |
|
enum StencilOperation_t |
|
{ |
|
#if !defined( _X360 ) |
|
STENCILOPERATION_KEEP = 1, |
|
STENCILOPERATION_ZERO = 2, |
|
STENCILOPERATION_REPLACE = 3, |
|
STENCILOPERATION_INCRSAT = 4, |
|
STENCILOPERATION_DECRSAT = 5, |
|
STENCILOPERATION_INVERT = 6, |
|
STENCILOPERATION_INCR = 7, |
|
STENCILOPERATION_DECR = 8, |
|
#else |
|
STENCILOPERATION_KEEP = D3DSTENCILOP_KEEP, |
|
STENCILOPERATION_ZERO = D3DSTENCILOP_ZERO, |
|
STENCILOPERATION_REPLACE = D3DSTENCILOP_REPLACE, |
|
STENCILOPERATION_INCRSAT = D3DSTENCILOP_INCRSAT, |
|
STENCILOPERATION_DECRSAT = D3DSTENCILOP_DECRSAT, |
|
STENCILOPERATION_INVERT = D3DSTENCILOP_INVERT, |
|
STENCILOPERATION_INCR = D3DSTENCILOP_INCR, |
|
STENCILOPERATION_DECR = D3DSTENCILOP_DECR, |
|
#endif |
|
STENCILOPERATION_FORCE_DWORD = 0x7fffffff |
|
}; |
|
|
|
enum StencilComparisonFunction_t |
|
{ |
|
#if !defined( _X360 ) |
|
STENCILCOMPARISONFUNCTION_NEVER = 1, |
|
STENCILCOMPARISONFUNCTION_LESS = 2, |
|
STENCILCOMPARISONFUNCTION_EQUAL = 3, |
|
STENCILCOMPARISONFUNCTION_LESSEQUAL = 4, |
|
STENCILCOMPARISONFUNCTION_GREATER = 5, |
|
STENCILCOMPARISONFUNCTION_NOTEQUAL = 6, |
|
STENCILCOMPARISONFUNCTION_GREATEREQUAL = 7, |
|
STENCILCOMPARISONFUNCTION_ALWAYS = 8, |
|
#else |
|
STENCILCOMPARISONFUNCTION_NEVER = D3DCMP_NEVER, |
|
STENCILCOMPARISONFUNCTION_LESS = D3DCMP_LESS, |
|
STENCILCOMPARISONFUNCTION_EQUAL = D3DCMP_EQUAL, |
|
STENCILCOMPARISONFUNCTION_LESSEQUAL = D3DCMP_LESSEQUAL, |
|
STENCILCOMPARISONFUNCTION_GREATER = D3DCMP_GREATER, |
|
STENCILCOMPARISONFUNCTION_NOTEQUAL = D3DCMP_NOTEQUAL, |
|
STENCILCOMPARISONFUNCTION_GREATEREQUAL = D3DCMP_GREATEREQUAL, |
|
STENCILCOMPARISONFUNCTION_ALWAYS = D3DCMP_ALWAYS, |
|
#endif |
|
|
|
STENCILCOMPARISONFUNCTION_FORCE_DWORD = 0x7fffffff |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Enumeration for the various fields capable of being morphed |
|
//----------------------------------------------------------------------------- |
|
enum MorphFormatFlags_t |
|
{ |
|
MORPH_POSITION = 0x0001, // 3D |
|
MORPH_NORMAL = 0x0002, // 3D |
|
MORPH_WRINKLE = 0x0004, // 1D |
|
MORPH_SPEED = 0x0008, // 1D |
|
MORPH_SIDE = 0x0010, // 1D |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// The morph format type |
|
//----------------------------------------------------------------------------- |
|
typedef unsigned int MorphFormat_t; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Standard lightmaps |
|
//----------------------------------------------------------------------------- |
|
enum StandardLightmap_t |
|
{ |
|
MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE = -1, |
|
MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP = -2, |
|
MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED = -3 |
|
}; |
|
|
|
|
|
struct MaterialSystem_SortInfo_t |
|
{ |
|
IMaterial *material; |
|
int lightmapPageID; |
|
}; |
|
|
|
|
|
#define MAX_FB_TEXTURES 4 |
|
|
|
//----------------------------------------------------------------------------- |
|
// Information about each adapter |
|
//----------------------------------------------------------------------------- |
|
enum |
|
{ |
|
MATERIAL_ADAPTER_NAME_LENGTH = 512 |
|
}; |
|
|
|
struct MaterialAdapterInfo_t |
|
{ |
|
char m_pDriverName[MATERIAL_ADAPTER_NAME_LENGTH]; |
|
unsigned int m_VendorID; |
|
unsigned int m_DeviceID; |
|
unsigned int m_SubSysID; |
|
unsigned int m_Revision; |
|
int m_nDXSupportLevel; // This is the *preferred* dx support level |
|
int m_nMaxDXSupportLevel; |
|
unsigned int m_nDriverVersionHigh; |
|
unsigned int m_nDriverVersionLow; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Video mode info.. |
|
//----------------------------------------------------------------------------- |
|
struct MaterialVideoMode_t |
|
{ |
|
int m_Width; // if width and height are 0 and you select |
|
int m_Height; // windowed mode, it'll use the window size |
|
ImageFormat m_Format; // use ImageFormats (ignored for windowed mode) |
|
int m_RefreshRate; // 0 == default (ignored for windowed mode) |
|
}; |
|
|
|
// fixme: should move this into something else. |
|
struct FlashlightState_t |
|
{ |
|
FlashlightState_t() |
|
{ |
|
m_bEnableShadows = false; // Provide reasonable defaults for shadow depth mapping parameters |
|
m_bDrawShadowFrustum = false; |
|
m_flShadowMapResolution = 1024.0f; |
|
m_flShadowFilterSize = 3.0f; |
|
m_flShadowSlopeScaleDepthBias = 16.0f; |
|
m_flShadowDepthBias = 0.0005f; |
|
m_flShadowJitterSeed = 0.0f; |
|
m_flShadowAtten = 0.0f; |
|
m_bScissor = false; |
|
m_nLeft = -1; |
|
m_nTop = -1; |
|
m_nRight = -1; |
|
m_nBottom = -1; |
|
m_nShadowQuality = 0; |
|
} |
|
|
|
Vector m_vecLightOrigin; |
|
Quaternion m_quatOrientation; |
|
float m_NearZ; |
|
float m_FarZ; |
|
float m_fHorizontalFOVDegrees; |
|
float m_fVerticalFOVDegrees; |
|
float m_fQuadraticAtten; |
|
float m_fLinearAtten; |
|
float m_fConstantAtten; |
|
float m_Color[4]; |
|
ITexture *m_pSpotlightTexture; |
|
int m_nSpotlightTextureFrame; |
|
|
|
// Shadow depth mapping parameters |
|
bool m_bEnableShadows; |
|
bool m_bDrawShadowFrustum; |
|
float m_flShadowMapResolution; |
|
float m_flShadowFilterSize; |
|
float m_flShadowSlopeScaleDepthBias; |
|
float m_flShadowDepthBias; |
|
float m_flShadowJitterSeed; |
|
float m_flShadowAtten; |
|
int m_nShadowQuality; |
|
|
|
// Getters for scissor members |
|
bool DoScissor() { return m_bScissor; } |
|
int GetLeft() { return m_nLeft; } |
|
int GetTop() { return m_nTop; } |
|
int GetRight() { return m_nRight; } |
|
int GetBottom() { return m_nBottom; } |
|
|
|
private: |
|
|
|
friend class CShadowMgr; |
|
|
|
bool m_bScissor; |
|
int m_nLeft; |
|
int m_nTop; |
|
int m_nRight; |
|
int m_nBottom; |
|
}; |
|
|
|
// Passed as the callback object to Async functions in the material system |
|
// so that callers don't have to worry about memory going out of scope before the |
|
// results return. |
|
abstract_class IAsyncTextureOperationReceiver : public IRefCounted |
|
{ |
|
public: |
|
virtual void OnAsyncCreateComplete( ITexture* pTex, void* pExtraArgs ) = 0; |
|
virtual void OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs ) = 0; |
|
virtual void OnAsyncMapComplete( ITexture* pTex, void* pExtraArgs, void* pMemory, int nPitch ) = 0; |
|
virtual void OnAsyncReadbackBegin( ITexture* pDst, ITexture* pSrc, void* pExtraArgs ) = 0; |
|
|
|
virtual int GetRefCount() const = 0; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Flags to be used with the Init call |
|
//----------------------------------------------------------------------------- |
|
enum MaterialInitFlags_t |
|
{ |
|
MATERIAL_INIT_ALLOCATE_FULLSCREEN_TEXTURE = 0x2, |
|
MATERIAL_INIT_REFERENCE_RASTERIZER = 0x4, |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Flags to specify type of depth buffer used with RT |
|
//----------------------------------------------------------------------------- |
|
|
|
// GR - this is to add RT with no depth buffer bound |
|
|
|
enum MaterialRenderTargetDepth_t |
|
{ |
|
MATERIAL_RT_DEPTH_SHARED = 0x0, |
|
MATERIAL_RT_DEPTH_SEPARATE = 0x1, |
|
MATERIAL_RT_DEPTH_NONE = 0x2, |
|
MATERIAL_RT_DEPTH_ONLY = 0x3, |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// A function to be called when we need to release all vertex buffers |
|
// NOTE: The restore function will tell the caller if all the vertex formats |
|
// changed so that it can flush caches, etc. if it needs to (for dxlevel support) |
|
//----------------------------------------------------------------------------- |
|
enum RestoreChangeFlags_t |
|
{ |
|
MATERIAL_RESTORE_VERTEX_FORMAT_CHANGED = 0x1, |
|
}; |
|
|
|
|
|
// NOTE: All size modes will force the render target to be smaller than or equal to |
|
// the size of the framebuffer. |
|
enum RenderTargetSizeMode_t |
|
{ |
|
RT_SIZE_NO_CHANGE=0, // Only allowed for render targets that don't want a depth buffer |
|
// (because if they have a depth buffer, the render target must be less than or equal to the size of the framebuffer). |
|
RT_SIZE_DEFAULT=1, // Don't play with the specified width and height other than making sure it fits in the framebuffer. |
|
RT_SIZE_PICMIP=2, // Apply picmip to the render target's width and height. |
|
RT_SIZE_HDR=3, // frame_buffer_width / 4 |
|
RT_SIZE_FULL_FRAME_BUFFER=4, // Same size as frame buffer, or next lower power of 2 if we can't do that. |
|
RT_SIZE_OFFSCREEN=5, // Target of specified size, don't mess with dimensions |
|
RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP=6, // Same size as the frame buffer, rounded up if necessary for systems that can't do non-power of two textures. |
|
RT_SIZE_REPLAY_SCREENSHOT = 7, // Rounded down to power of 2, essentially... |
|
RT_SIZE_LITERAL = 8, // Use the size passed in. Don't clamp it to the frame buffer size. Really. |
|
RT_SIZE_LITERAL_PICMIP = 9 // Use the size passed in, don't clamp to the frame buffer size, but do apply picmip restrictions. |
|
|
|
}; |
|
|
|
typedef void (*MaterialBufferReleaseFunc_t)( ); |
|
typedef void (*MaterialBufferRestoreFunc_t)( int nChangeFlags ); // see RestoreChangeFlags_t |
|
typedef void (*ModeChangeCallbackFunc_t)( void ); |
|
|
|
typedef int VertexBufferHandle_t; |
|
typedef unsigned short MaterialHandle_t; |
|
|
|
DECLARE_POINTER_HANDLE( OcclusionQueryObjectHandle_t ); |
|
#define INVALID_OCCLUSION_QUERY_OBJECT_HANDLE ( (OcclusionQueryObjectHandle_t)0 ) |
|
|
|
class IMaterialProxyFactory; |
|
class ITexture; |
|
class IMaterialSystemHardwareConfig; |
|
class CShadowMgr; |
|
|
|
DECLARE_POINTER_HANDLE( MaterialLock_t ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
abstract_class IMaterialSystem : 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 |
|
|
|
|
|
//--------------------------------------------------------- |
|
// Material and texture management |
|
//--------------------------------------------------------- |
|
|
|
// Stop attempting to stream in textures in response to usage. Useful for phases such as loading or other explicit |
|
// operations that shouldn't take usage of textures as a signal to stream them in at full rez. |
|
virtual void SuspendTextureStreaming( ) = 0; |
|
virtual void ResumeTextureStreaming( ) = 0; |
|
|
|
// 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; |
|
|
|
// Creates a texture compositor template for use in later code. |
|
virtual bool AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc, int nTexCompositeTemplateFlags = 0 ) = 0; |
|
|
|
// Performs final verification of all compositor templates (after they've all been initially loaded). |
|
virtual bool VerifyTextureCompositorTemplates( ) = 0; |
|
virtual uint32_t GetShaderAPIGLTexture( ITexture *pTexture, int nFrame, int nTextureChannel ) = 0; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
abstract_class IMatRenderContext : public IRefCounted |
|
{ |
|
public: |
|
virtual void BeginRender() = 0; |
|
virtual void EndRender() = 0; |
|
|
|
virtual void Flush( bool flushHardware = false ) = 0; |
|
|
|
virtual void BindLocalCubemap( ITexture *pTexture ) = 0; |
|
|
|
// pass in an ITexture (that is build with "rendertarget" "1") or |
|
// pass in NULL for the regular backbuffer. |
|
virtual void SetRenderTarget( ITexture *pTexture ) = 0; |
|
virtual ITexture * GetRenderTarget( void ) = 0; |
|
|
|
virtual void GetRenderTargetDimensions( int &width, int &height) const = 0; |
|
|
|
// Bind a material is current for rendering. |
|
virtual void Bind( IMaterial *material, void *proxyData = 0 ) = 0; |
|
// Bind a lightmap page current for rendering. You only have to |
|
// do this for materials that require lightmaps. |
|
virtual void BindLightmapPage( int lightmapPageID ) = 0; |
|
|
|
// inputs are between 0 and 1 |
|
virtual void DepthRange( float zNear, float zFar ) = 0; |
|
|
|
virtual void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil = false ) = 0; |
|
|
|
// read to a unsigned char rgb image. |
|
virtual void ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat ) = 0; |
|
|
|
// Sets lighting |
|
virtual void SetAmbientLight( float r, float g, float b ) = 0; |
|
virtual void SetLight( int lightNum, const LightDesc_t& desc ) = 0; |
|
|
|
// The faces of the cube are specified in the same order as cubemap textures |
|
virtual void SetAmbientLightCube( Vector4D cube[6] ) = 0; |
|
|
|
// Blit the backbuffer to the framebuffer texture |
|
virtual void CopyRenderTargetToTexture( ITexture *pTexture ) = 0; |
|
|
|
// Set the current texture that is a copy of the framebuffer. |
|
virtual void SetFrameBufferCopyTexture( ITexture *pTexture, int textureIndex = 0 ) = 0; |
|
virtual ITexture *GetFrameBufferCopyTexture( int textureIndex ) = 0; |
|
|
|
// |
|
// end vertex array api |
|
// |
|
|
|
// matrix api |
|
virtual void MatrixMode( MaterialMatrixMode_t matrixMode ) = 0; |
|
virtual void PushMatrix( void ) = 0; |
|
virtual void PopMatrix( void ) = 0; |
|
virtual void LoadMatrix( VMatrix const& matrix ) = 0; |
|
virtual void LoadMatrix( matrix3x4_t const& matrix ) = 0; |
|
virtual void MultMatrix( VMatrix const& matrix ) = 0; |
|
virtual void MultMatrix( matrix3x4_t const& matrix ) = 0; |
|
virtual void MultMatrixLocal( VMatrix const& matrix ) = 0; |
|
virtual void MultMatrixLocal( matrix3x4_t const& matrix ) = 0; |
|
virtual void GetMatrix( MaterialMatrixMode_t matrixMode, VMatrix *matrix ) = 0; |
|
virtual void GetMatrix( MaterialMatrixMode_t matrixMode, matrix3x4_t *matrix ) = 0; |
|
virtual void LoadIdentity( void ) = 0; |
|
virtual void Ortho( double left, double top, double right, double bottom, double zNear, double zFar ) = 0; |
|
virtual void PerspectiveX( double fovx, double aspect, double zNear, double zFar ) = 0; |
|
virtual void PickMatrix( int x, int y, int width, int height ) = 0; |
|
virtual void Rotate( float angle, float x, float y, float z ) = 0; |
|
virtual void Translate( float x, float y, float z ) = 0; |
|
virtual void Scale( float x, float y, float z ) = 0; |
|
// end matrix api |
|
|
|
// Sets/gets the viewport |
|
virtual void Viewport( int x, int y, int width, int height ) = 0; |
|
virtual void GetViewport( int& x, int& y, int& width, int& height ) const = 0; |
|
|
|
// The cull mode |
|
virtual void CullMode( MaterialCullMode_t cullMode ) = 0; |
|
|
|
// end matrix api |
|
|
|
// This could easily be extended to a general user clip plane |
|
virtual void SetHeightClipMode( MaterialHeightClipMode_t nHeightClipMode ) = 0; |
|
// garymcthack : fog z is always used for heightclipz for now. |
|
virtual void SetHeightClipZ( float z ) = 0; |
|
|
|
// Fog methods... |
|
virtual void FogMode( MaterialFogMode_t fogMode ) = 0; |
|
virtual void FogStart( float fStart ) = 0; |
|
virtual void FogEnd( float fEnd ) = 0; |
|
virtual void SetFogZ( float fogZ ) = 0; |
|
virtual MaterialFogMode_t GetFogMode( void ) = 0; |
|
|
|
virtual void FogColor3f( float r, float g, float b ) = 0; |
|
virtual void FogColor3fv( float const* rgb ) = 0; |
|
virtual void FogColor3ub( unsigned char r, unsigned char g, unsigned char b ) = 0; |
|
virtual void FogColor3ubv( unsigned char const* rgb ) = 0; |
|
|
|
virtual void GetFogColor( unsigned char *rgb ) = 0; |
|
|
|
// Sets the number of bones for skinning |
|
virtual void SetNumBoneWeights( int numBones ) = 0; |
|
|
|
// Creates/destroys Mesh |
|
virtual IMesh* CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial = NULL ) = 0; |
|
virtual void DestroyStaticMesh( IMesh* mesh ) = 0; |
|
|
|
// Gets the dynamic mesh associated with the currently bound material |
|
// note that you've got to render the mesh before calling this function |
|
// a second time. Clients should *not* call DestroyStaticMesh on the mesh |
|
// returned by this call. |
|
// Use buffered = false if you want to not have the mesh be buffered, |
|
// but use it instead in the following pattern: |
|
// meshBuilder.Begin |
|
// meshBuilder.End |
|
// Draw partial |
|
// Draw partial |
|
// Draw partial |
|
// meshBuilder.Begin |
|
// meshBuilder.End |
|
// etc |
|
// Use Vertex or Index Override to supply a static vertex or index buffer |
|
// to use in place of the dynamic buffers. |
|
// |
|
// If you pass in a material in pAutoBind, it will automatically bind the |
|
// material. This can be helpful since you must bind the material you're |
|
// going to use BEFORE calling GetDynamicMesh. |
|
virtual IMesh* GetDynamicMesh( |
|
bool buffered = true, |
|
IMesh* pVertexOverride = 0, |
|
IMesh* pIndexOverride = 0, |
|
IMaterial *pAutoBind = 0 ) = 0; |
|
|
|
// ------------ New Vertex/Index Buffer interface ---------------------------- |
|
// Do we need support for bForceTempMesh and bSoftwareVertexShader? |
|
// I don't think we use bSoftwareVertexShader anymore. .need to look into bForceTempMesh. |
|
virtual IVertexBuffer *CreateStaticVertexBuffer( VertexFormat_t fmt, int nVertexCount, const char *pTextureBudgetGroup ) = 0; |
|
virtual IIndexBuffer *CreateStaticIndexBuffer( MaterialIndexFormat_t fmt, int nIndexCount, const char *pTextureBudgetGroup ) = 0; |
|
virtual void DestroyVertexBuffer( IVertexBuffer * ) = 0; |
|
virtual void DestroyIndexBuffer( IIndexBuffer * ) = 0; |
|
// Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams? |
|
virtual IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered = true ) = 0; |
|
virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered = true ) = 0; |
|
virtual void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions = 1 ) = 0; |
|
virtual void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes ) = 0; |
|
virtual void Draw( MaterialPrimitiveType_t primitiveType, int firstIndex, int numIndices ) = 0; |
|
// ------------ End ---------------------------- |
|
|
|
// Selection mode methods |
|
virtual int SelectionMode( bool selectionMode ) = 0; |
|
virtual void SelectionBuffer( unsigned int* pBuffer, int size ) = 0; |
|
virtual void ClearSelectionNames( ) = 0; |
|
virtual void LoadSelectionName( int name ) = 0; |
|
virtual void PushSelectionName( int name ) = 0; |
|
virtual void PopSelectionName() = 0; |
|
|
|
// Sets the Clear Color for ClearBuffer.... |
|
virtual void ClearColor3ub( unsigned char r, unsigned char g, unsigned char b ) = 0; |
|
virtual void ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) = 0; |
|
|
|
// Allows us to override the depth buffer setting of a material |
|
virtual void OverrideDepthEnable( bool bEnable, bool bDepthEnable ) = 0; |
|
|
|
// FIXME: This is a hack required for NVidia/XBox, can they fix in drivers? |
|
virtual void DrawScreenSpaceQuad( IMaterial* pMaterial ) = 0; |
|
|
|
// For debugging and building recording files. This will stuff a token into the recording file, |
|
// then someone doing a playback can watch for the token. |
|
virtual void SyncToken( const char *pToken ) = 0; |
|
|
|
// FIXME: REMOVE THIS FUNCTION! |
|
// The only reason why it's not gone is because we're a week from ship when I found the bug in it |
|
// and everything's tuned to use it. |
|
// It's returning values which are 2x too big (it's returning sphere diameter x2) |
|
// Use ComputePixelDiameterOfSphere below in all new code instead. |
|
virtual float ComputePixelWidthOfSphere( const Vector& origin, float flRadius ) = 0; |
|
|
|
// |
|
// Occlusion query support |
|
// |
|
|
|
// Allocate and delete query objects. |
|
virtual OcclusionQueryObjectHandle_t CreateOcclusionQueryObject( void ) = 0; |
|
virtual void DestroyOcclusionQueryObject( OcclusionQueryObjectHandle_t ) = 0; |
|
|
|
// Bracket drawing with begin and end so that we can get counts next frame. |
|
virtual void BeginOcclusionQueryDrawing( OcclusionQueryObjectHandle_t ) = 0; |
|
virtual void EndOcclusionQueryDrawing( OcclusionQueryObjectHandle_t ) = 0; |
|
|
|
// Get the number of pixels rendered between begin and end on an earlier frame. |
|
// Calling this in the same frame is a huge perf hit! |
|
virtual int OcclusionQuery_GetNumPixelsRendered( OcclusionQueryObjectHandle_t ) = 0; |
|
|
|
virtual void SetFlashlightMode( bool bEnable ) = 0; |
|
|
|
virtual void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture ) = 0; |
|
|
|
// Gets the current height clip mode |
|
virtual MaterialHeightClipMode_t GetHeightClipMode( ) = 0; |
|
|
|
// This returns the diameter of the sphere in pixels based on |
|
// the current model, view, + projection matrices and viewport. |
|
virtual float ComputePixelDiameterOfSphere( const Vector& vecAbsOrigin, float flRadius ) = 0; |
|
|
|
// By default, the material system applies the VIEW and PROJECTION matrices to the user clip |
|
// planes (which are specified in world space) to generate projection-space user clip planes |
|
// Occasionally (for the particle system in hl2, for example), we want to override that |
|
// behavior and explictly specify a ViewProj transform for user clip planes |
|
virtual void EnableUserClipTransformOverride( bool bEnable ) = 0; |
|
virtual void UserClipTransform( const VMatrix &worldToView ) = 0; |
|
|
|
virtual bool GetFlashlightMode() const = 0; |
|
|
|
// Used to make the handle think it's never had a successful query before |
|
virtual void ResetOcclusionQueryObject( OcclusionQueryObjectHandle_t ) = 0; |
|
|
|
// FIXME: Remove |
|
virtual void Unused3() {} |
|
|
|
// Creates/destroys morph data associated w/ a particular material |
|
virtual IMorph *CreateMorph( MorphFormat_t format, const char *pDebugName ) = 0; |
|
virtual void DestroyMorph( IMorph *pMorph ) = 0; |
|
|
|
// Binds the morph data for use in rendering |
|
virtual void BindMorph( IMorph *pMorph ) = 0; |
|
|
|
// Sets flexweights for rendering |
|
virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights ) = 0; |
|
|
|
// FIXME: Remove |
|
virtual void Unused4() {}; |
|
virtual void Unused5() {}; |
|
virtual void Unused6() {}; |
|
virtual void Unused7() {}; |
|
virtual void Unused8() {}; |
|
|
|
// Read w/ stretch to a host-memory buffer |
|
virtual void ReadPixelsAndStretch( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pBuffer, ImageFormat dstFormat, int nDstStride ) = 0; |
|
|
|
// Gets the window size |
|
virtual void GetWindowSize( int &width, int &height ) const = 0; |
|
|
|
// This function performs a texture map from one texture map to the render destination, doing |
|
// all the necessary pixel/texel coordinate fix ups. fractional values can be used for the |
|
// src_texture coordinates to get linear sampling - integer values should produce 1:1 mappings |
|
// for non-scaled operations. |
|
virtual void DrawScreenSpaceRectangle( |
|
IMaterial *pMaterial, |
|
int destx, int desty, |
|
int width, int height, |
|
float src_texture_x0, float src_texture_y0, // which texel you want to appear at |
|
// destx/y |
|
float src_texture_x1, float src_texture_y1, // which texel you want to appear at |
|
// destx+width-1, desty+height-1 |
|
int src_texture_width, int src_texture_height, // needed for fixup |
|
void *pClientRenderable = NULL, |
|
int nXDice = 1, |
|
int nYDice = 1 )=0; |
|
|
|
virtual void LoadBoneMatrix( int boneIndex, const matrix3x4_t& matrix ) = 0; |
|
|
|
// This version will push the current rendertarget + current viewport onto the stack |
|
virtual void PushRenderTargetAndViewport( ) = 0; |
|
|
|
// This version will push a new rendertarget + a maximal viewport for that rendertarget onto the stack |
|
virtual void PushRenderTargetAndViewport( ITexture *pTexture ) = 0; |
|
|
|
// This version will push a new rendertarget + a specified viewport onto the stack |
|
virtual void PushRenderTargetAndViewport( ITexture *pTexture, int nViewX, int nViewY, int nViewW, int nViewH ) = 0; |
|
|
|
// This version will push a new rendertarget + a specified viewport onto the stack |
|
virtual void PushRenderTargetAndViewport( ITexture *pTexture, ITexture *pDepthTexture, int nViewX, int nViewY, int nViewW, int nViewH ) = 0; |
|
|
|
// This will pop a rendertarget + viewport |
|
virtual void PopRenderTargetAndViewport( void ) = 0; |
|
|
|
// Binds a particular texture as the current lightmap |
|
virtual void BindLightmapTexture( ITexture *pLightmapTexture ) = 0; |
|
|
|
// Blit a subrect of the current render target to another texture |
|
virtual void CopyRenderTargetToTextureEx( ITexture *pTexture, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect = NULL ) = 0; |
|
virtual void CopyTextureToRenderTargetEx( int nRenderTargetID, ITexture *pTexture, Rect_t *pSrcRect, Rect_t *pDstRect = NULL ) = 0; |
|
|
|
// Special off-center perspective matrix for DoF, MSAA jitter and poster rendering |
|
virtual void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right ) = 0; |
|
|
|
// Rendering parameters control special drawing modes withing the material system, shader |
|
// system, shaders, and engine. renderparm.h has their definitions. |
|
virtual void SetFloatRenderingParameter(int parm_number, float value) = 0; |
|
virtual void SetIntRenderingParameter(int parm_number, int value) = 0; |
|
virtual void SetVectorRenderingParameter(int parm_number, Vector const &value) = 0; |
|
|
|
// stencil buffer operations. |
|
virtual void SetStencilEnable(bool onoff) = 0; |
|
virtual void SetStencilFailOperation(StencilOperation_t op) = 0; |
|
virtual void SetStencilZFailOperation(StencilOperation_t op) = 0; |
|
virtual void SetStencilPassOperation(StencilOperation_t op) = 0; |
|
virtual void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn) = 0; |
|
virtual void SetStencilReferenceValue(int ref) = 0; |
|
virtual void SetStencilTestMask(uint32 msk) = 0; |
|
virtual void SetStencilWriteMask(uint32 msk) = 0; |
|
virtual void ClearStencilBufferRectangle(int xmin, int ymin, int xmax, int ymax,int value) =0; |
|
|
|
virtual void SetRenderTargetEx( int nRenderTargetID, ITexture *pTexture ) = 0; |
|
|
|
// rendering clip planes, beware that only the most recently pushed plane will actually be used in a sizeable chunk of hardware configurations |
|
// and that changes to the clip planes mid-frame while UsingFastClipping() is true will result unresolvable depth inconsistencies |
|
virtual void PushCustomClipPlane( const float *pPlane ) = 0; |
|
virtual void PopCustomClipPlane( void ) = 0; |
|
|
|
// Returns the number of vertices + indices we can render using the dynamic mesh |
|
// Passing true in the second parameter will return the max # of vertices + indices |
|
// we can use before a flush is provoked and may return different values |
|
// if called multiple times in succession. |
|
// Passing false into the second parameter will return |
|
// the maximum possible vertices + indices that can be rendered in a single batch |
|
virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices ) = 0; |
|
|
|
// Returns the max possible vertices + indices to render in a single draw call |
|
virtual int GetMaxVerticesToRender( IMaterial *pMaterial ) = 0; |
|
virtual int GetMaxIndicesToRender( ) = 0; |
|
virtual void DisableAllLocalLights() = 0; |
|
virtual int CompareMaterialCombos( IMaterial *pMaterial1, IMaterial *pMaterial2, int lightMapID1, int lightMapID2 ) = 0; |
|
|
|
virtual IMesh *GetFlexMesh() = 0; |
|
|
|
virtual void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture ) = 0; |
|
|
|
// Returns the currently bound local cubemap |
|
virtual ITexture *GetLocalCubemap( ) = 0; |
|
|
|
// This is a version of clear buffers which will only clear the buffer at pixels which pass the stencil test |
|
virtual void ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth ) = 0; |
|
|
|
//enables/disables all entered clipping planes, returns the input from the last time it was called. |
|
virtual bool EnableClipping( bool bEnable ) = 0; |
|
|
|
//get fog distances entered with FogStart(), FogEnd(), and SetFogZ() |
|
virtual void GetFogDistances( float *fStart, float *fEnd, float *fFogZ ) = 0; |
|
|
|
// Hooks for firing PIX events from outside the Material System... |
|
virtual void BeginPIXEvent( unsigned long color, const char *szName ) = 0; |
|
virtual void EndPIXEvent() = 0; |
|
virtual void SetPIXMarker( unsigned long color, const char *szName ) = 0; |
|
|
|
// Batch API |
|
// from changelist 166623: |
|
// - replaced obtuse material system batch usage with an explicit and easier to thread API |
|
virtual void BeginBatch( IMesh* pIndices ) = 0; |
|
virtual void BindBatch( IMesh* pVertices, IMaterial *pAutoBind = NULL ) = 0; |
|
virtual void DrawBatch(int firstIndex, int numIndices ) = 0; |
|
virtual void EndBatch() = 0; |
|
|
|
// Raw access to the call queue, which can be NULL if not in a queued mode |
|
virtual ICallQueue *GetCallQueue() = 0; |
|
|
|
// Returns the world-space camera position |
|
virtual void GetWorldSpaceCameraPosition( Vector *pCameraPos ) = 0; |
|
virtual void GetWorldSpaceCameraVectors( Vector *pVecForward, Vector *pVecRight, Vector *pVecUp ) = 0; |
|
|
|
// Tone mapping |
|
virtual void ResetToneMappingScale( float monoscale) = 0; // set scale to monoscale instantly with no chasing |
|
virtual void SetGoalToneMappingScale( float monoscale) = 0; // set scale to monoscale instantly with no chasing |
|
|
|
// call TurnOnToneMapping before drawing the 3d scene to get the proper interpolated brightness |
|
// value set. |
|
virtual void TurnOnToneMapping() = 0; |
|
|
|
// Set a linear vector color scale for all 3D rendering. |
|
// A value of [1.0f, 1.0f, 1.0f] should match non-tone-mapped rendering. |
|
virtual void SetToneMappingScaleLinear( const Vector &scale ) = 0; |
|
|
|
virtual Vector GetToneMappingScaleLinear( void ) = 0; |
|
virtual void SetShadowDepthBiasFactors( float fSlopeScaleDepthBias, float fDepthBias ) = 0; |
|
|
|
// Apply stencil operations to every pixel on the screen without disturbing depth or color buffers |
|
virtual void PerformFullScreenStencilOperation( void ) = 0; |
|
|
|
// Sets lighting origin for the current model (needed to convert directional lights to points) |
|
virtual void SetLightingOrigin( Vector vLightingOrigin ) = 0; |
|
|
|
// Set scissor rect for rendering |
|
virtual void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor ) = 0; |
|
|
|
// Methods used to build the morph accumulator that is read from when HW morph<ing is enabled. |
|
virtual void BeginMorphAccumulation() = 0; |
|
virtual void EndMorphAccumulation() = 0; |
|
virtual void AccumulateMorph( IMorph* pMorph, int nMorphCount, const MorphWeight_t* pWeights ) = 0; |
|
|
|
virtual void PushDeformation( DeformationBase_t const *Deformation ) = 0; |
|
virtual void PopDeformation( ) = 0; |
|
virtual int GetNumActiveDeformations() const = 0; |
|
|
|
virtual bool GetMorphAccumulatorTexCoord( Vector2D *pTexCoord, IMorph *pMorph, int nVertex ) = 0; |
|
|
|
// Version of get dynamic mesh that specifies a specific vertex format |
|
virtual IMesh* GetDynamicMeshEx( VertexFormat_t vertexFormat, bool bBuffered = true, |
|
IMesh* pVertexOverride = 0, IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 ) = 0; |
|
|
|
virtual void FogMaxDensity( float flMaxDensity ) = 0; |
|
|
|
#if defined( _X360 ) |
|
//Seems best to expose GPR allocation to scene rendering code. 128 total to split between vertex/pixel shaders (pixel will be set to 128 - vertex). Minimum value of 16. More GPR's = more threads. |
|
virtual void PushVertexShaderGPRAllocation( int iVertexShaderCount = 64 ) = 0; |
|
virtual void PopVertexShaderGPRAllocation( void ) = 0; |
|
#endif |
|
|
|
virtual IMaterial *GetCurrentMaterial() = 0; |
|
virtual int GetCurrentNumBones() const = 0; |
|
virtual void *GetCurrentProxy() = 0; |
|
|
|
// Color correction related methods.. |
|
// Client cannot call IColorCorrectionSystem directly because it is not thread-safe |
|
// FIXME: Make IColorCorrectionSystem threadsafe? |
|
virtual void EnableColorCorrection( bool bEnable ) = 0; |
|
virtual ColorCorrectionHandle_t AddLookup( const char *pName ) = 0; |
|
virtual bool RemoveLookup( ColorCorrectionHandle_t handle ) = 0; |
|
virtual void LockLookup( ColorCorrectionHandle_t handle ) = 0; |
|
virtual void LoadLookup( ColorCorrectionHandle_t handle, const char *pLookupName ) = 0; |
|
virtual void UnlockLookup( ColorCorrectionHandle_t handle ) = 0; |
|
virtual void SetLookupWeight( ColorCorrectionHandle_t handle, float flWeight ) = 0; |
|
virtual void ResetLookupWeights( ) = 0; |
|
virtual void SetResetable( ColorCorrectionHandle_t handle, bool bResetable ) = 0; |
|
|
|
//There are some cases where it's simply not reasonable to update the full screen depth texture (mostly on PC). |
|
//Use this to mark it as invalid and use a dummy texture for depth reads. |
|
virtual void SetFullScreenDepthTextureValidityFlag( bool bIsValid ) = 0; |
|
|
|
// A special path used to tick the front buffer while loading on the 360 |
|
virtual void SetNonInteractivePacifierTexture( ITexture *pTexture, float flNormalizedX, float flNormalizedY, float flNormalizedSize ) = 0; |
|
virtual void SetNonInteractiveTempFullscreenBuffer( ITexture *pTexture, MaterialNonInteractiveMode_t mode ) = 0; |
|
virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode ) = 0; |
|
virtual void RefreshFrontBufferNonInteractive() = 0; |
|
// Allocates temp render data. Renderdata goes out of scope at frame end in multicore |
|
// Renderdata goes out of scope after refcount goes to zero in singlecore. |
|
// Locking/unlocking increases + decreases refcount |
|
virtual void * LockRenderData( int nSizeInBytes ) = 0; |
|
virtual void UnlockRenderData( void *pData ) = 0; |
|
|
|
// Typed version. If specified, pSrcData is copied into the locked memory. |
|
template< class E > E* LockRenderDataTyped( int nCount, const E* pSrcData = NULL ); |
|
|
|
// Temp render data gets immediately freed after it's all unlocked in single core. |
|
// This prevents it from being freed |
|
virtual void AddRefRenderData() = 0; |
|
virtual void ReleaseRenderData() = 0; |
|
|
|
// Returns whether a pointer is render data. NOTE: passing NULL returns true |
|
virtual bool IsRenderData( const void *pData ) const = 0; |
|
virtual void PrintfVA( char *fmt, va_list vargs ) = 0; |
|
virtual void Printf( PRINTF_FORMAT_STRING const char *fmt, ... ) = 0; |
|
virtual float Knob( char *knobname, float *setvalue = NULL ) = 0; |
|
// Allows us to override the alpha write setting of a material |
|
virtual void OverrideAlphaWriteEnable( bool bEnable, bool bAlphaWriteEnable ) = 0; |
|
virtual void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable ) = 0; |
|
|
|
virtual void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ) = 0; |
|
|
|
// Create a texture from the specified src render target, then call pRecipient->OnAsyncCreateComplete from the main thread. |
|
// The texture will be created using the destination format, and will optionally have mipmaps generated. |
|
// In case of error, the provided callback function will be called with the error texture. |
|
virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs ) = 0; |
|
}; |
|
|
|
template< class E > inline E* IMatRenderContext::LockRenderDataTyped( int nCount, const E* pSrcData ) |
|
{ |
|
E *pDstData = (E*)LockRenderData( nCount*sizeof(E) ); |
|
if ( pSrcData && pDstData ) |
|
memutils::copy( pDstData, pSrcData, nCount ); |
|
return pDstData; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Utility class for addreffing/releasing render data (prevents freeing on single core) |
|
//----------------------------------------------------------------------------- |
|
class CMatRenderDataReference |
|
{ |
|
public: |
|
CMatRenderDataReference(); |
|
CMatRenderDataReference( IMatRenderContext* pRenderContext ); |
|
~CMatRenderDataReference(); |
|
void Lock( IMatRenderContext *pRenderContext ); |
|
void Release(); |
|
|
|
private: |
|
IMatRenderContext *m_pRenderContext; |
|
}; |
|
|
|
|
|
inline CMatRenderDataReference::CMatRenderDataReference() |
|
{ |
|
m_pRenderContext = NULL; |
|
} |
|
|
|
inline CMatRenderDataReference::CMatRenderDataReference( IMatRenderContext* pRenderContext ) |
|
{ |
|
m_pRenderContext = NULL; |
|
Lock( pRenderContext ); |
|
} |
|
|
|
inline CMatRenderDataReference::~CMatRenderDataReference() |
|
{ |
|
Release(); |
|
} |
|
|
|
inline void CMatRenderDataReference::Lock( IMatRenderContext* pRenderContext ) |
|
{ |
|
if ( !m_pRenderContext ) |
|
{ |
|
m_pRenderContext = pRenderContext; |
|
m_pRenderContext->AddRefRenderData( ); |
|
} |
|
} |
|
|
|
inline void CMatRenderDataReference::Release() |
|
{ |
|
if ( m_pRenderContext ) |
|
{ |
|
m_pRenderContext->ReleaseRenderData( ); |
|
m_pRenderContext = NULL; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Utility class for locking/unlocking render data |
|
//----------------------------------------------------------------------------- |
|
template< typename E > |
|
class CMatRenderData |
|
{ |
|
public: |
|
CMatRenderData( IMatRenderContext* pRenderContext ); |
|
CMatRenderData( IMatRenderContext* pRenderContext, int nCount, const E *pSrcData = NULL ); |
|
~CMatRenderData(); |
|
E* Lock( int nCount, const E* pSrcData = NULL ); |
|
void Release(); |
|
bool IsValid() const; |
|
const E* Base() const; |
|
E* Base(); |
|
const E& operator[]( int i ) const; |
|
E& operator[]( int i ); |
|
|
|
private: |
|
IMatRenderContext* m_pRenderContext; |
|
E *m_pRenderData; |
|
int m_nCount; |
|
bool m_bNeedsUnlock; |
|
}; |
|
|
|
template< typename E > |
|
inline CMatRenderData<E>::CMatRenderData( IMatRenderContext* pRenderContext ) |
|
{ |
|
m_pRenderContext = pRenderContext; |
|
m_nCount = 0; |
|
m_pRenderData = 0; |
|
m_bNeedsUnlock = false; |
|
} |
|
|
|
template< typename E > |
|
inline CMatRenderData<E>::CMatRenderData( IMatRenderContext* pRenderContext, int nCount, const E* pSrcData ) |
|
{ |
|
m_pRenderContext = pRenderContext; |
|
m_nCount = 0; |
|
m_pRenderData = 0; |
|
m_bNeedsUnlock = false; |
|
Lock( nCount, pSrcData ); |
|
} |
|
|
|
template< typename E > |
|
inline CMatRenderData<E>::~CMatRenderData() |
|
{ |
|
Release(); |
|
} |
|
|
|
template< typename E > |
|
inline bool CMatRenderData<E>::IsValid() const |
|
{ |
|
return m_pRenderData != NULL; |
|
} |
|
|
|
template< typename E > |
|
inline E* CMatRenderData<E>::Lock( int nCount, const E* pSrcData ) |
|
{ |
|
m_nCount = nCount; |
|
if ( pSrcData && m_pRenderContext->IsRenderData( pSrcData ) ) |
|
{ |
|
// Yes, we're const-casting away, but that should be ok since |
|
// the src data is render data |
|
m_pRenderData = const_cast<E*>( pSrcData ); |
|
m_pRenderContext->AddRefRenderData(); |
|
m_bNeedsUnlock = false; |
|
return m_pRenderData; |
|
} |
|
m_pRenderData = m_pRenderContext->LockRenderDataTyped<E>( nCount, pSrcData ); |
|
m_bNeedsUnlock = true; |
|
return m_pRenderData; |
|
} |
|
|
|
template< typename E > |
|
inline void CMatRenderData<E>::Release() |
|
{ |
|
if ( m_pRenderContext && m_pRenderData ) |
|
{ |
|
if ( m_bNeedsUnlock ) |
|
{ |
|
m_pRenderContext->UnlockRenderData( m_pRenderData ); |
|
} |
|
else |
|
{ |
|
m_pRenderContext->ReleaseRenderData(); |
|
} |
|
} |
|
m_pRenderData = NULL; |
|
m_nCount = 0; |
|
m_bNeedsUnlock = false; |
|
} |
|
|
|
template< typename E > |
|
inline E* CMatRenderData<E>::Base() |
|
{ |
|
return m_pRenderData; |
|
} |
|
|
|
template< typename E > |
|
inline const E* CMatRenderData<E>::Base() const |
|
{ |
|
return m_pRenderData; |
|
} |
|
|
|
template< typename E > |
|
inline E& CMatRenderData<E>::operator[]( int i ) |
|
{ |
|
Assert( ( i >= 0 ) && ( i < m_nCount ) ); |
|
return m_pRenderData[i]; |
|
} |
|
|
|
template< typename E > |
|
inline const E& CMatRenderData<E>::operator[]( int i ) const |
|
{ |
|
Assert( ( i >= 0 ) && ( i < m_nCount ) ); |
|
return m_pRenderData[i]; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
class CMatRenderContextPtr : public CRefPtr<IMatRenderContext> |
|
{ |
|
typedef CRefPtr<IMatRenderContext> BaseClass; |
|
public: |
|
CMatRenderContextPtr() = default; |
|
CMatRenderContextPtr( IMatRenderContext *pInit ) : BaseClass( pInit ) { if ( BaseClass::m_pObject ) BaseClass::m_pObject->BeginRender(); } |
|
CMatRenderContextPtr( IMaterialSystem *pFrom ) : BaseClass( pFrom->GetRenderContext() ) { if ( BaseClass::m_pObject ) BaseClass::m_pObject->BeginRender(); } |
|
~CMatRenderContextPtr() { if ( BaseClass::m_pObject ) BaseClass::m_pObject->EndRender(); } |
|
|
|
IMatRenderContext *operator=( IMatRenderContext *p ) { if ( p ) p->BeginRender(); return BaseClass::operator=( p ); } |
|
|
|
void SafeRelease() { if ( BaseClass::m_pObject ) BaseClass::m_pObject->EndRender(); BaseClass::SafeRelease(); } |
|
void AssignAddRef( IMatRenderContext *pFrom ) { if ( BaseClass::m_pObject ) BaseClass::m_pObject->EndRender(); BaseClass::AssignAddRef( pFrom ); BaseClass::m_pObject->BeginRender(); } |
|
|
|
void GetFrom( IMaterialSystem *pFrom ) { AssignAddRef( pFrom->GetRenderContext() ); } |
|
|
|
|
|
private: |
|
CMatRenderContextPtr( const CMatRenderContextPtr &from ); |
|
void operator=( const CMatRenderContextPtr &from ); |
|
|
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Helper class for begin/end of pix event via constructor/destructor |
|
//----------------------------------------------------------------------------- |
|
#define PIX_VALVE_ORANGE 0xFFF5940F |
|
|
|
class PIXEvent |
|
{ |
|
public: |
|
PIXEvent( IMatRenderContext *pRenderContext, const char *szName, unsigned long color = PIX_VALVE_ORANGE ) |
|
{ |
|
m_pRenderContext = pRenderContext; |
|
Assert( m_pRenderContext ); |
|
Assert( szName ); |
|
m_pRenderContext->BeginPIXEvent( color, szName ); |
|
} |
|
~PIXEvent() |
|
{ |
|
m_pRenderContext->EndPIXEvent(); |
|
} |
|
private: |
|
IMatRenderContext *m_pRenderContext; |
|
}; |
|
|
|
|
|
// Also be sure to enable PIX_INSTRUMENTATION in shaderdevicedx8.h |
|
//#define PIX_ENABLE 1 // set this to 1 and build engine/studiorender to enable pix events in the engine |
|
|
|
#if PIX_ENABLE |
|
# define PIXEVENT PIXEvent _pixEvent |
|
#else |
|
# define PIXEVENT |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
#ifdef MATERIAL_SYSTEM_DEBUG_CALL_QUEUE |
|
#include "tier1/callqueue.h" |
|
#include "tier1/fmtstr.h" |
|
static void DoMatSysQueueMark( IMaterialSystem *pMaterialSystem, const char *psz ) |
|
{ |
|
CMatRenderContextPtr pRenderContext( pMaterialSystem ); |
|
if ( pRenderContext->GetCallQueue() ) |
|
pRenderContext->GetCallQueue()->QueueCall( Plat_DebugString, CUtlEnvelope<const char *>( psz ) ); |
|
} |
|
|
|
#define MatSysQueueMark( pMaterialSystem, ...) DoMatSysQueueMark( pMaterialSystem, CFmtStr( __VA_ARGS__ ) ) |
|
#else |
|
#define MatSysQueueMark( msg, ...) ((void)0) |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
extern IMaterialSystem *materials; |
|
extern IMaterialSystem *g_pMaterialSystem; |
|
|
|
#endif // IMATERIALSYSTEM_H
|
|
|