669 lines
29 KiB
C++
669 lines
29 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef ISHADERAPI_H
|
|
#define ISHADERAPI_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "materialsystem/deformations.h"
|
|
#include "mathlib/vector4d.h"
|
|
#include "shaderapi/IShaderDevice.h"
|
|
#include "shaderapi/ishaderdynamic.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class IShaderUtil;
|
|
class IFileSystem;
|
|
class CPixelWriter;
|
|
class CMeshBuilder;
|
|
struct MaterialVideoMode_t;
|
|
class IMesh;
|
|
class IVertexBuffer;
|
|
class IIndexBuffer;
|
|
struct MeshDesc_t;
|
|
enum MaterialCullMode_t;
|
|
class IDataCache;
|
|
struct MorphWeight_t;
|
|
class IVTFTexture;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This must match the definition in playback.cpp!
|
|
//-----------------------------------------------------------------------------
|
|
enum ShaderRenderTarget_t {
|
|
SHADER_RENDERTARGET_BACKBUFFER = -1,
|
|
SHADER_RENDERTARGET_DEPTHBUFFER = -1,
|
|
// GR - no RT, used to disable depth buffer
|
|
SHADER_RENDERTARGET_NONE = -2,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This must match the definition in playback.cpp!
|
|
//-----------------------------------------------------------------------------
|
|
typedef int ShaderAPITextureHandle_t;
|
|
#define INVALID_SHADERAPI_TEXTURE_HANDLE 0
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The state snapshot handle
|
|
//-----------------------------------------------------------------------------
|
|
typedef short StateSnapshot_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The state snapshot handle
|
|
//-----------------------------------------------------------------------------
|
|
typedef int ShaderDLL_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Texture creation
|
|
//-----------------------------------------------------------------------------
|
|
enum CreateTextureFlags_t {
|
|
TEXTURE_CREATE_CUBEMAP = 0x0001,
|
|
TEXTURE_CREATE_RENDERTARGET = 0x0002,
|
|
TEXTURE_CREATE_MANAGED = 0x0004,
|
|
TEXTURE_CREATE_DEPTHBUFFER = 0x0008,
|
|
TEXTURE_CREATE_DYNAMIC = 0x0010,
|
|
TEXTURE_CREATE_AUTOMIPMAP = 0x0020,
|
|
TEXTURE_CREATE_VERTEXTEXTURE = 0x0040, // for internal use only
|
|
TEXTURE_CREATE_FALLBACK = 0x0080, // 360 only
|
|
TEXTURE_CREATE_NOD3DMEMORY = 0x0100, // 360 only
|
|
TEXTURE_CREATE_SYSMEM =
|
|
0x0200, // This texture should be alloc'd in the sysmem pool
|
|
TEXTURE_CREATE_UNUSED4 = 0x0400, // Dead
|
|
TEXTURE_CREATE_UNUSED5 = 0x0800, // Dead
|
|
TEXTURE_CREATE_UNFILTERABLE_OK = 0x1000,
|
|
TEXTURE_CREATE_CANCONVERTFORMAT =
|
|
0x2000, // 360 only, allow format conversions at load
|
|
TEXTURE_CREATE_SRGB =
|
|
0x4000, // Posix/GL only, for textures which are SRGB-readable
|
|
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Fill modes
|
|
//-----------------------------------------------------------------------------
|
|
enum ShaderFillMode_t {
|
|
SHADER_FILL_SOLID = 0,
|
|
SHADER_FILL_WIREFRAME,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Rasterization state object
|
|
//-----------------------------------------------------------------------------
|
|
struct ShaderRasterState_t {
|
|
ShaderFillMode_t m_FillMode;
|
|
MaterialCullMode_t m_CullMode;
|
|
bool m_bCullEnable : 1;
|
|
bool m_bDepthBias : 1;
|
|
bool m_bScissorEnable : 1;
|
|
bool m_bMultisampleEnable : 1;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used for occlusion queries
|
|
//-----------------------------------------------------------------------------
|
|
DECLARE_POINTER_HANDLE(ShaderAPIOcclusionQuery_t);
|
|
#define INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE ((ShaderAPIOcclusionQuery_t)0)
|
|
|
|
enum ShaderAPIOcclusionQueryResult_t {
|
|
OCCLUSION_QUERY_RESULT_PENDING = -1,
|
|
OCCLUSION_QUERY_RESULT_ERROR = -2
|
|
};
|
|
#define OCCLUSION_QUERY_FINISHED(iQueryResult) \
|
|
((iQueryResult) != OCCLUSION_QUERY_RESULT_PENDING)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is what the material system gets to see.
|
|
//-----------------------------------------------------------------------------
|
|
#define SHADERAPI_INTERFACE_VERSION "ShaderApi030"
|
|
abstract_class IShaderAPI : public IShaderDynamicAPI {
|
|
public:
|
|
//
|
|
// NOTE: These methods have been ported to DX10
|
|
//
|
|
|
|
// Viewport methods
|
|
virtual void SetViewports(int nCount,
|
|
const ShaderViewport_t *pViewports) = 0;
|
|
virtual int GetViewports(ShaderViewport_t * pViewports, int nMax) const = 0;
|
|
|
|
// Buffer clearing
|
|
virtual void ClearBuffers(bool bClearColor, bool bClearDepth,
|
|
bool bClearStencil, int renderTargetWidth,
|
|
int renderTargetHeight) = 0;
|
|
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;
|
|
|
|
// Methods related to binding shaders
|
|
virtual void BindVertexShader(VertexShaderHandle_t hVertexShader) = 0;
|
|
virtual void BindGeometryShader(GeometryShaderHandle_t hGeometryShader) = 0;
|
|
virtual void BindPixelShader(PixelShaderHandle_t hPixelShader) = 0;
|
|
|
|
// Methods related to state objects
|
|
virtual void SetRasterState(const ShaderRasterState_t &state) = 0;
|
|
|
|
//
|
|
// NOTE: These methods have not yet been ported to DX10
|
|
//
|
|
|
|
// Sets the mode...
|
|
virtual bool SetMode(void *hwnd, int nAdapter,
|
|
const ShaderDeviceInfo_t &info) = 0;
|
|
|
|
virtual void ChangeVideoMode(const ShaderDeviceInfo_t &info) = 0;
|
|
|
|
// Returns the snapshot id for the shader state
|
|
virtual StateSnapshot_t TakeSnapshot() = 0;
|
|
|
|
virtual void TexMinFilter(ShaderTexFilterMode_t texFilterMode) = 0;
|
|
virtual void TexMagFilter(ShaderTexFilterMode_t texFilterMode) = 0;
|
|
virtual void TexWrap(ShaderTexCoordComponent_t coord,
|
|
ShaderTexWrapMode_t wrapMode) = 0;
|
|
|
|
virtual void CopyRenderTargetToTexture(
|
|
ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
// Binds a particular material to render with
|
|
virtual void Bind(IMaterial * pMaterial) = 0;
|
|
|
|
// Flushes any primitives that are buffered
|
|
virtual void FlushBufferedPrimitives() = 0;
|
|
|
|
// Gets the dynamic mesh; 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.
|
|
virtual IMesh *GetDynamicMesh(
|
|
IMaterial * pMaterial, int nHWSkinBoneCount, bool bBuffered = true,
|
|
IMesh *pVertexOverride = 0, IMesh *pIndexOverride = 0) = 0;
|
|
virtual IMesh *GetDynamicMeshEx(
|
|
IMaterial * pMaterial, VertexFormat_t vertexFormat,
|
|
int nHWSkinBoneCount, bool bBuffered = true, IMesh *pVertexOverride = 0,
|
|
IMesh *pIndexOverride = 0) = 0;
|
|
|
|
// Methods to ask about particular state snapshots
|
|
virtual bool IsTranslucent(StateSnapshot_t id) const = 0;
|
|
virtual bool IsAlphaTested(StateSnapshot_t id) const = 0;
|
|
virtual bool UsesVertexAndPixelShaders(StateSnapshot_t id) const = 0;
|
|
virtual bool IsDepthWriteEnabled(StateSnapshot_t id) const = 0;
|
|
|
|
// Gets the vertex format for a set of snapshot ids
|
|
virtual VertexFormat_t ComputeVertexFormat(int numSnapshots,
|
|
StateSnapshot_t *pIds) const = 0;
|
|
|
|
// What fields in the vertex do we actually use?
|
|
virtual VertexFormat_t ComputeVertexUsage(int numSnapshots,
|
|
StateSnapshot_t *pIds) const = 0;
|
|
|
|
// Begins a rendering pass
|
|
virtual void BeginPass(StateSnapshot_t snapshot) = 0;
|
|
|
|
// Renders a single pass of a material
|
|
virtual void RenderPass(int nPass, int nPassCount) = 0;
|
|
|
|
// Set the number of bone weights
|
|
virtual void SetNumBoneWeights(int numBones) = 0;
|
|
|
|
// Sets the lights
|
|
virtual void SetLight(int lightNum, const LightDesc_t &desc) = 0;
|
|
|
|
// Lighting origin for the current model
|
|
virtual void SetLightingOrigin(Vector vLightingOrigin) = 0;
|
|
|
|
virtual void SetAmbientLight(float r, float g, float b) = 0;
|
|
virtual void SetAmbientLightCube(Vector4D cube[6]) = 0;
|
|
|
|
// The shade mode
|
|
virtual void ShadeMode(ShaderShadeMode_t mode) = 0;
|
|
|
|
// The cull mode
|
|
virtual void CullMode(MaterialCullMode_t cullMode) = 0;
|
|
|
|
// Force writes only when z matches. . . useful for stenciling things out
|
|
// by rendering the desired Z values ahead of time.
|
|
virtual void ForceDepthFuncEquals(bool bEnable) = 0;
|
|
|
|
// Forces Z buffering to be on or off
|
|
virtual void OverrideDepthEnable(bool bEnable, bool bDepthEnable) = 0;
|
|
|
|
virtual void SetHeightClipZ(float z) = 0;
|
|
virtual void SetHeightClipMode(
|
|
enum MaterialHeightClipMode_t heightClipMode) = 0;
|
|
|
|
virtual void SetClipPlane(int index, const float *pPlane) = 0;
|
|
virtual void EnableClipPlane(int index, bool bEnable) = 0;
|
|
|
|
// Put all the model matrices into vertex shader constants.
|
|
virtual void SetSkinningMatrices() = 0;
|
|
|
|
// Returns the nearest supported format
|
|
virtual ImageFormat GetNearestSupportedFormat(
|
|
ImageFormat fmt, bool bFilteringRequired = true) const = 0;
|
|
virtual ImageFormat GetNearestRenderTargetFormat(ImageFormat fmt) const = 0;
|
|
|
|
// When AA is enabled, render targets are not AA and require a separate
|
|
// depth buffer.
|
|
virtual bool DoRenderTargetsNeedSeparateDepthBuffer() const = 0;
|
|
|
|
// Texture management methods
|
|
// For CreateTexture also see CreateTextures below
|
|
virtual ShaderAPITextureHandle_t CreateTexture(
|
|
int width, int height, int depth, ImageFormat dstImageFormat,
|
|
int numMipLevels, int numCopies, int flags, const char *pDebugName,
|
|
const char *pTextureGroupName) = 0;
|
|
|
|
virtual void DeleteTexture(ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
virtual ShaderAPITextureHandle_t CreateDepthTexture(
|
|
ImageFormat renderTargetFormat, int width, int height,
|
|
const char *pDebugName, bool bTexture) = 0;
|
|
|
|
virtual bool IsTexture(ShaderAPITextureHandle_t textureHandle) = 0;
|
|
virtual bool IsTextureResident(ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
// Indicates we're going to be modifying this texture
|
|
// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter
|
|
// all use the texture specified by this function.
|
|
virtual void ModifyTexture(ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
virtual void TexImage2D(int level, int cubeFaceID, ImageFormat dstFormat,
|
|
int zOffset, int width, int height,
|
|
ImageFormat srcFormat,
|
|
bool bSrcIsTiled, // NOTE: for X360 only
|
|
void *imageData) = 0;
|
|
|
|
virtual void TexSubImage2D(int level, int cubeFaceID, int xOffset,
|
|
int yOffset, int zOffset, int width, int height,
|
|
ImageFormat srcFormat, int srcStride,
|
|
bool bSrcIsTiled, // NOTE: for X360 only
|
|
void *imageData) = 0;
|
|
|
|
virtual void TexImageFromVTF(IVTFTexture * pVTF, int iVTFFrame) = 0;
|
|
|
|
// An alternate (and faster) way of writing image data
|
|
// (locks the current Modify Texture). Use the pixel writer to write the
|
|
// data after Lock is called Doesn't work for compressed textures
|
|
virtual bool TexLock(int level, int cubeFaceID, int xOffset, int yOffset,
|
|
int width, int height, CPixelWriter &writer) = 0;
|
|
virtual void TexUnlock() = 0;
|
|
|
|
// These are bound to the texture
|
|
virtual void TexSetPriority(int priority) = 0;
|
|
|
|
// Sets the texture state
|
|
virtual void BindTexture(Sampler_t sampler,
|
|
ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
// Set the render target to a texID.
|
|
// Set to SHADER_RENDERTARGET_BACKBUFFER if you want to use the regular
|
|
// framebuffer. Set to SHADER_RENDERTARGET_DEPTHBUFFER if you want to use
|
|
// the regular z buffer.
|
|
virtual void SetRenderTarget(ShaderAPITextureHandle_t colorTextureHandle =
|
|
SHADER_RENDERTARGET_BACKBUFFER,
|
|
ShaderAPITextureHandle_t depthTextureHandle =
|
|
SHADER_RENDERTARGET_DEPTHBUFFER) = 0;
|
|
|
|
// stuff that isn't to be used from within a shader
|
|
virtual void ClearBuffersObeyStencil(bool bClearColor,
|
|
bool bClearDepth) = 0;
|
|
virtual void ReadPixels(int x, int y, int width, int height,
|
|
unsigned char *data, ImageFormat dstFormat) = 0;
|
|
virtual void ReadPixels(Rect_t * pSrcRect, Rect_t * pDstRect,
|
|
unsigned char *data, ImageFormat dstFormat,
|
|
int nDstStride) = 0;
|
|
|
|
virtual void FlushHardware() = 0;
|
|
|
|
// Use this to begin and end the frame
|
|
virtual void BeginFrame() = 0;
|
|
virtual void EndFrame() = 0;
|
|
|
|
// 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;
|
|
|
|
// Force the hardware to finish whatever it's doing
|
|
virtual void ForceHardwareSync() = 0;
|
|
|
|
// Used to clear the transition table when we know it's become invalid.
|
|
virtual void ClearSnapshots() = 0;
|
|
|
|
virtual void FogStart(float fStart) = 0;
|
|
virtual void FogEnd(float fEnd) = 0;
|
|
virtual void SetFogZ(float fogZ) = 0;
|
|
// Scene fog state.
|
|
virtual void SceneFogColor3ub(unsigned char r, unsigned char g,
|
|
unsigned char b) = 0;
|
|
virtual void GetSceneFogColor(unsigned char *rgb) = 0;
|
|
virtual void SceneFogMode(MaterialFogMode_t fogMode) = 0;
|
|
|
|
// Can we download textures?
|
|
virtual bool CanDownloadTextures() const = 0;
|
|
|
|
virtual void ResetRenderState(bool bFullReset = true) = 0;
|
|
|
|
// We use smaller dynamic VBs during level transitions, to free up memory
|
|
virtual int GetCurrentDynamicVBSize(void) = 0;
|
|
virtual void DestroyVertexBuffers(bool bExitingLevel = false) = 0;
|
|
|
|
virtual void EvictManagedResources() = 0;
|
|
|
|
// Level of anisotropic filtering
|
|
virtual void SetAnisotropicLevel(int nAnisotropyLevel) = 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;
|
|
|
|
// Setup standard vertex shader constants (that don't change)
|
|
// This needs to be called anytime that overbright changes.
|
|
virtual void SetStandardVertexShaderConstants(float fOverbright) = 0;
|
|
|
|
//
|
|
// Occlusion query support
|
|
//
|
|
|
|
// Allocate and delete query objects.
|
|
virtual ShaderAPIOcclusionQuery_t CreateOcclusionQueryObject(void) = 0;
|
|
virtual void DestroyOcclusionQueryObject(ShaderAPIOcclusionQuery_t) = 0;
|
|
|
|
// Bracket drawing with begin and end so that we can get counts next frame.
|
|
virtual void BeginOcclusionQueryDrawing(ShaderAPIOcclusionQuery_t) = 0;
|
|
virtual void EndOcclusionQueryDrawing(ShaderAPIOcclusionQuery_t) = 0;
|
|
|
|
// OcclusionQuery_GetNumPixelsRendered
|
|
// 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!
|
|
// Returns iQueryResult:
|
|
// iQueryResult >= 0 - iQueryResult is the number of pixels
|
|
//rendered
|
|
// OCCLUSION_QUERY_RESULT_PENDING - query results are not available
|
|
//yet OCCLUSION_QUERY_RESULT_ERROR - query failed
|
|
// Use OCCLUSION_QUERY_FINISHED( iQueryResult ) to test if query finished.
|
|
virtual int OcclusionQuery_GetNumPixelsRendered(
|
|
ShaderAPIOcclusionQuery_t hQuery, bool bFlush = false) = 0;
|
|
|
|
virtual void SetFlashlightState(const FlashlightState_t &state,
|
|
const VMatrix &worldToTexture) = 0;
|
|
|
|
virtual void ClearVertexAndPixelShaderRefCounts() = 0;
|
|
virtual void PurgeUnusedVertexAndPixelShaders() = 0;
|
|
|
|
// Called when the dx support level has changed
|
|
virtual void DXSupportLevelChanged() = 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 View transform for user clip planes. The PROJECTION will be
|
|
// mutliplied against this instead of the normal VIEW matrix.
|
|
virtual void EnableUserClipTransformOverride(bool bEnable) = 0;
|
|
virtual void UserClipTransform(const VMatrix &worldToView) = 0;
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// Everything after this point added after HL2 shipped.
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
// What fields in the morph do we actually use?
|
|
virtual MorphFormat_t ComputeMorphFormat(int numSnapshots,
|
|
StateSnapshot_t *pIds) const = 0;
|
|
|
|
// Set the render target to a texID.
|
|
// Set to SHADER_RENDERTARGET_BACKBUFFER if you want to use the regular
|
|
// framebuffer. Set to SHADER_RENDERTARGET_DEPTHBUFFER if you want to use
|
|
// the regular z buffer.
|
|
virtual void SetRenderTargetEx(int nRenderTargetID,
|
|
ShaderAPITextureHandle_t colorTextureHandle =
|
|
SHADER_RENDERTARGET_BACKBUFFER,
|
|
ShaderAPITextureHandle_t depthTextureHandle =
|
|
SHADER_RENDERTARGET_DEPTHBUFFER) = 0;
|
|
|
|
virtual void CopyRenderTargetToTextureEx(
|
|
ShaderAPITextureHandle_t textureHandle, int nRenderTargetID,
|
|
Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL) = 0;
|
|
virtual void CopyTextureToRenderTargetEx(
|
|
int nRenderTargetID, ShaderAPITextureHandle_t textureHandle,
|
|
Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL) = 0;
|
|
|
|
// For dealing with device lost in cases where SwapBuffers isn't called all
|
|
// the time (Hammer)
|
|
virtual void HandleDeviceLost() = 0;
|
|
|
|
virtual void EnableLinearColorSpaceFrameBuffer(bool bEnable) = 0;
|
|
|
|
// Lets the shader know about the full-screen texture so it can
|
|
virtual void SetFullScreenTextureHandle(ShaderAPITextureHandle_t h) = 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;
|
|
|
|
virtual float GetFloatRenderingParameter(int parm_number) const = 0;
|
|
virtual int GetIntRenderingParameter(int parm_number) const = 0;
|
|
virtual Vector GetVectorRenderingParameter(int parm_number) const = 0;
|
|
|
|
virtual void SetFastClipPlane(const float *pPlane) = 0;
|
|
virtual void EnableFastClip(bool bEnable) = 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 number of vertices we can render for a given material
|
|
virtual int GetMaxVerticesToRender(IMaterial * pMaterial) = 0;
|
|
virtual int GetMaxIndicesToRender() = 0;
|
|
|
|
// stencil methods
|
|
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;
|
|
|
|
// disables all local lights
|
|
virtual void DisableAllLocalLights() = 0;
|
|
virtual int CompareSnapshots(StateSnapshot_t snapshot0,
|
|
StateSnapshot_t snapshot1) = 0;
|
|
|
|
virtual IMesh *GetFlexMesh() = 0;
|
|
|
|
virtual void SetFlashlightStateEx(const FlashlightState_t &state,
|
|
const VMatrix &worldToTexture,
|
|
ITexture *pFlashlightDepthTexture) = 0;
|
|
|
|
virtual bool SupportsMSAAMode(int nMSAAMode) = 0;
|
|
|
|
#if defined(_X360)
|
|
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 ShaderAPITextureHandle_t CreateRenderTargetSurface(
|
|
int width, int height, ImageFormat format, const char *pDebugName,
|
|
const char *pTextureGroupName) = 0;
|
|
virtual void PersistDisplay() = 0;
|
|
virtual bool PostQueuedTexture(const void *pData, int nSize,
|
|
ShaderAPITextureHandle_t *pHandles,
|
|
int nHandles, int nWidth, int nHeight,
|
|
int nDepth, int nMips, int *pRefCount) = 0;
|
|
virtual void *GetD3DDevice() = 0;
|
|
|
|
virtual void PushVertexShaderGPRAllocation(int iVertexShaderCount = 64) = 0;
|
|
virtual void PopVertexShaderGPRAllocation(void) = 0;
|
|
|
|
virtual void EnableVSync_360(
|
|
bool bEnable) = 0; // 360 allows us to bypass vsync blocking up to 60
|
|
// fps without creating a new device
|
|
#endif
|
|
|
|
virtual bool OwnGPUResources(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;
|
|
|
|
// Enables and disables for Alpha To Coverage
|
|
virtual void EnableAlphaToCoverage() = 0;
|
|
virtual void DisableAlphaToCoverage() = 0;
|
|
|
|
// Computes the vertex buffer pointers
|
|
virtual void ComputeVertexDescription(
|
|
unsigned char *pBuffer, VertexFormat_t vertexFormat, MeshDesc_t &desc)
|
|
const = 0;
|
|
|
|
virtual bool SupportsShadowDepthTextures(void) = 0;
|
|
|
|
virtual void SetDisallowAccess(bool) = 0;
|
|
virtual void EnableShaderShaderMutex(bool) = 0;
|
|
virtual void ShaderLock() = 0;
|
|
virtual void ShaderUnlock() = 0;
|
|
|
|
virtual ImageFormat GetShadowDepthTextureFormat(void) = 0;
|
|
|
|
virtual bool SupportsFetch4(void) = 0;
|
|
virtual void SetShadowDepthBiasFactors(float fShadowSlopeScaleDepthBias,
|
|
float fShadowDepthBias) = 0;
|
|
|
|
// ------------ New Vertex/Index Buffer interface
|
|
// ----------------------------
|
|
virtual void BindVertexBuffer(int nStreamID, 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 nFirstIndex,
|
|
int nIndexCount) = 0;
|
|
// ------------ End ----------------------------
|
|
|
|
// Apply stencil operations to every pixel on the screen without disturbing
|
|
// depth or color buffers
|
|
virtual void PerformFullScreenStencilOperation(void) = 0;
|
|
|
|
virtual void SetScissorRect(const int nLeft, const int nTop,
|
|
const int nRight, const int nBottom,
|
|
const bool bEnableScissor) = 0;
|
|
|
|
// nVidia CSAA modes, different from SupportsMSAAMode()
|
|
virtual bool SupportsCSAAMode(int nNumSamples, int nQualityLevel) = 0;
|
|
|
|
// Notifies the shaderapi to invalidate the current set of delayed constants
|
|
// because we just finished a draw pass. Either actual or not.
|
|
virtual void InvalidateDelayedShaderConstants(void) = 0;
|
|
|
|
// Gamma<->Linear conversions according to the video hardware we're running
|
|
// on
|
|
virtual float GammaToLinear_HardwareSpecific(float fGamma) const = 0;
|
|
virtual float LinearToGamma_HardwareSpecific(float fLinear) const = 0;
|
|
|
|
// Set's the linear->gamma conversion textures to use for this hardware for
|
|
// both srgb writes enabled and disabled(identity)
|
|
virtual void SetLinearToGammaConversionTextures(
|
|
ShaderAPITextureHandle_t hSRGBWriteEnabledTexture,
|
|
ShaderAPITextureHandle_t hIdentityTexture) = 0;
|
|
|
|
virtual ImageFormat GetNullTextureFormat(void) = 0;
|
|
|
|
virtual void BindVertexTexture(VertexTextureSampler_t nSampler,
|
|
ShaderAPITextureHandle_t textureHandle) = 0;
|
|
|
|
// Enables hardware morphing
|
|
virtual void EnableHWMorphing(bool bEnable) = 0;
|
|
|
|
// Sets flexweights for rendering
|
|
virtual void SetFlexWeights(int nFirstWeight, int nCount,
|
|
const MorphWeight_t *pWeights) = 0;
|
|
|
|
virtual void FogMaxDensity(float flMaxDensity) = 0;
|
|
|
|
// Create a multi-frame texture (equivalent to calling "CreateTexture"
|
|
// multiple times, but more efficient)
|
|
virtual void CreateTextures(
|
|
ShaderAPITextureHandle_t * pHandles, int count, int width, int height,
|
|
int depth, ImageFormat dstImageFormat, int numMipLevels, int numCopies,
|
|
int flags, const char *pDebugName, const char *pTextureGroupName) = 0;
|
|
|
|
virtual void AcquireThreadOwnership() = 0;
|
|
virtual void ReleaseThreadOwnership() = 0;
|
|
|
|
virtual bool SupportsNormalMapCompression() const = 0;
|
|
|
|
// Only does anything on XBox360. This is useful to eliminate stalls
|
|
virtual void EnableBuffer2FramesAhead(bool bEnable) = 0;
|
|
|
|
virtual void SetDepthFeatheringPixelShaderConstant(
|
|
int iConstant, float fDepthBlendScale) = 0;
|
|
|
|
// debug logging
|
|
// only implemented in some subclasses
|
|
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;
|
|
|
|
// extended clear buffers function with alpha independent from color
|
|
virtual void ClearBuffersObeyStencilEx(bool bClearColor, bool bClearAlpha,
|
|
bool bClearDepth) = 0;
|
|
|
|
// Allows copying a render target to another texture by specifying them
|
|
// both.
|
|
virtual void CopyRenderTargetToScratchTexture(
|
|
ShaderAPITextureHandle_t srcRt, ShaderAPITextureHandle_t dstTex,
|
|
Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL) = 0;
|
|
|
|
// Allows locking and unlocking of very specific surface types.
|
|
virtual void LockRect(void **pOutBits, int *pOutPitch,
|
|
ShaderAPITextureHandle_t texHandle, int mipmap, int x,
|
|
int y, int w, int h, bool bWrite, bool bRead) = 0;
|
|
virtual void UnlockRect(ShaderAPITextureHandle_t texHandle, int mipmap) = 0;
|
|
};
|
|
|
|
#endif // ISHADERAPI_H
|