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.
382 lines
13 KiB
382 lines
13 KiB
//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef IRENDERCONTEXT_H
|
|
#define IRENDERCONTEXT_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "rendersystem/irenderdevice.h"
|
|
#include "mathlib/vector4d.h"
|
|
#include "tier1/generichash.h"
|
|
#include "rendersystem/renderstate.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "rendersystem/schema/renderable.g.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum RenderBufferStride_t
|
|
{
|
|
RENDER_BUFFER_STRIDE_INVALID = -1,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Index/vertex buffer lock info
|
|
//-----------------------------------------------------------------------------
|
|
struct LockDesc_t
|
|
{
|
|
void *m_pMemory;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Viewport structure
|
|
//-----------------------------------------------------------------------------
|
|
#define RENDER_VIEWPORT_VERSION 1
|
|
struct RenderViewport_t
|
|
{
|
|
int m_nVersion;
|
|
int m_nTopLeftX;
|
|
int m_nTopLeftY;
|
|
int m_nWidth;
|
|
int m_nHeight;
|
|
float m_flMinZ;
|
|
float m_flMaxZ;
|
|
|
|
RenderViewport_t() : m_nVersion( RENDER_VIEWPORT_VERSION ) {}
|
|
|
|
void Init()
|
|
{
|
|
memset( this, 0, sizeof(RenderViewport_t) );
|
|
m_nVersion = RENDER_VIEWPORT_VERSION;
|
|
}
|
|
|
|
void Init( int x, int y, int nWidth, int nHeight, float flMinZ = 0.0f, float flMaxZ = 1.0f )
|
|
{
|
|
m_nVersion = RENDER_VIEWPORT_VERSION;
|
|
m_nTopLeftX = x; m_nTopLeftY = y; m_nWidth = nWidth; m_nHeight = nHeight;
|
|
m_flMinZ = flMinZ;
|
|
m_flMaxZ = flMaxZ;
|
|
}
|
|
};
|
|
|
|
|
|
// clear flags
|
|
enum RenderClearFlags_t
|
|
{
|
|
RENDER_CLEAR_FLAGS_CLEAR_DEPTH = 0x1,
|
|
RENDER_CLEAR_FLAGS_CLEAR_STENCIL = 0x2
|
|
};
|
|
|
|
|
|
enum StandardTextureID_t
|
|
{
|
|
STDTEXTURE_NORMAL_DEPTH_BUFFER = 0,
|
|
STDTEXTURE_LIGHTPASS_OUTPUT,
|
|
|
|
STDTEXTURE_NUMBER_OF_IDS
|
|
};
|
|
|
|
|
|
class CDisplayList // subclasses in devices
|
|
{
|
|
public:
|
|
CDisplayList *m_pNext;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Data for the material system
|
|
//-----------------------------------------------------------------------------
|
|
#define RENDER_MATERIAL_NUM_WORLD_MATRICES 53
|
|
struct RenderMaterialData_t
|
|
{
|
|
int nMode;
|
|
|
|
float flTime;
|
|
|
|
float mWorldArray[ RENDER_MATERIAL_NUM_WORLD_MATRICES ][3][4];
|
|
VMatrix mView;
|
|
VMatrix mProjection;
|
|
VMatrix mVP;
|
|
VMatrix mWVP;
|
|
|
|
Vector vCameraPosition;
|
|
Vector vCameraForwardVec;
|
|
Vector vCameraUpVec;
|
|
float flNearPlane;
|
|
float flFarPlane;
|
|
float vViewportSize[2];
|
|
|
|
HRenderTexture customTextures[2];
|
|
|
|
void Init()
|
|
{
|
|
nMode = 0;
|
|
|
|
flTime = 0.0f;
|
|
|
|
float m4x3Identity[3][4] = { 1.0f, 0.0f, 0.0f, 0.0f,
|
|
0.0f, 1.0f, 0.0f, 0.0f,
|
|
0.0f, 0.0f, 1.0f, 0.0f };
|
|
|
|
for ( int i = 0; i < RENDER_MATERIAL_NUM_WORLD_MATRICES; i++ )
|
|
{
|
|
memcpy( mWorldArray[i], m4x3Identity, sizeof( m4x3Identity ) );
|
|
}
|
|
|
|
mView.Identity();
|
|
mProjection.Identity();
|
|
mVP.Identity();
|
|
mWVP.Identity();
|
|
|
|
vCameraPosition.Init( 0.0f, 0.0f, 0.0f );
|
|
vCameraForwardVec.Init( 0.0f, 0.0f, 0.0f );
|
|
vCameraUpVec.Init( 0.0f, 0.0f, 0.0f );
|
|
flNearPlane = 0.0f;
|
|
flFarPlane = 1.0f;
|
|
vViewportSize[0] = 0.0f;
|
|
vViewportSize[1] = 0.0f;
|
|
|
|
customTextures[0] = RENDER_TEXTURE_HANDLE_INVALID;
|
|
customTextures[1] = RENDER_TEXTURE_HANDLE_INVALID;
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Render context interface
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class IRenderContext
|
|
{
|
|
// rendering functions. in flux
|
|
public:
|
|
virtual void SetSwapChain( SwapChainHandle_t hSwapChain ) = 0;
|
|
|
|
// Called when the context is handed to a thread.
|
|
virtual void AttachToCurrentThread() = 0;
|
|
|
|
virtual void Clear( const Vector4D &vecRGBAColor, int nFlags = 0 ) = 0; // any RENDER_CLEAR_FLAGS_CLEAR_xxx flags
|
|
|
|
virtual void SetViewports( int nCount, const RenderViewport_t* pViewports, bool setImmediately = false ) = 0;
|
|
virtual void GetViewport( RenderViewport_t *pViewport, int nViewport ) = 0;
|
|
|
|
// Restriction: This can only be called as the first call after a
|
|
// context is created, or the first call after a Submit.
|
|
virtual void BindRenderTargets( RenderTargetBinding_t hRenderTargetBinding ) = 0;
|
|
|
|
// set this to actually draw, and clear display list data
|
|
virtual void Submit( void ) =0;
|
|
|
|
// use this interface to finish a command list but not submit it until later. This call resets
|
|
// the rendercontext
|
|
virtual CDisplayList *DetachCommandList ( void ) =0;
|
|
|
|
|
|
// add items to the next submitted batches. Doing a submit resets this
|
|
virtual void DependsOn( CDependencyDescriptor *pDesc ) = 0;
|
|
virtual void Satisfies( CDependencyDescriptor *pDesc ) = 0;
|
|
|
|
// Creates/destroys vertex + index buffers
|
|
// For CreateDynamicIndexBuffer, nMaxInstanceCount == 0 means we don't expect
|
|
// the buffer to be used w/ instanced rendering.
|
|
// mNaxInstanceCount == INT_MAX means we have no idea how many instances will be rendered
|
|
virtual HRenderBuffer CreateDynamicVertexBuffer( const BufferDesc_t& desc ) = 0;
|
|
virtual void DestroyDynamicVertexBuffer( HRenderBuffer hVertexBuffer ) = 0;
|
|
virtual HRenderBuffer CreateDynamicIndexBuffer( const BufferDesc_t& desc, int nMaxInstanceCount = 0 ) = 0;
|
|
virtual void DestroyDynamicIndexBuffer( HRenderBuffer hIndexBuffer ) = 0;
|
|
|
|
// Use this to read or write buffers, whether lock is for read or write
|
|
// depends on the type of buffer (dynamic, staging, semistatic, etc)
|
|
virtual bool LockIndexBuffer( HRenderBuffer hIndexBuffer, int nMaxSizeInBytes, LockDesc_t *pDesc ) = 0;
|
|
virtual void UnlockIndexBuffer( HRenderBuffer hIndexBuffer, int nWrittenSizeInBytes, LockDesc_t *pDesc ) = 0;
|
|
virtual bool LockVertexBuffer( HRenderBuffer hVertexBuffer, int nMaxSizeInBytes, LockDesc_t *pDesc ) = 0;
|
|
virtual void UnlockVertexBuffer( HRenderBuffer hVertexBuffer, int nWrittenSizeInBytes, LockDesc_t *pDesc ) = 0;
|
|
|
|
// Binds an vertex/index buffer
|
|
virtual bool BindIndexBuffer( HRenderBuffer hIndexBuffer, int nOffset ) = 0;
|
|
virtual bool BindVertexBuffer( int nSlot, HRenderBuffer hVertexBuffer, int nOffset, int nStride = RENDER_BUFFER_STRIDE_INVALID ) = 0;
|
|
|
|
// Binds a vertex shader
|
|
virtual void BindVertexShader( RenderShaderHandle_t hVertexShader, RenderInputLayout_t hInputLayout ) = 0;
|
|
|
|
// Binds all other shader types
|
|
virtual void BindShader( RenderShaderType_t nType, RenderShaderHandle_t hShader ) = 0;
|
|
|
|
// textures
|
|
virtual void BindTexture( int nSamplerIndex, HRenderTexture hTexture, RenderShaderType_t nTargetPipelineStage = RENDER_PIXEL_SHADER ) = 0;
|
|
|
|
virtual void SetSamplerStatePS( int nSamplerIndex, RsFilter_t eFilterMode, RsTextureAddressMode_t eUWrapMode = RS_TEXTURE_ADDRESS_WRAP,
|
|
RsTextureAddressMode_t eVWrapMode = RS_TEXTURE_ADDRESS_WRAP, RsTextureAddressMode_t eWWrapMode = RS_TEXTURE_ADDRESS_WRAP,
|
|
RsComparison_t eTextureComparisonMode = RS_CMP_LESS ) = 0;
|
|
|
|
virtual void SetSamplerStateVS( int nSamplerIndex, RsFilter_t eFilterMode, RsTextureAddressMode_t eUWrapMode = RS_TEXTURE_ADDRESS_WRAP,
|
|
RsTextureAddressMode_t eVWrapMode = RS_TEXTURE_ADDRESS_WRAP, RsTextureAddressMode_t eWWrapMode = RS_TEXTURE_ADDRESS_WRAP,
|
|
RsComparison_t eTextureComparisonMode = RS_CMP_LESS ) = 0;
|
|
|
|
virtual void SetSamplerState( int32 nSamplerIndex, const CSamplerStateDesc *pSamplerDesc, RenderShaderType_t nTargetPipelineStage = RENDER_PIXEL_SHADER ) = 0;
|
|
|
|
// download data into a texture. It is acceptable to pass NULL for pData, in which case a d3d
|
|
// texture will be allocated and set up, but with unset bits (this is useful for getting a
|
|
// render target into memory for instance).
|
|
// NOTE: This doesn't work on file-backed textures
|
|
virtual void SetTextureData( HRenderTexture hTexture, const TextureDesc_t *pDataDesc, const void *pData, int nDataSize, bool bIsPreTiled, int nSpecificMipLevelToSet = -1, Rect_t const *pSubRectToUpdate = NULL ) = 0;
|
|
|
|
// Draws stuff!
|
|
// If nMaxVertexCount == 0, then calculate max vertex count from the size of the vertex buffer
|
|
virtual void Draw( RenderPrimitiveType_t type, int nFirstVertex, int nVertexCount ) = 0;
|
|
virtual void DrawInstanced( RenderPrimitiveType_t type, int nFirstVertex, int nVertexCountPerInstance, int nInstanceCount ) = 0;
|
|
virtual void DrawIndexed( RenderPrimitiveType_t type, int nFirstIndex, int nIndexCount, int nMaxVertexCount = 0 ) = 0;
|
|
virtual void DrawIndexedInstanced( RenderPrimitiveType_t type, int nFirstIndex, int nIndexCountPerInstance, int nInstanceCount, int nMaxVertexCount = 0 ) = 0;
|
|
|
|
// misc state setting
|
|
virtual void SetCullMode( RenderCullMode_t eCullMode ) = 0;
|
|
virtual void SetBlendMode( RenderBlendMode_t eBlendMode, float const *pBlendFactor = NULL ) = 0;
|
|
virtual void SetZBufferMode( RenderZBufferMode_t eZBufferMode ) = 0;
|
|
|
|
virtual RsRasterizerStateHandle_t FindOrCreateRasterizerState( const RsRasterizerStateDesc_t *pRsDesc ) = 0;
|
|
virtual void SetRasterizerState( RsRasterizerStateHandle_t rasterizerState ) = 0;
|
|
|
|
virtual RsDepthStencilStateHandle_t FindOrCreateDepthStencilState( const RsDepthStencilStateDesc_t *pRsDesc ) = 0;
|
|
virtual void SetDepthStencilState( RsDepthStencilStateHandle_t rasterizerState, uint32 nStencilRef = 0 ) = 0;
|
|
|
|
virtual RsBlendStateHandle_t FindOrCreateBlendState( const RsBlendStateDesc_t *pBlendDesc ) = 0;
|
|
virtual void SetBlendState( RsBlendStateHandle_t blendState, float const *pBlendFactor = NULL, uint32 nSampleMask = 0xFFFFFFFF ) = 0;
|
|
|
|
// set the data in a constant buffer
|
|
virtual void SetConstantBufferData( ConstantBufferHandle_t hConstantBuffer, void const *pData, int nDataSize ) = 0;
|
|
|
|
// bind constant buffers
|
|
virtual void BindConstantBuffer( RenderShaderType_t nType, ConstantBufferHandle_t hConstantBuffer, int nSlot, int nRegisterBaseForDx9 ) = 0;
|
|
|
|
// get access to per-frame pooled constant buffers.
|
|
virtual ConstantBufferHandle_t GetDynamicConstantBuffer( int nSize, void const *pData = NULL ) =0;
|
|
|
|
// Get the input layout associated with this renderbuffer. Returns RENDER_INPUT_LAYOUT_INVALID if none is associated.
|
|
virtual RenderInputLayout_t GetInputLayoutForVertexBuffer( HRenderBuffer hBuffer, InputLayoutVariation_t nVariation = INPUT_LAYOUT_VARIATION_DEFAULT ) = 0;
|
|
|
|
// Blocks the thread until the render thread completely empties
|
|
virtual void Flush() = 0;
|
|
|
|
// Forces a device lost
|
|
virtual void ForceDeviceLost() = 0;
|
|
|
|
// Returns the device associated w/ the context
|
|
virtual IRenderDevice *GetDevice() = 0;
|
|
|
|
// PIX events for debugging/perf analysis
|
|
virtual void BeginPixEvent( color32 c, const char *pEventName ) = 0;
|
|
virtual void EndPixEvent( ) = 0;
|
|
virtual void PixSetMarker( color32 c, const char *pEventName ) = 0;
|
|
|
|
|
|
// "standard" texture support.
|
|
virtual void BindStandardTexture( int nSamplerIndex, StandardTextureID_t nTextureID, RenderShaderType_t nTargetPipelineStage = RENDER_PIXEL_SHADER ) = 0;
|
|
virtual void SetStandardTexture( StandardTextureID_t nTextureID, HRenderTexture hTexture ) =0;
|
|
virtual HRenderTexture GetStandardTexture( StandardTextureID_t nTextureID ) =0;
|
|
|
|
// Material system data
|
|
virtual RenderMaterialData_t &GetMaterialData() = 0;
|
|
|
|
protected:
|
|
// Don't allow delete calls on an IRenderContext
|
|
virtual ~IRenderContext() {}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// simple helper class with all inlines
|
|
//-----------------------------------------------------------------------------
|
|
class CRenderContextPtr
|
|
{
|
|
public:
|
|
CRenderContextPtr( IRenderDevice *pDevice, RenderTargetBinding_t hRenderTargetBinding = RENDER_TARGET_BINDING_INVALID );
|
|
~CRenderContextPtr( void );
|
|
IRenderContext *operator->( void ) const;
|
|
operator IRenderContext*() const;
|
|
void Release( );
|
|
|
|
protected:
|
|
IRenderContext *m_pContext;
|
|
IRenderDevice *m_pDevice;
|
|
};
|
|
|
|
FORCEINLINE CRenderContextPtr::CRenderContextPtr( IRenderDevice *pDevice, RenderTargetBinding_t hRenderTargetBinding )
|
|
{
|
|
m_pDevice = pDevice;
|
|
m_pContext = pDevice->GetRenderContext( );
|
|
m_pContext->BindRenderTargets( hRenderTargetBinding );
|
|
}
|
|
|
|
FORCEINLINE CRenderContextPtr::~CRenderContextPtr( void )
|
|
{
|
|
Release();
|
|
}
|
|
|
|
FORCEINLINE void CRenderContextPtr::Release( )
|
|
{
|
|
if ( m_pContext )
|
|
{
|
|
m_pContext->Submit( );
|
|
m_pDevice->ReleaseRenderContext( m_pContext );
|
|
m_pContext = NULL;
|
|
m_pDevice = NULL;
|
|
}
|
|
}
|
|
|
|
// delegate to context via -> override
|
|
FORCEINLINE IRenderContext *CRenderContextPtr::operator->( void ) const
|
|
{
|
|
return m_pContext;
|
|
}
|
|
|
|
// Cast operator (to pass to other methods)
|
|
FORCEINLINE CRenderContextPtr::operator IRenderContext*() const
|
|
{
|
|
return m_pContext;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Pix measurement helper class
|
|
//-----------------------------------------------------------------------------
|
|
class CRenderPixEvent
|
|
{
|
|
public:
|
|
CRenderPixEvent( IRenderContext *pRenderContext, color32 c, const char *pName )
|
|
{
|
|
m_pContext = pRenderContext;
|
|
m_pContext->BeginPixEvent( c, pName );
|
|
}
|
|
|
|
~CRenderPixEvent()
|
|
{
|
|
Release();
|
|
}
|
|
|
|
void Release()
|
|
{
|
|
if ( m_pContext )
|
|
{
|
|
m_pContext->EndPixEvent();
|
|
m_pContext = NULL;
|
|
}
|
|
}
|
|
|
|
private:
|
|
IRenderContext *m_pContext;
|
|
};
|
|
|
|
|
|
#endif // IRENDERCONTEXT_H
|