391 lines
15 KiB
C++
391 lines
15 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef ISHADERDEVICE_H
|
|
#define ISHADERDEVICE_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier1/interface.h"
|
|
#include "appframework/IAppSystem.h"
|
|
#include "bitmap/imageformat.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "shaderapi/ishaderdynamic.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
struct MaterialAdapterInfo_t;
|
|
class IMesh;
|
|
class KeyValues;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Describes how to set the mode
|
|
//-----------------------------------------------------------------------------
|
|
#define SHADER_DISPLAY_MODE_VERSION 1
|
|
|
|
struct ShaderDisplayMode_t
|
|
{
|
|
ShaderDisplayMode_t() { memset( this, 0, sizeof(ShaderDisplayMode_t) ); m_nVersion = SHADER_DISPLAY_MODE_VERSION; }
|
|
|
|
int m_nVersion;
|
|
int m_nWidth; // 0 when running windowed means use desktop resolution
|
|
int m_nHeight;
|
|
ImageFormat m_Format; // use ImageFormats (ignored for windowed mode)
|
|
int m_nRefreshRateNumerator; // Refresh rate. Use 0 in numerator + denominator for a default setting.
|
|
int m_nRefreshRateDenominator; // Refresh rate = numerator / denominator.
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Describes how to set the device
|
|
//-----------------------------------------------------------------------------
|
|
#define SHADER_DEVICE_INFO_VERSION 1
|
|
|
|
struct ShaderDeviceInfo_t
|
|
{
|
|
ShaderDeviceInfo_t() { memset( this, 0, sizeof(ShaderDeviceInfo_t) ); m_nVersion = SHADER_DEVICE_INFO_VERSION; m_DisplayMode.m_nVersion = SHADER_DISPLAY_MODE_VERSION; }
|
|
|
|
int m_nVersion;
|
|
ShaderDisplayMode_t m_DisplayMode;
|
|
int m_nBackBufferCount; // valid values are 1 or 2 [2 results in triple buffering]
|
|
int m_nAASamples; // Number of AA samples to use
|
|
int m_nAAQuality; // AA quality level
|
|
int m_nDXLevel; // 0 means use recommended DX level for this adapter
|
|
int m_nWindowedSizeLimitWidth; // Used if m_bLimitWindowedSize is set, defines max bounds for the back buffer
|
|
int m_nWindowedSizeLimitHeight;
|
|
|
|
bool m_bWindowed : 1;
|
|
bool m_bResizing : 1; // Only is meaningful when using windowed mode; means the window can be resized.
|
|
bool m_bUseStencil : 1;
|
|
bool m_bLimitWindowedSize : 1; // In windowed mode, should we prevent the back buffer from getting too large?
|
|
bool m_bWaitForVSync : 1; // Would we not present until vsync?
|
|
bool m_bScaleToOutputResolution : 1; // 360 ONLY: sets up hardware scaling
|
|
bool m_bProgressive : 1; // 360 ONLY: interlaced or progressive
|
|
bool m_bUsingMultipleWindows : 1; // Forces D3DPresent to use _COPY instead
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Info for non-interactive mode
|
|
//-----------------------------------------------------------------------------
|
|
struct ShaderNonInteractiveInfo_t
|
|
{
|
|
ShaderAPITextureHandle_t m_hTempFullscreenTexture;
|
|
int m_nPacifierCount;
|
|
ShaderAPITextureHandle_t m_pPacifierTextures[64];
|
|
float m_flNormalizedX;
|
|
float m_flNormalizedY;
|
|
float m_flNormalizedSize;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For vertex/index buffers. What type is it?
|
|
// (NOTE: mirror this with a similarly named enum at the material system level for backwards compatability.)
|
|
//-----------------------------------------------------------------------------
|
|
enum ShaderBufferType_t
|
|
{
|
|
SHADER_BUFFER_TYPE_STATIC = 0,
|
|
SHADER_BUFFER_TYPE_DYNAMIC,
|
|
SHADER_BUFFER_TYPE_STATIC_TEMP,
|
|
SHADER_BUFFER_TYPE_DYNAMIC_TEMP,
|
|
|
|
SHADER_BUFFER_TYPE_COUNT,
|
|
};
|
|
|
|
inline bool IsDynamicBufferType( ShaderBufferType_t type )
|
|
{
|
|
return ( ( type == SHADER_BUFFER_TYPE_DYNAMIC ) || ( type == SHADER_BUFFER_TYPE_DYNAMIC_TEMP ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Handle to a vertex, pixel, and geometry shader
|
|
//-----------------------------------------------------------------------------
|
|
DECLARE_POINTER_HANDLE( VertexShaderHandle_t );
|
|
DECLARE_POINTER_HANDLE( GeometryShaderHandle_t );
|
|
DECLARE_POINTER_HANDLE( PixelShaderHandle_t );
|
|
|
|
#define VERTEX_SHADER_HANDLE_INVALID ( (VertexShaderHandle_t)0 )
|
|
#define GEOMETRY_SHADER_HANDLE_INVALID ( (GeometryShaderHandle_t)0 )
|
|
#define PIXEL_SHADER_HANDLE_INVALID ( (PixelShaderHandle_t)0 )
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A shader buffer returns a block of memory which must be released when done with it
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class IShaderBuffer
|
|
{
|
|
public:
|
|
virtual size_t GetSize() const = 0;
|
|
virtual const void* GetBits() const = 0;
|
|
virtual void Release() = 0;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Mode chance callback
|
|
//-----------------------------------------------------------------------------
|
|
typedef void (*ShaderModeChangeCallbackFunc_t)( void );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Methods related to discovering and selecting devices
|
|
//-----------------------------------------------------------------------------
|
|
#define SHADER_DEVICE_MGR_INTERFACE_VERSION "ShaderDeviceMgr001"
|
|
abstract_class IShaderDeviceMgr : public IAppSystem
|
|
{
|
|
public:
|
|
// Gets the number of adapters...
|
|
virtual int GetAdapterCount() const = 0;
|
|
|
|
// Returns info about each adapter
|
|
virtual void GetAdapterInfo( int nAdapter, MaterialAdapterInfo_t& info ) const = 0;
|
|
|
|
// Gets recommended congifuration for a particular adapter at a particular dx level
|
|
virtual bool GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pConfiguration ) = 0;
|
|
|
|
// Returns the number of modes
|
|
virtual int GetModeCount( int nAdapter ) const = 0;
|
|
|
|
// Returns mode information..
|
|
virtual void GetModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter, int nMode ) const = 0;
|
|
|
|
// Returns the current mode info for the requested adapter
|
|
virtual void GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const = 0;
|
|
|
|
// Initialization, shutdown
|
|
virtual bool SetAdapter( int nAdapter, int nFlags ) = 0;
|
|
|
|
// Sets the mode
|
|
// Use the returned factory to get at an IShaderDevice and an IShaderRender
|
|
// and any other interfaces we decide to create.
|
|
// A returned factory of NULL indicates the mode was not set properly.
|
|
virtual CreateInterfaceFn SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode ) = 0;
|
|
|
|
// Installs a callback to get called
|
|
virtual void AddModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) = 0;
|
|
virtual void RemoveModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) = 0;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Methods related to control of the device
|
|
//-----------------------------------------------------------------------------
|
|
#define SHADER_DEVICE_INTERFACE_VERSION "ShaderDevice001"
|
|
abstract_class IShaderDevice
|
|
{
|
|
public:
|
|
// Releases/reloads resources when other apps want some memory
|
|
virtual void ReleaseResources() = 0;
|
|
virtual void ReacquireResources() = 0;
|
|
|
|
// returns the backbuffer format and dimensions
|
|
virtual ImageFormat GetBackBufferFormat() const = 0;
|
|
virtual void GetBackBufferDimensions( int& width, int& height ) const = 0;
|
|
|
|
// Returns the current adapter in use
|
|
virtual int GetCurrentAdapter() const = 0;
|
|
|
|
// Are we using graphics?
|
|
virtual bool IsUsingGraphics() const = 0;
|
|
|
|
// Use this to spew information about the 3D layer
|
|
virtual void SpewDriverInfo() const = 0;
|
|
|
|
// What's the bit depth of the stencil buffer?
|
|
virtual int StencilBufferBits() const = 0;
|
|
|
|
// Are we using a mode that uses MSAA
|
|
virtual bool IsAAEnabled() const = 0;
|
|
|
|
// Does a page flip
|
|
virtual void Present() = 0;
|
|
|
|
// Returns the window size
|
|
virtual void GetWindowSize( int &nWidth, int &nHeight ) const = 0;
|
|
|
|
// Gamma ramp control
|
|
virtual void SetHardwareGammaRamp( float fGamma, float fGammaTVRangeMin, float fGammaTVRangeMax, float fGammaTVExponent, bool bTVEnabled ) = 0;
|
|
|
|
// Creates/ destroys a child window
|
|
virtual bool AddView( void* hWnd ) = 0;
|
|
virtual void RemoveView( void* hWnd ) = 0;
|
|
|
|
// Activates a view
|
|
virtual void SetView( void* hWnd ) = 0;
|
|
|
|
// Shader compilation
|
|
virtual IShaderBuffer* CompileShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion ) = 0;
|
|
|
|
// Shader creation, destruction
|
|
virtual VertexShaderHandle_t CreateVertexShader( IShaderBuffer* pShaderBuffer ) = 0;
|
|
virtual void DestroyVertexShader( VertexShaderHandle_t hShader ) = 0;
|
|
virtual GeometryShaderHandle_t CreateGeometryShader( IShaderBuffer* pShaderBuffer ) = 0;
|
|
virtual void DestroyGeometryShader( GeometryShaderHandle_t hShader ) = 0;
|
|
virtual PixelShaderHandle_t CreatePixelShader( IShaderBuffer* pShaderBuffer ) = 0;
|
|
virtual void DestroyPixelShader( PixelShaderHandle_t hShader ) = 0;
|
|
|
|
// Utility methods to make shader creation simpler
|
|
// NOTE: For the utlbuffer version, use a binary buffer for a compiled shader
|
|
// and a text buffer for a source-code (.fxc) shader
|
|
VertexShaderHandle_t CreateVertexShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion );
|
|
VertexShaderHandle_t CreateVertexShader( CUtlBuffer &buf, const char *pShaderVersion = NULL );
|
|
GeometryShaderHandle_t CreateGeometryShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion );
|
|
GeometryShaderHandle_t CreateGeometryShader( CUtlBuffer &buf, const char *pShaderVersion = NULL );
|
|
PixelShaderHandle_t CreatePixelShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion );
|
|
PixelShaderHandle_t CreatePixelShader( CUtlBuffer &buf, const char *pShaderVersion = NULL );
|
|
|
|
// NOTE: Deprecated!! Use CreateVertexBuffer/CreateIndexBuffer instead
|
|
// Creates/destroys Mesh
|
|
virtual IMesh* CreateStaticMesh( VertexFormat_t vertexFormat, const char *pTextureBudgetGroup, IMaterial * pMaterial = NULL ) = 0;
|
|
virtual void DestroyStaticMesh( IMesh* mesh ) = 0;
|
|
|
|
// Creates/destroys static vertex + index buffers
|
|
virtual IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup ) = 0;
|
|
virtual void DestroyVertexBuffer( IVertexBuffer *pVertexBuffer ) = 0;
|
|
|
|
virtual IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup ) = 0;
|
|
virtual void DestroyIndexBuffer( IIndexBuffer *pIndexBuffer ) = 0;
|
|
|
|
// Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams?
|
|
virtual IVertexBuffer *GetDynamicVertexBuffer( int nStreamID, VertexFormat_t vertexFormat, bool bBuffered = true ) = 0;
|
|
virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered = true ) = 0;
|
|
|
|
// A special path used to tick the front buffer while loading on the 360
|
|
virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode, ShaderNonInteractiveInfo_t *pInfo = NULL ) = 0;
|
|
virtual void RefreshFrontBufferNonInteractive( ) = 0;
|
|
virtual void HandleThreadEvent( uint32 threadEvent ) = 0;
|
|
|
|
#ifdef DX_TO_GL_ABSTRACTION
|
|
virtual void DoStartupShaderPreloading( void ) = 0;
|
|
#endif
|
|
virtual char *GetDisplayDeviceName() = 0;
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper wrapper for IShaderBuffer for reading precompiled shader files
|
|
// NOTE: This is meant to be instanced on the stack; so don't call Release!
|
|
//-----------------------------------------------------------------------------
|
|
class CUtlShaderBuffer : public IShaderBuffer
|
|
{
|
|
public:
|
|
CUtlShaderBuffer( CUtlBuffer &buf ) : m_pBuf( &buf ) {}
|
|
|
|
virtual size_t GetSize() const
|
|
{
|
|
return m_pBuf->TellMaxPut();
|
|
}
|
|
|
|
virtual const void* GetBits() const
|
|
{
|
|
return m_pBuf->Base();
|
|
}
|
|
|
|
virtual void Release()
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
|
|
private:
|
|
CUtlBuffer *m_pBuf;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inline methods of IShaderDevice
|
|
//-----------------------------------------------------------------------------
|
|
inline VertexShaderHandle_t IShaderDevice::CreateVertexShader( CUtlBuffer &buf, const char *pShaderVersion )
|
|
{
|
|
// NOTE: Text buffers are assumed to have source-code shader files
|
|
// Binary buffers are assumed to have compiled shader files
|
|
if ( buf.IsText() )
|
|
{
|
|
Assert( pShaderVersion );
|
|
return CreateVertexShader( (const char *)buf.Base(), buf.TellMaxPut(), pShaderVersion );
|
|
}
|
|
|
|
CUtlShaderBuffer shaderBuffer( buf );
|
|
return CreateVertexShader( &shaderBuffer );
|
|
}
|
|
|
|
inline VertexShaderHandle_t IShaderDevice::CreateVertexShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion )
|
|
{
|
|
VertexShaderHandle_t hVertexShader = VERTEX_SHADER_HANDLE_INVALID;
|
|
IShaderBuffer* pShaderBuffer = CompileShader( pProgram, nBufLen, pShaderVersion );
|
|
if ( pShaderBuffer )
|
|
{
|
|
hVertexShader = CreateVertexShader( pShaderBuffer );
|
|
pShaderBuffer->Release();
|
|
}
|
|
return hVertexShader;
|
|
}
|
|
|
|
inline GeometryShaderHandle_t IShaderDevice::CreateGeometryShader( CUtlBuffer &buf, const char *pShaderVersion )
|
|
{
|
|
// NOTE: Text buffers are assumed to have source-code shader files
|
|
// Binary buffers are assumed to have compiled shader files
|
|
if ( buf.IsText() )
|
|
{
|
|
Assert( pShaderVersion );
|
|
return CreateGeometryShader( (const char *)buf.Base(), buf.TellMaxPut(), pShaderVersion );
|
|
}
|
|
|
|
CUtlShaderBuffer shaderBuffer( buf );
|
|
return CreateGeometryShader( &shaderBuffer );
|
|
}
|
|
|
|
inline GeometryShaderHandle_t IShaderDevice::CreateGeometryShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion )
|
|
{
|
|
GeometryShaderHandle_t hGeometryShader = GEOMETRY_SHADER_HANDLE_INVALID;
|
|
IShaderBuffer* pShaderBuffer = CompileShader( pProgram, nBufLen, pShaderVersion );
|
|
if ( pShaderBuffer )
|
|
{
|
|
hGeometryShader = CreateGeometryShader( pShaderBuffer );
|
|
pShaderBuffer->Release();
|
|
}
|
|
return hGeometryShader;
|
|
}
|
|
|
|
inline PixelShaderHandle_t IShaderDevice::CreatePixelShader( CUtlBuffer &buf, const char *pShaderVersion )
|
|
{
|
|
// NOTE: Text buffers are assumed to have source-code shader files
|
|
// Binary buffers are assumed to have compiled shader files
|
|
if ( buf.IsText() )
|
|
{
|
|
Assert( pShaderVersion );
|
|
return CreatePixelShader( (const char *)buf.Base(), buf.TellMaxPut(), pShaderVersion );
|
|
}
|
|
|
|
CUtlShaderBuffer shaderBuffer( buf );
|
|
return CreatePixelShader( &shaderBuffer );
|
|
}
|
|
|
|
inline PixelShaderHandle_t IShaderDevice::CreatePixelShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion )
|
|
{
|
|
PixelShaderHandle_t hPixelShader = PIXEL_SHADER_HANDLE_INVALID;
|
|
IShaderBuffer* pShaderBuffer = CompileShader( pProgram, nBufLen, pShaderVersion );
|
|
if ( pShaderBuffer )
|
|
{
|
|
hPixelShader = CreatePixelShader( pShaderBuffer );
|
|
pShaderBuffer->Release();
|
|
}
|
|
return hPixelShader;
|
|
}
|
|
|
|
|
|
#endif // ISHADERDEVICE_H
|