diff --git a/launcher/launcher.cpp b/launcher/launcher.cpp index 0b27da73..d09e0716 100644 --- a/launcher/launcher.cpp +++ b/launcher/launcher.cpp @@ -752,6 +752,12 @@ bool CSourceAppSystemGroup::Create() // Load up the appropriate shader DLL // This has to be done before connection. char const* pDLLName = "shaderapidx9" DLL_EXT_STRING; + + if ( CommandLine()->FindParm( "-gl" ) ) + { + pDLLName = "shaderapigl" DLL_EXT_STRING; + } + if ( CommandLine()->FindParm( "-noshaderapi" ) ) { pDLLName = "shaderapiempty" DLL_EXT_STRING; diff --git a/materialsystem/shaderapigl/meshgl.cpp b/materialsystem/shaderapigl/meshgl.cpp new file mode 100644 index 00000000..1b1d4ee7 --- /dev/null +++ b/materialsystem/shaderapigl/meshgl.cpp @@ -0,0 +1,171 @@ +#include "meshgl.h" + +//----------------------------------------------------------------------------- +// +// The empty mesh... +// +//----------------------------------------------------------------------------- +CGLMesh::CGLMesh( bool bIsDynamic ) : m_bIsDynamic( bIsDynamic ) +{ + m_pVertexMemory = new unsigned char[VERTEX_BUFFER_SIZE]; +} + +CGLMesh::~CGLMesh() +{ + delete[] m_pVertexMemory; +} + +bool CGLMesh::Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc ) +{ + static int s_BogusIndex; + desc.m_pIndices = (unsigned short*)&s_BogusIndex; + desc.m_nIndexSize = 0; + desc.m_nFirstIndex = 0; + desc.m_nOffset = 0; + return true; +} + +void CGLMesh::Unlock( int nWrittenIndexCount, IndexDesc_t& desc ) +{ +} + +void CGLMesh::ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc ) +{ + Lock( nIndexCount, false, desc ); +} + +void CGLMesh::ModifyEnd( IndexDesc_t& desc ) +{ +} + +void CGLMesh::Spew( int nIndexCount, const IndexDesc_t & desc ) +{ +} + +void CGLMesh::ValidateData( int nIndexCount, const IndexDesc_t &desc ) +{ +} + +bool CGLMesh::Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ) +{ + // Who cares about the data? + desc.m_pPosition = (float*)m_pVertexMemory; + desc.m_pNormal = (float*)m_pVertexMemory; + desc.m_pColor = m_pVertexMemory; + + int i; + for ( i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i) + { + desc.m_pTexCoord[i] = (float*)m_pVertexMemory; + } + + desc.m_pBoneWeight = (float*)m_pVertexMemory; + desc.m_pBoneMatrixIndex = (unsigned char*)m_pVertexMemory; + desc.m_pTangentS = (float*)m_pVertexMemory; + desc.m_pTangentT = (float*)m_pVertexMemory; + desc.m_pUserData = (float*)m_pVertexMemory; + desc.m_NumBoneWeights = 2; + + desc.m_VertexSize_Position = 0; + desc.m_VertexSize_BoneWeight = 0; + desc.m_VertexSize_BoneMatrixIndex = 0; + desc.m_VertexSize_Normal = 0; + desc.m_VertexSize_Color = 0; + for( i=0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ ) + { + desc.m_VertexSize_TexCoord[i] = 0; + } + desc.m_VertexSize_TangentS = 0; + desc.m_VertexSize_TangentT = 0; + desc.m_VertexSize_UserData = 0; + desc.m_ActualVertexSize = 0; // Size of the vertices.. Some of the m_VertexSize_ elements above + + desc.m_nFirstVertex = 0; + desc.m_nOffset = 0; + return true; +} + +void CGLMesh::Unlock( int nVertexCount, VertexDesc_t &desc ) +{ +} + +void CGLMesh::Spew( int nVertexCount, const VertexDesc_t &desc ) +{ +} + +void CGLMesh::ValidateData( int nVertexCount, const VertexDesc_t & desc ) +{ +} + +void CGLMesh::LockMesh( int numVerts, int numIndices, MeshDesc_t& desc ) +{ + Lock( numVerts, false, *static_cast( &desc ) ); + Lock( numIndices, false, *static_cast( &desc ) ); +} + +void CGLMesh::UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc ) +{ +} + +void CGLMesh::ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc ) +{ + Lock( numVerts, false, *static_cast( &desc ) ); + Lock( numIndices, false, *static_cast( &desc ) ); +} + +void CGLMesh::ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc ) +{ + ModifyBeginEx( false, firstVertex, numVerts, firstIndex, numIndices, desc ); +} + +void CGLMesh::ModifyEnd( MeshDesc_t& desc ) +{ +} + +// returns the # of vertices (static meshes only) +int CGLMesh::VertexCount() const +{ + return 0; +} + +// Sets the primitive type +void CGLMesh::SetPrimitiveType( MaterialPrimitiveType_t type ) +{ +} + +// Draws the entire mesh +void CGLMesh::Draw( int firstIndex, int numIndices ) +{ +} + +void CGLMesh::Draw(CPrimList *pPrims, int nPrims) +{ +} + +// Copy verts and/or indices to a mesh builder. This only works for temp meshes! +void CGLMesh::CopyToMeshBuilder( + int iStartVert, // Which vertices to copy. + int nVerts, + int iStartIndex, // Which indices to copy. + int nIndices, + int indexOffset, // This is added to each index. + CMeshBuilder &builder ) +{ +} + +// Spews the mesh data +void CGLMesh::Spew( int numVerts, int numIndices, const MeshDesc_t & desc ) +{ +} + +void CGLMesh::ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc ) +{ +} + +// gets the associated material +IMaterial* CGLMesh::GetMaterial() +{ + // umm. this don't work none + Assert(0); + return 0; +} diff --git a/materialsystem/shaderapigl/meshgl.h b/materialsystem/shaderapigl/meshgl.h new file mode 100644 index 00000000..54611b0e --- /dev/null +++ b/materialsystem/shaderapigl/meshgl.h @@ -0,0 +1,109 @@ +#ifndef MESHGL_H +#define MESHGL_H + +#include "utlvector.h" +#include "materialsystem/imaterialsystem.h" +#include "shaderapi/ishaderutil.h" +#include "shaderapi/ishaderapi.h" +#include "materialsystem/imesh.h" +#include "materialsystem/idebugtextureinfo.h" +#include "materialsystem/deformations.h" + +//----------------------------------------------------------------------------- +// The empty mesh +//----------------------------------------------------------------------------- +class CGLMesh : public IMesh +{ +public: + CGLMesh( bool bIsDynamic ); + virtual ~CGLMesh(); + + // FIXME: Make this work! Unsupported methods of IIndexBuffer + IVertexBuffer + virtual bool Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc ); + virtual void Unlock( int nWrittenIndexCount, IndexDesc_t& desc ); + virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc ); + virtual void ModifyEnd( IndexDesc_t& desc ); + virtual void Spew( int nIndexCount, const IndexDesc_t & desc ); + virtual void ValidateData( int nIndexCount, const IndexDesc_t &desc ); + virtual bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ); + virtual void Unlock( int nVertexCount, VertexDesc_t &desc ); + virtual void Spew( int nVertexCount, const VertexDesc_t &desc ); + virtual void ValidateData( int nVertexCount, const VertexDesc_t & desc ); + virtual bool IsDynamic() const { return m_bIsDynamic; } + virtual void BeginCastBuffer( VertexFormat_t format ) {} + virtual void BeginCastBuffer( MaterialIndexFormat_t format ) {} + virtual void EndCastBuffer( ) {} + virtual int GetRoomRemaining() const { return 0; } + virtual MaterialIndexFormat_t IndexFormat() const { return MATERIAL_INDEX_FORMAT_UNKNOWN; } + + void LockMesh( int numVerts, int numIndices, MeshDesc_t& desc ); + void UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc ); + + void ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc ); + void ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc ); + void ModifyEnd( MeshDesc_t& desc ); + + // returns the # of vertices (static meshes only) + int VertexCount() const; + + // Sets the primitive type + void SetPrimitiveType( MaterialPrimitiveType_t type ); + + // Draws the entire mesh + void Draw(int firstIndex, int numIndices); + + void Draw(CPrimList *pPrims, int nPrims); + + // Copy verts and/or indices to a mesh builder. This only works for temp meshes! + virtual void CopyToMeshBuilder( + int iStartVert, // Which vertices to copy. + int nVerts, + int iStartIndex, // Which indices to copy. + int nIndices, + int indexOffset, // This is added to each index. + CMeshBuilder &builder ); + + // Spews the mesh data + void Spew( int numVerts, int numIndices, const MeshDesc_t & desc ); + + void ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc ); + + // gets the associated material + IMaterial* GetMaterial(); + + void SetColorMesh( IMesh *pColorMesh, int nVertexOffset ) + { + } + + + virtual int IndexCount() const + { + return 0; + } + + virtual void SetFlexMesh( IMesh *pMesh, int nVertexOffset ) {} + + virtual void DisableFlexMesh() {} + + virtual void MarkAsDrawn() {} + + virtual unsigned ComputeMemoryUsed() { return 0; } + + virtual VertexFormat_t GetVertexFormat() const { return VERTEX_POSITION; } + + virtual IMesh *GetMesh() + { + return this; + } + +private: + enum + { + VERTEX_BUFFER_SIZE = 1024 * 1024 + }; + + unsigned char* m_pVertexMemory; + bool m_bIsDynamic; +}; + +#endif \ No newline at end of file diff --git a/materialsystem/shaderapigl/shaderapidevicegl.cp b/materialsystem/shaderapigl/shaderapidevicegl.cp new file mode 100644 index 00000000..e69de29b diff --git a/materialsystem/shaderapigl/shaderapidevicegl.cpp b/materialsystem/shaderapigl/shaderapidevicegl.cpp new file mode 100644 index 00000000..99e08d2f --- /dev/null +++ b/materialsystem/shaderapigl/shaderapidevicegl.cpp @@ -0,0 +1,223 @@ +#include "utlvector.h" +#include "materialsystem/imaterialsystem.h" +#include "shaderapi/ishaderutil.h" +#include "shaderapi/ishaderapi.h" +#include "materialsystem/imesh.h" +#include "materialsystem/idebugtextureinfo.h" +#include "materialsystem/deformations.h" +#include "meshgl.h" +#include "shaderapigl.h" +#include "shaderapidevicegl.h" +#include "shadershadowgl.h" + +//----------------------------------------------------------------------------- +// The main GL Shader util interface +//----------------------------------------------------------------------------- +IShaderUtil* g_pShaderUtil; + +//----------------------------------------------------------------------------- +// Factory to return from SetMode +//----------------------------------------------------------------------------- +static void* ShaderInterfaceFactory( const char *pInterfaceName, int *pReturnCode ) +{ + if ( pReturnCode ) + { + *pReturnCode = IFACE_OK; + } + if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_INTERFACE_VERSION ) ) + return static_cast< IShaderDevice* >( &s_ShaderDeviceGL ); + if ( !Q_stricmp( pInterfaceName, SHADERAPI_INTERFACE_VERSION ) ) + return static_cast< IShaderAPI* >( &g_ShaderAPIGL ); + if ( !Q_stricmp( pInterfaceName, SHADERSHADOW_INTERFACE_VERSION ) ) + return static_cast< IShaderShadow* >( &g_ShaderShadow ); + + if ( pReturnCode ) + { + *pReturnCode = IFACE_FAILED; + } + return NULL; +} + + +//----------------------------------------------------------------------------- +// +// Shader device empty +// +//----------------------------------------------------------------------------- +void CShaderDeviceGL::GetWindowSize( int &width, int &height ) const +{ + width = 0; + height = 0; +} + +void CShaderDeviceGL::GetBackBufferDimensions( int& width, int& height ) const +{ + width = 1600; + height = 900; +} + +// Use this to spew information about the 3D layer +void CShaderDeviceGL::SpewDriverInfo() const +{ + Warning("GL shader\n"); +} + +// Creates/ destroys a child window +bool CShaderDeviceGL::AddView( void* hwnd ) +{ + return true; +} + +void CShaderDeviceGL::RemoveView( void* hwnd ) +{ +} + +// Activates a view +void CShaderDeviceGL::SetView( void* hwnd ) +{ +} + +void CShaderDeviceGL::ReleaseResources() +{ +} + +void CShaderDeviceGL::ReacquireResources() +{ +} + +// Creates/destroys Mesh +IMesh* CShaderDeviceGL::CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial ) +{ + return &m_Mesh; +} + +void CShaderDeviceGL::DestroyStaticMesh( IMesh* mesh ) +{ +} + +// Creates/destroys static vertex + index buffers +IVertexBuffer *CShaderDeviceGL::CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pTextureBudgetGroup ) +{ + return ( type == SHADER_BUFFER_TYPE_STATIC || type == SHADER_BUFFER_TYPE_STATIC_TEMP ) ? &m_Mesh : &m_DynamicMesh; +} + +void CShaderDeviceGL::DestroyVertexBuffer( IVertexBuffer *pVertexBuffer ) +{ + +} + +IIndexBuffer *CShaderDeviceGL::CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pTextureBudgetGroup ) +{ + switch( bufferType ) + { + case SHADER_BUFFER_TYPE_STATIC: + case SHADER_BUFFER_TYPE_STATIC_TEMP: + return &m_Mesh; + default: + Assert( 0 ); + case SHADER_BUFFER_TYPE_DYNAMIC: + case SHADER_BUFFER_TYPE_DYNAMIC_TEMP: + return &m_DynamicMesh; + } +} + +void CShaderDeviceGL::DestroyIndexBuffer( IIndexBuffer *pIndexBuffer ) +{ + +} + +IVertexBuffer *CShaderDeviceGL::GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered ) +{ + return &m_DynamicMesh; +} + +IIndexBuffer *CShaderDeviceGL::GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered ) +{ + return &m_Mesh; +} + + + + + +//----------------------------------------------------------------------------- +// +// CShaderDeviceMgrGL +// +//----------------------------------------------------------------------------- +bool CShaderDeviceMgrGL::Connect( CreateInterfaceFn factory ) +{ + // So others can access it + g_pShaderUtil = (IShaderUtil*)factory( SHADER_UTIL_INTERFACE_VERSION, NULL ); + + return true; +} + +void CShaderDeviceMgrGL::Disconnect() +{ + g_pShaderUtil = NULL; +} + +void *CShaderDeviceMgrGL::QueryInterface( const char *pInterfaceName ) +{ + if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_MGR_INTERFACE_VERSION ) ) + return static_cast< IShaderDeviceMgr* >( this ); + if ( !Q_stricmp( pInterfaceName, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION ) ) + return static_cast< IMaterialSystemHardwareConfig* >( &g_ShaderAPIGL ); + return NULL; +} + +InitReturnVal_t CShaderDeviceMgrGL::Init() +{ + return INIT_OK; +} + +void CShaderDeviceMgrGL::Shutdown() +{ + +} + +// Sets the adapter +bool CShaderDeviceMgrGL::SetAdapter( int nAdapter, int nFlags ) +{ + return true; +} + +// FIXME: Is this a public interface? Might only need to be private to shaderapi +CreateInterfaceFn CShaderDeviceMgrGL::SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode ) +{ + return ShaderInterfaceFactory; +} + +// Gets the number of adapters... +int CShaderDeviceMgrGL::GetAdapterCount() const +{ + return 0; +} + +bool CShaderDeviceMgrGL::GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pKeyValues ) +{ + return true; +} + +// Returns info about each adapter +void CShaderDeviceMgrGL::GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const +{ + memset( &info, 0, sizeof( info ) ); + info.m_nDXSupportLevel = 90; +} + +// Returns the number of modes +int CShaderDeviceMgrGL::GetModeCount( int nAdapter ) const +{ + return 0; +} + +// Returns mode information.. +void CShaderDeviceMgrGL::GetModeInfo( ShaderDisplayMode_t *pInfo, int nAdapter, int nMode ) const +{ +} + +void CShaderDeviceMgrGL::GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const +{ +} \ No newline at end of file diff --git a/materialsystem/shaderapigl/shaderapidevicegl.h b/materialsystem/shaderapigl/shaderapidevicegl.h new file mode 100644 index 00000000..c5967d3a --- /dev/null +++ b/materialsystem/shaderapigl/shaderapidevicegl.h @@ -0,0 +1,99 @@ +#ifndef SHADERAPIDEVICEGL_H +#define SHADERAPIDEVICEGL_H + +extern IShaderUtil* g_pShaderUtil; + +//----------------------------------------------------------------------------- +// The GL implementation of the shader device +//----------------------------------------------------------------------------- +class CShaderDeviceGL : public IShaderDevice +{ +public: + CShaderDeviceGL() : m_DynamicMesh( true ), m_Mesh( false ) {} + + // Methods of IShaderDevice + virtual int GetCurrentAdapter() const { return 0; } + virtual bool IsUsingGraphics() const { return false; } + virtual void SpewDriverInfo() const; + virtual ImageFormat GetBackBufferFormat() const { return IMAGE_FORMAT_RGB888; } + virtual void GetBackBufferDimensions( int& width, int& height ) const; + virtual int StencilBufferBits() const { return 0; } + virtual bool IsAAEnabled() const { return false; } + virtual void Present( ) {} + virtual void GetWindowSize( int &width, int &height ) const; + virtual bool AddView( void* hwnd ); + virtual void RemoveView( void* hwnd ); + virtual void SetView( void* hwnd ); + virtual void ReleaseResources(); + virtual void ReacquireResources(); + virtual IMesh* CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial = NULL ); + virtual void DestroyStaticMesh( IMesh* mesh ); + virtual IShaderBuffer* CompileShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion ) { return NULL; } + virtual VertexShaderHandle_t CreateVertexShader( IShaderBuffer* pShaderBuffer ) { return VERTEX_SHADER_HANDLE_INVALID; } + virtual void DestroyVertexShader( VertexShaderHandle_t hShader ) {} + virtual GeometryShaderHandle_t CreateGeometryShader( IShaderBuffer* pShaderBuffer ) { return GEOMETRY_SHADER_HANDLE_INVALID; } + virtual void DestroyGeometryShader( GeometryShaderHandle_t hShader ) {} + virtual PixelShaderHandle_t CreatePixelShader( IShaderBuffer* pShaderBuffer ) { return PIXEL_SHADER_HANDLE_INVALID; } + virtual void DestroyPixelShader( PixelShaderHandle_t hShader ) {} + virtual IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup ); + virtual void DestroyVertexBuffer( IVertexBuffer *pVertexBuffer ); + virtual IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup ); + virtual void DestroyIndexBuffer( IIndexBuffer *pIndexBuffer ); + virtual IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered ); + virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered ); + virtual void SetHardwareGammaRamp( float fGamma, float fGammaTVRangeMin, float fGammaTVRangeMax, float fGammaTVExponent, bool bTVEnabled ) {} + virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode, ShaderNonInteractiveInfo_t *pInfo ) {} + virtual void RefreshFrontBufferNonInteractive( ) {} + virtual void HandleThreadEvent( uint32 threadEvent ) {} + +#ifdef DX_TO_GL_ABSTRACTION + virtual void DoStartupShaderPreloading( void ) {} +#endif + + virtual char *GetDisplayDeviceName() OVERRIDE { return ""; } + +private: + CGLMesh m_Mesh; + CGLMesh m_DynamicMesh; +}; + +static CShaderDeviceGL s_ShaderDeviceGL; + +// FIXME: Remove; it's for backward compat with the materialsystem only for now +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderDeviceGL, IShaderDevice, + SHADER_DEVICE_INTERFACE_VERSION, s_ShaderDeviceGL ) + +//----------------------------------------------------------------------------- +// The DX8 implementation of the shader device +//----------------------------------------------------------------------------- +class CShaderDeviceMgrGL : public IShaderDeviceMgr +{ +public: + // Methods of IAppSystem + virtual bool Connect( CreateInterfaceFn factory ); + virtual void Disconnect(); + virtual void *QueryInterface( const char *pInterfaceName ); + virtual InitReturnVal_t Init(); + virtual void Shutdown(); + +public: + // Methods of IShaderDeviceMgr + virtual int GetAdapterCount() const; + virtual void GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const; + virtual bool GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pKeyValues ); + virtual int GetModeCount( int adapter ) const; + virtual void GetModeInfo( ShaderDisplayMode_t *pInfo, int nAdapter, int mode ) const; + virtual void GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const; + virtual bool SetAdapter( int nAdapter, int nFlags ); + virtual CreateInterfaceFn SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode ); + virtual void AddModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) {} + virtual void RemoveModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) {} +}; + +static CShaderDeviceMgrGL s_ShaderDeviceMgrGL; + +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderDeviceMgrGL, IShaderDeviceMgr, + SHADER_DEVICE_MGR_INTERFACE_VERSION, s_ShaderDeviceMgrGL ) + + +#endif \ No newline at end of file diff --git a/materialsystem/shaderapigl/shaderapigl.cpp b/materialsystem/shaderapigl/shaderapigl.cpp new file mode 100644 index 00000000..9b5360e9 --- /dev/null +++ b/materialsystem/shaderapigl/shaderapigl.cpp @@ -0,0 +1,1142 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//===========================================================================// + +#include "utlvector.h" +#include "materialsystem/imaterialsystem.h" +#include "shadersystem.h" +#include "shaderapi/ishaderutil.h" +#include "shaderapi/ishaderapi.h" +#include "materialsystem/imesh.h" +#include "tier0/dbg.h" +#include "materialsystem/idebugtextureinfo.h" +#include "materialsystem/deformations.h" +#include "meshgl.h" +#include "shaderapidevicegl.h" +#include "shaderapigl.h" +#include "shadershadowgl.h" + +//----------------------------------------------------------------------------- +// +// Shader API GL +// +//----------------------------------------------------------------------------- + +CShaderAPIGL::CShaderAPIGL() : m_Mesh( false ) +{ +} + +CShaderAPIGL::~CShaderAPIGL() +{ +} + + +bool CShaderAPIGL::DoRenderTargetsNeedSeparateDepthBuffer() const +{ + return false; +} + +// Can we download textures? +bool CShaderAPIGL::CanDownloadTextures() const +{ + return false; +} + +// Used to clear the transition table when we know it's become invalid. +void CShaderAPIGL::ClearSnapshots() +{ +} + +// Members of IMaterialSystemHardwareConfig +bool CShaderAPIGL::HasDestAlphaBuffer() const +{ + return false; +} + +bool CShaderAPIGL::HasStencilBuffer() const +{ + return false; +} + +int CShaderAPIGL::MaxViewports() const +{ + return 1; +} + +int CShaderAPIGL::GetShadowFilterMode() const +{ + return 0; +} + +int CShaderAPIGL::StencilBufferBits() const +{ + return 0; +} + +int CShaderAPIGL::GetFrameBufferColorDepth() const +{ + return 0; +} + +int CShaderAPIGL::GetSamplerCount() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 60)) + return 1; + if (( ShaderUtil()->GetConfig().dxSupportLevel >= 60 ) && ( ShaderUtil()->GetConfig().dxSupportLevel < 80 )) + return 2; + return 4; +} + +bool CShaderAPIGL::HasSetDeviceGammaRamp() const +{ + return false; +} + +bool CShaderAPIGL::SupportsCompressedTextures() const +{ + return false; +} + +VertexCompressionType_t CShaderAPIGL::SupportsCompressedVertices() const +{ + return VERTEX_COMPRESSION_NONE; +} + +bool CShaderAPIGL::SupportsVertexAndPixelShaders() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 80)) + return false; + + return true; +} + +bool CShaderAPIGL::SupportsPixelShaders_1_4() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 81)) + return false; + + return true; +} + +bool CShaderAPIGL::SupportsPixelShaders_2_0() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 90)) + return false; + + return true; +} + +bool CShaderAPIGL::SupportsPixelShaders_2_b() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 90)) + return false; + + return true; +} + +bool CShaderAPIGL::ActuallySupportsPixelShaders_2_b() const +{ + return true; +} + +bool CShaderAPIGL::SupportsShaderModel_3_0() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 95)) + return false; + + return true; +} + +bool CShaderAPIGL::SupportsStaticControlFlow() const +{ + if ( IsOpenGL() ) + return false; + + return SupportsVertexShaders_2_0(); +} + +bool CShaderAPIGL::SupportsVertexShaders_2_0() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 90)) + return false; + + return true; +} + +int CShaderAPIGL::MaximumAnisotropicLevel() const +{ + return 0; +} + +void CShaderAPIGL::SetAnisotropicLevel( int nAnisotropyLevel ) +{ +} + +int CShaderAPIGL::MaxTextureWidth() const +{ + // Should be big enough to cover all cases + return 16384; +} + +int CShaderAPIGL::MaxTextureHeight() const +{ + // Should be big enough to cover all cases + return 16384; +} + +int CShaderAPIGL::MaxTextureAspectRatio() const +{ + // Should be big enough to cover all cases + return 16384; +} + + +int CShaderAPIGL::TextureMemorySize() const +{ + // fake it + return 64 * 1024 * 1024; +} + +int CShaderAPIGL::GetDXSupportLevel() const +{ + return 90; +} + +bool CShaderAPIGL::SupportsOverbright() const +{ + return false; +} + +bool CShaderAPIGL::SupportsCubeMaps() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 70)) + return false; + + return true; +} + +bool CShaderAPIGL::SupportsNonPow2Textures() const +{ + return true; +} + +bool CShaderAPIGL::SupportsMipmappedCubemaps() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 70)) + return false; + + return true; +} + +int CShaderAPIGL::GetTextureStageCount() const +{ + return 4; +} + +int CShaderAPIGL::NumVertexShaderConstants() const +{ + return 128; +} + +int CShaderAPIGL::NumBooleanVertexShaderConstants() const +{ + return 0; +} + +int CShaderAPIGL::NumIntegerVertexShaderConstants() const +{ + return 0; +} + +int CShaderAPIGL::NumPixelShaderConstants() const +{ + return 8; +} + +int CShaderAPIGL::MaxNumLights() const +{ + return 4; +} + +bool CShaderAPIGL::SupportsSpheremapping() const +{ + return false; +} + + +// This is the max dx support level supported by the card +int CShaderAPIGL::GetMaxDXSupportLevel() const +{ + return 90; +} + +bool CShaderAPIGL::SupportsHardwareLighting() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 70)) + return false; + + return true; +} + +int CShaderAPIGL::MaxBlendMatrices() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 70)) + { + return 1; + } + + return 0; +} + +int CShaderAPIGL::MaxBlendMatrixIndices() const +{ + if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) && + (ShaderUtil()->GetConfig().dxSupportLevel < 70)) + { + return 1; + } + + return 0; +} + +int CShaderAPIGL::MaxVertexShaderBlendMatrices() const +{ + return 0; +} + +int CShaderAPIGL::MaxUserClipPlanes() const +{ + return 0; +} + +bool CShaderAPIGL::SpecifiesFogColorInLinearSpace() const +{ + return false; +} + +bool CShaderAPIGL::SupportsSRGB() const +{ + return false; +} + +bool CShaderAPIGL::FakeSRGBWrite() const +{ + return false; +} + +bool CShaderAPIGL::CanDoSRGBReadFromRTs() const +{ + return true; +} + +bool CShaderAPIGL::SupportsGLMixedSizeTargets() const +{ + return false; +} + +const char *CShaderAPIGL::GetHWSpecificShaderDLLName() const +{ + return 0; +} + +// Sets the default *dynamic* state +void CShaderAPIGL::SetDefaultState() +{ +} + + +// Returns the snapshot id for the shader state +StateSnapshot_t CShaderAPIGL::TakeSnapshot( ) +{ + StateSnapshot_t id = 0; + if (g_ShaderShadow.m_IsTranslucent) + id |= TRANSLUCENT; + if (g_ShaderShadow.m_IsAlphaTested) + id |= ALPHATESTED; + if (g_ShaderShadow.m_bUsesVertexAndPixelShaders) + id |= VERTEX_AND_PIXEL_SHADERS; + if (g_ShaderShadow.m_bIsDepthWriteEnabled) + id |= DEPTHWRITE; + return id; +} + +// Returns true if the state snapshot is transparent +bool CShaderAPIGL::IsTranslucent( StateSnapshot_t id ) const +{ + return (id & TRANSLUCENT) != 0; +} + +bool CShaderAPIGL::IsAlphaTested( StateSnapshot_t id ) const +{ + return (id & ALPHATESTED) != 0; +} + +bool CShaderAPIGL::IsDepthWriteEnabled( StateSnapshot_t id ) const +{ + return (id & DEPTHWRITE) != 0; +} + +bool CShaderAPIGL::UsesVertexAndPixelShaders( StateSnapshot_t id ) const +{ + return (id & VERTEX_AND_PIXEL_SHADERS) != 0; +} + +// Gets the vertex format for a set of snapshot ids +VertexFormat_t CShaderAPIGL::ComputeVertexFormat( int numSnapshots, StateSnapshot_t* pIds ) const +{ + return 0; +} + +// Gets the vertex format for a set of snapshot ids +VertexFormat_t CShaderAPIGL::ComputeVertexUsage( int numSnapshots, StateSnapshot_t* pIds ) const +{ + return 0; +} + +// Uses a state snapshot +void CShaderAPIGL::UseSnapshot( StateSnapshot_t snapshot ) +{ +} + +// Sets the color to modulate by +void CShaderAPIGL::Color3f( float r, float g, float b ) +{ +} + +void CShaderAPIGL::Color3fv( float const* pColor ) +{ +} + +void CShaderAPIGL::Color4f( float r, float g, float b, float a ) +{ +} + +void CShaderAPIGL::Color4fv( float const* pColor ) +{ +} + +// Faster versions of color +void CShaderAPIGL::Color3ub( unsigned char r, unsigned char g, unsigned char b ) +{ +} + +void CShaderAPIGL::Color3ubv( unsigned char const* rgb ) +{ +} + +void CShaderAPIGL::Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) +{ +} + +void CShaderAPIGL::Color4ubv( unsigned char const* rgba ) +{ +} + +// The shade mode +void CShaderAPIGL::ShadeMode( ShaderShadeMode_t mode ) +{ +} + +// Binds a particular material to render with +void CShaderAPIGL::Bind( IMaterial* pMaterial ) +{ +} + +// Cull mode +void CShaderAPIGL::CullMode( MaterialCullMode_t cullMode ) +{ +} + +void CShaderAPIGL::ForceDepthFuncEquals( bool bEnable ) +{ +} + +// Forces Z buffering on or off +void CShaderAPIGL::OverrideDepthEnable( bool bEnable, bool bDepthEnable ) +{ +} + +void CShaderAPIGL::OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable ) +{ +} + +void CShaderAPIGL::OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable ) +{ +} + +//legacy fast clipping linkage +void CShaderAPIGL::SetHeightClipZ( float z ) +{ +} + +void CShaderAPIGL::SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode ) +{ +} + +// Sets the lights +void CShaderAPIGL::SetLight( int lightNum, const LightDesc_t& desc ) +{ +} + +// Sets lighting origin for the current model +void CShaderAPIGL::SetLightingOrigin( Vector vLightingOrigin ) +{ +} + +void CShaderAPIGL::SetAmbientLight( float r, float g, float b ) +{ +} + +void CShaderAPIGL::SetAmbientLightCube( Vector4D cube[6] ) +{ +} + +// Get lights +int CShaderAPIGL::GetMaxLights( void ) const +{ + return 0; +} + +const LightDesc_t& CShaderAPIGL::GetLight( int lightNum ) const +{ + static LightDesc_t blah; + return blah; +} + +// Render state for the ambient light cube (vertex shaders) +void CShaderAPIGL::SetVertexShaderStateAmbientLightCube() +{ +} + +void CShaderAPIGL::SetSkinningMatrices() +{ +} + +// Lightmap texture binding +void CShaderAPIGL::BindLightmap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindBumpLightmap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindFullbrightLightmap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindWhite( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindBlack( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindGrey( TextureStage_t stage ) +{ +} + +// Gets the lightmap dimensions +void CShaderAPIGL::GetLightmapDimensions( int *w, int *h ) +{ + g_pShaderUtil->GetLightmapDimensions( w, h ); +} + +// Special system flat normal map binding. +void CShaderAPIGL::BindFlatNormalMap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindNormalizationCubeMap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindSignedNormalizationCubeMap( TextureStage_t stage ) +{ +} + +void CShaderAPIGL::BindFBTexture( TextureStage_t stage, int textureIndex ) +{ +} + +// Flushes any primitives that are buffered +void CShaderAPIGL::FlushBufferedPrimitives() +{ +} + +// 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. +IMesh* CShaderAPIGL::GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ) +{ + return &m_Mesh; +} + +IMesh* CShaderAPIGL::GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t fmt, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ) +{ + return &m_Mesh; +} + +IMesh* CShaderAPIGL::GetFlexMesh() +{ + return &m_Mesh; +} + +// Begins a rendering pass that uses a state snapshot +void CShaderAPIGL::BeginPass( StateSnapshot_t snapshot ) +{ +} + +// Renders a single pass of a material +void CShaderAPIGL::RenderPass( int nPass, int nPassCount ) +{ +} + +// stuff related to matrix stacks +void CShaderAPIGL::MatrixMode( MaterialMatrixMode_t matrixMode ) +{ +} + +void CShaderAPIGL::PushMatrix() +{ +} + +void CShaderAPIGL::PopMatrix() +{ +} + +void CShaderAPIGL::LoadMatrix( float *m ) +{ +} + +void CShaderAPIGL::MultMatrix( float *m ) +{ +} + +void CShaderAPIGL::MultMatrixLocal( float *m ) +{ +} + +void CShaderAPIGL::GetMatrix( MaterialMatrixMode_t matrixMode, float *dst ) +{ +} + +void CShaderAPIGL::LoadIdentity( void ) +{ +} + +void CShaderAPIGL::LoadCameraToWorld( void ) +{ +} + +void CShaderAPIGL::Ortho( double left, double top, double right, double bottom, double zNear, double zFar ) +{ +} + +void CShaderAPIGL::PerspectiveX( double fovx, double aspect, double zNear, double zFar ) +{ +} + +void CShaderAPIGL::PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right ) +{ +} + +void CShaderAPIGL::PickMatrix( int x, int y, int width, int height ) +{ +} + +void CShaderAPIGL::Rotate( float angle, float x, float y, float z ) +{ +} + +void CShaderAPIGL::Translate( float x, float y, float z ) +{ +} + +void CShaderAPIGL::Scale( float x, float y, float z ) +{ +} + +void CShaderAPIGL::ScaleXY( float x, float y ) +{ +} + +// Fog methods... +void CShaderAPIGL::FogMode( MaterialFogMode_t fogMode ) +{ +} + +void CShaderAPIGL::FogStart( float fStart ) +{ +} + +void CShaderAPIGL::FogEnd( float fEnd ) +{ +} + +void CShaderAPIGL::SetFogZ( float fogZ ) +{ +} + +void CShaderAPIGL::FogMaxDensity( float flMaxDensity ) +{ +} + +void CShaderAPIGL::GetFogDistances( float *fStart, float *fEnd, float *fFogZ ) +{ +} + + +void CShaderAPIGL::SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b ) +{ +} + + +void CShaderAPIGL::SceneFogMode( MaterialFogMode_t fogMode ) +{ +} + +void CShaderAPIGL::GetSceneFogColor( unsigned char *rgb ) +{ +} + +MaterialFogMode_t CShaderAPIGL::GetSceneFogMode( ) +{ + return MATERIAL_FOG_NONE; +} + +int CShaderAPIGL::GetPixelFogCombo( ) +{ + return 0; +} + +void CShaderAPIGL::FogColor3f( float r, float g, float b ) +{ +} + +void CShaderAPIGL::FogColor3fv( float const* rgb ) +{ +} + +void CShaderAPIGL::FogColor3ub( unsigned char r, unsigned char g, unsigned char b ) +{ +} + +void CShaderAPIGL::FogColor3ubv( unsigned char const* rgb ) +{ +} + +void CShaderAPIGL::SetViewports( int nCount, const ShaderViewport_t* pViewports ) +{ +} + +int CShaderAPIGL::GetViewports( ShaderViewport_t* pViewports, int nMax ) const +{ + return 1; +} + +// Sets the vertex and pixel shaders +void CShaderAPIGL::SetVertexShaderIndex( int vshIndex ) +{ +} + +void CShaderAPIGL::SetPixelShaderIndex( int pshIndex ) +{ +} + +// Sets the constant registers for vertex and pixel shaders +void CShaderAPIGL::SetVertexShaderConstant( int var, float const* pVec, int numConst, bool bForce ) +{ +} + +void CShaderAPIGL::SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numConst, bool bForce ) +{ +} + +void CShaderAPIGL::SetIntegerVertexShaderConstant( int var, int const* pVec, int numConst, bool bForce ) +{ +} + +void CShaderAPIGL::SetPixelShaderConstant( int var, float const* pVec, int numConst, bool bForce ) +{ +} + +void CShaderAPIGL::SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools, bool bForce ) +{ +} + +void CShaderAPIGL::SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs, bool bForce ) +{ +} + +void CShaderAPIGL::InvalidateDelayedShaderConstants( void ) +{ +} + +float CShaderAPIGL::GammaToLinear_HardwareSpecific( float fGamma ) const +{ + return 0.0f; +} + +float CShaderAPIGL::LinearToGamma_HardwareSpecific( float fLinear ) const +{ + return 0.0f; +} + +void CShaderAPIGL::SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture ) +{ +} + + +// Returns the nearest supported format +ImageFormat CShaderAPIGL::GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired /* = true */ ) const +{ + return fmt; +} + +ImageFormat CShaderAPIGL::GetNearestRenderTargetFormat( ImageFormat fmt ) const +{ + return fmt; +} + +// Sets the texture state +void CShaderAPIGL::BindTexture( Sampler_t stage, ShaderAPITextureHandle_t textureHandle ) +{ +} + +void CShaderAPIGL::ClearColor3ub( unsigned char r, unsigned char g, unsigned char b ) +{ +} + +void CShaderAPIGL::ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) +{ +} + +// Indicates we're going to be modifying this texture +// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter +// all use the texture specified by this function. +void CShaderAPIGL::ModifyTexture( ShaderAPITextureHandle_t textureHandle ) +{ +} + +// Texture management methods +void CShaderAPIGL::TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int zOffset, int width, int height, + ImageFormat srcFormat, bool bSrcIsTiled, void *imageData ) +{ +} + +void CShaderAPIGL::TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int zOffset, int width, int height, + ImageFormat srcFormat, int srcStride, bool bSrcIsTiled, void *imageData ) +{ +} + +void CShaderAPIGL::TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame ) +{ +} + +bool CShaderAPIGL::TexLock( int level, int cubeFaceID, int xOffset, int yOffset, + int width, int height, CPixelWriter& writer ) +{ + return false; +} + +void CShaderAPIGL::TexUnlock( ) +{ +} + + +// These are bound to the texture, not the texture environment +void CShaderAPIGL::TexMinFilter( ShaderTexFilterMode_t texFilterMode ) +{ +} + +void CShaderAPIGL::TexMagFilter( ShaderTexFilterMode_t texFilterMode ) +{ +} + +void CShaderAPIGL::TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode ) +{ +} + +void CShaderAPIGL::TexSetPriority( int priority ) +{ +} + +ShaderAPITextureHandle_t CShaderAPIGL::CreateTexture( + int width, + int height, + int depth, + ImageFormat dstImageFormat, + int numMipLevels, + int numCopies, + int flags, + const char *pDebugName, + const char *pTextureGroupName ) +{ + return 0; +} + +// Create a multi-frame texture (equivalent to calling "CreateTexture" multiple times, but more efficient) +void CShaderAPIGL::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 ) +{ + for ( int k = 0; k < count; ++ k ) + pHandles[ k ] = 0; +} + + +ShaderAPITextureHandle_t CShaderAPIGL::CreateDepthTexture( ImageFormat renderFormat, int width, int height, const char *pDebugName, bool bTexture ) +{ + return 0; +} + +void CShaderAPIGL::DeleteTexture( ShaderAPITextureHandle_t textureHandle ) +{ +} + +bool CShaderAPIGL::IsTexture( ShaderAPITextureHandle_t textureHandle ) +{ + return true; +} + +bool CShaderAPIGL::IsTextureResident( ShaderAPITextureHandle_t textureHandle ) +{ + return false; +} + +// stuff that isn't to be used from within a shader +void CShaderAPIGL::ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight ) +{ +} + +void CShaderAPIGL::ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth ) +{ +} + +void CShaderAPIGL::ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ) +{ +} + +void CShaderAPIGL::PerformFullScreenStencilOperation( void ) +{ +} + +void CShaderAPIGL::SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor ) +{ +} + +void CShaderAPIGL::ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat ) +{ +} + +void CShaderAPIGL::ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride ) +{ +} + +void CShaderAPIGL::FlushHardware() +{ +} + +void CShaderAPIGL::ResetRenderState( bool bFullReset ) +{ +} + +// Set the number of bone weights +void CShaderAPIGL::SetNumBoneWeights( int numBones ) +{ +} + +void CShaderAPIGL::EnableHWMorphing( bool bEnable ) +{ +} + +// Selection mode methods +int CShaderAPIGL::SelectionMode( bool selectionMode ) +{ + return 0; +} + +void CShaderAPIGL::SelectionBuffer( unsigned int* pBuffer, int size ) +{ +} + +void CShaderAPIGL::ClearSelectionNames( ) +{ +} + +void CShaderAPIGL::LoadSelectionName( int name ) +{ +} + +void CShaderAPIGL::PushSelectionName( int name ) +{ +} + +void CShaderAPIGL::PopSelectionName() +{ +} + + +// Use this to get the mesh builder that allows us to modify vertex data +CMeshBuilder* CShaderAPIGL::GetVertexModifyBuilder() +{ + return 0; +} + +// Board-independent calls, here to unify how shaders set state +// Implementations should chain back to IShaderUtil->BindTexture(), etc. + +// Use this to begin and end the frame +void CShaderAPIGL::BeginFrame() +{ +} + +void CShaderAPIGL::EndFrame() +{ +} + +// returns the current time in seconds.... +double CShaderAPIGL::CurrentTime() const +{ + return Sys_FloatTime(); +} + +// Get the current camera position in world space. +void CShaderAPIGL::GetWorldSpaceCameraPosition( float * pPos ) const +{ +} + +void CShaderAPIGL::ForceHardwareSync( void ) +{ +} + +void CShaderAPIGL::SetClipPlane( int index, const float *pPlane ) +{ +} + +void CShaderAPIGL::EnableClipPlane( int index, bool bEnable ) +{ +} + +void CShaderAPIGL::SetFastClipPlane( const float *pPlane ) +{ +} + +void CShaderAPIGL::EnableFastClip( bool bEnable ) +{ +} + +int CShaderAPIGL::GetCurrentNumBones( void ) const +{ + return 0; +} + +bool CShaderAPIGL::IsHWMorphingEnabled( void ) const +{ + return false; +} + +int CShaderAPIGL::GetCurrentLightCombo( void ) const +{ + return 0; +} + +void CShaderAPIGL::GetDX9LightState( LightState_t *state ) const +{ + state->m_nNumLights = 0; + state->m_bAmbientLight = false; + state->m_bStaticLightVertex = false; + state->m_bStaticLightTexel = false; +} + +MaterialFogMode_t CShaderAPIGL::GetCurrentFogType( void ) const +{ + return MATERIAL_FOG_NONE; +} + +void CShaderAPIGL::RecordString( const char *pStr ) +{ +} + +bool CShaderAPIGL::ReadPixelsFromFrontBuffer() const +{ + return true; +} + +bool CShaderAPIGL::PreferDynamicTextures() const +{ + return false; +} + +bool CShaderAPIGL::PreferReducedFillrate() const +{ + return false; +} + +bool CShaderAPIGL::HasProjectedBumpEnv() const +{ + return true; +} + +int CShaderAPIGL::GetCurrentDynamicVBSize( void ) +{ + return 0; +} + +void CShaderAPIGL::DestroyVertexBuffers( bool bExitingLevel ) +{ +} + +void CShaderAPIGL::EvictManagedResources() +{ +} + +void CShaderAPIGL::SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected ) +{ +} + +void CShaderAPIGL::SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 ) +{ +} + +void CShaderAPIGL::SyncToken( const char *pToken ) +{ +} + +void CShaderAPIGL::GetBackBufferDimensions( int& width, int& height ) const +{ + s_ShaderDeviceGL.GetBackBufferDimensions( width, height ); +} + +void CShaderAPIGL::GetCurrentColorCorrection( ShaderColorCorrectionInfo_t* pInfo ) +{ + pInfo->m_bIsEnabled = false; + pInfo->m_nLookupCount = 0; + pInfo->m_flDefaultWeight = 0.0f; +} diff --git a/materialsystem/shaderapigl/shaderapigl.h b/materialsystem/shaderapigl/shaderapigl.h new file mode 100644 index 00000000..d545e23b --- /dev/null +++ b/materialsystem/shaderapigl/shaderapigl.h @@ -0,0 +1,887 @@ +#ifndef SHADERAPIGL_H +#define SHADERAPIGL_H + +#include "IHardwareConfigInternal.h" + +//----------------------------------------------------------------------------- +// The DX8 implementation of the shader API +//----------------------------------------------------------------------------- +class CShaderAPIGL : public IShaderAPI, public IHardwareConfigInternal, public IDebugTextureInfo +{ +public: + // constructor, destructor + CShaderAPIGL( ); + virtual ~CShaderAPIGL(); + + // IDebugTextureInfo implementation. +public: + + virtual bool IsDebugTextureListFresh( int numFramesAllowed = 1 ) { return false; } + virtual bool SetDebugTextureRendering( bool bEnable ) { return false; } + virtual void EnableDebugTextureList( bool bEnable ) {} + virtual void EnableGetAllTextures( bool bEnable ) {} + virtual KeyValues* GetDebugTextureList() { return NULL; } + virtual int GetTextureMemoryUsed( TextureMemoryType eTextureMemory ) { return 0; } + + // Methods of IShaderDynamicAPI + virtual void GetBackBufferDimensions( int& width, int& height ) const; + virtual void GetCurrentColorCorrection( ShaderColorCorrectionInfo_t* pInfo ); + + // Methods of IShaderAPI +public: + virtual void SetViewports( int nCount, const ShaderViewport_t* pViewports ); + virtual int GetViewports( ShaderViewport_t* pViewports, int nMax ) const; + virtual void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight ); + virtual void ClearColor3ub( unsigned char r, unsigned char g, unsigned char b ); + virtual void ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ); + virtual void BindVertexShader( VertexShaderHandle_t hVertexShader ) {} + virtual void BindGeometryShader( GeometryShaderHandle_t hGeometryShader ) {} + virtual void BindPixelShader( PixelShaderHandle_t hPixelShader ) {} + virtual void SetRasterState( const ShaderRasterState_t& state ) {} + virtual void MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords ) {} + virtual bool OwnGPUResources( bool bEnable ) { return false; } + + virtual bool DoRenderTargetsNeedSeparateDepthBuffer() const; + + // Used to clear the transition table when we know it's become invalid. + void ClearSnapshots(); + + // Sets the mode... + bool SetMode( void* hwnd, int nAdapter, const ShaderDeviceInfo_t &info ) + { + return true; + } + + void ChangeVideoMode( const ShaderDeviceInfo_t &info ) + { + } + + // Called when the dx support level has changed + virtual void DXSupportLevelChanged() {} + + virtual void EnableUserClipTransformOverride( bool bEnable ) {} + virtual void UserClipTransform( const VMatrix &worldToView ) {} + + // Sets the default *dynamic* state + void SetDefaultState( ); + + // Returns the snapshot id for the shader state + StateSnapshot_t TakeSnapshot( ); + + // Returns true if the state snapshot is transparent + bool IsTranslucent( StateSnapshot_t id ) const; + bool IsAlphaTested( StateSnapshot_t id ) const; + bool UsesVertexAndPixelShaders( StateSnapshot_t id ) const; + virtual bool IsDepthWriteEnabled( StateSnapshot_t id ) const; + + // Gets the vertex format for a set of snapshot ids + VertexFormat_t ComputeVertexFormat( int numSnapshots, StateSnapshot_t* pIds ) const; + + // Gets the vertex format for a set of snapshot ids + VertexFormat_t ComputeVertexUsage( int numSnapshots, StateSnapshot_t* pIds ) const; + + // Begins a rendering pass that uses a state snapshot + void BeginPass( StateSnapshot_t snapshot ); + + // Uses a state snapshot + void UseSnapshot( StateSnapshot_t snapshot ); + + // Use this to get the mesh builder that allows us to modify vertex data + CMeshBuilder* GetVertexModifyBuilder(); + + // Sets the color to modulate by + void Color3f( float r, float g, float b ); + void Color3fv( float const* pColor ); + void Color4f( float r, float g, float b, float a ); + void Color4fv( float const* pColor ); + + // Faster versions of color + void Color3ub( unsigned char r, unsigned char g, unsigned char b ); + void Color3ubv( unsigned char const* rgb ); + void Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ); + void Color4ubv( unsigned char const* rgba ); + + // Sets the lights + void SetLight( int lightNum, const LightDesc_t& desc ); + void SetLightingOrigin( Vector vLightingOrigin ); + void SetAmbientLight( float r, float g, float b ); + void SetAmbientLightCube( Vector4D cube[6] ); + + // Get the lights + int GetMaxLights( void ) const; + const LightDesc_t& GetLight( int lightNum ) const; + + // Render state for the ambient light cube (vertex shaders) + void SetVertexShaderStateAmbientLightCube(); + void SetPixelShaderStateAmbientLightCube( int pshReg, bool bForceToBlack = false ) + { + } + + float GetAmbientLightCubeLuminance(void) + { + return 0.0f; + } + + void SetSkinningMatrices(); + + // Lightmap texture binding + void BindLightmap( TextureStage_t stage ); + void BindLightmapAlpha( TextureStage_t stage ) + { + } + void BindBumpLightmap( TextureStage_t stage ); + void BindFullbrightLightmap( TextureStage_t stage ); + void BindWhite( TextureStage_t stage ); + void BindBlack( TextureStage_t stage ); + void BindGrey( TextureStage_t stage ); + void BindFBTexture( TextureStage_t stage, int textureIdex ); + void CopyRenderTargetToTexture( ShaderAPITextureHandle_t texID ) + { + } + + void CopyRenderTargetToTextureEx( ShaderAPITextureHandle_t texID, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect ) + { + } + + void CopyTextureToRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t textureHandle, Rect_t *pSrcRect, Rect_t *pDstRect ) + { + } + + // Special system flat normal map binding. + void BindFlatNormalMap( TextureStage_t stage ); + void BindNormalizationCubeMap( TextureStage_t stage ); + void BindSignedNormalizationCubeMap( TextureStage_t stage ); + + // Set the number of bone weights + void SetNumBoneWeights( int numBones ); + void EnableHWMorphing( bool bEnable ); + + // Flushes any primitives that are buffered + void FlushBufferedPrimitives(); + + // 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. + IMesh* GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ); + IMesh* GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t fmt, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ); + + IMesh* GetFlexMesh(); + + // Renders a single pass of a material + void RenderPass( int nPass, int nPassCount ); + + // stuff related to matrix stacks + void MatrixMode( MaterialMatrixMode_t matrixMode ); + void PushMatrix(); + void PopMatrix(); + void LoadMatrix( float *m ); + void LoadBoneMatrix( int boneIndex, const float *m ) {} + void MultMatrix( float *m ); + void MultMatrixLocal( float *m ); + void GetMatrix( MaterialMatrixMode_t matrixMode, float *dst ); + void LoadIdentity( void ); + void LoadCameraToWorld( void ); + void Ortho( double left, double top, double right, double bottom, double zNear, double zFar ); + void PerspectiveX( double fovx, double aspect, double zNear, double zFar ); + void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right ); + void PickMatrix( int x, int y, int width, int height ); + void Rotate( float angle, float x, float y, float z ); + void Translate( float x, float y, float z ); + void Scale( float x, float y, float z ); + void ScaleXY( float x, float y ); + + // Fog methods... + void FogMode( MaterialFogMode_t fogMode ); + void FogStart( float fStart ); + void FogEnd( float fEnd ); + void SetFogZ( float fogZ ); + void FogMaxDensity( float flMaxDensity ); + void GetFogDistances( float *fStart, float *fEnd, float *fFogZ ); + void FogColor3f( float r, float g, float b ); + void FogColor3fv( float const* rgb ); + void FogColor3ub( unsigned char r, unsigned char g, unsigned char b ); + void FogColor3ubv( unsigned char const* rgb ); + + virtual void SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b ); + virtual void SceneFogMode( MaterialFogMode_t fogMode ); + virtual void GetSceneFogColor( unsigned char *rgb ); + virtual MaterialFogMode_t GetSceneFogMode( ); + virtual int GetPixelFogCombo( ); + + void SetHeightClipZ( float z ); + void SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode ); + + void SetClipPlane( int index, const float *pPlane ); + void EnableClipPlane( int index, bool bEnable ); + + void SetFastClipPlane( const float *pPlane ); + void EnableFastClip( bool bEnable ); + + // We use smaller dynamic VBs during level transitions, to free up memory + virtual int GetCurrentDynamicVBSize( void ); + virtual void DestroyVertexBuffers( bool bExitingLevel = false ); + + // Sets the vertex and pixel shaders + void SetVertexShaderIndex( int vshIndex ); + void SetPixelShaderIndex( int pshIndex ); + + // Sets the constant register for vertex and pixel shaders + void SetVertexShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false ); + void SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numConst = 1, bool bForce = false ); + void SetIntegerVertexShaderConstant( int var, int const* pVec, int numConst = 1, bool bForce = false ); + void SetPixelShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false ); + void SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false ); + void SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false ); + + void InvalidateDelayedShaderConstants( void ); + + // Gamma<->Linear conversions according to the video hardware we're running on + float GammaToLinear_HardwareSpecific( float fGamma ) const; + float LinearToGamma_HardwareSpecific( float fLinear ) const; + + //Set's the linear->gamma conversion textures to use for this hardware for both srgb writes enabled and disabled(identity) + void SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture ); + + // Cull mode + void CullMode( MaterialCullMode_t cullMode ); + + // Force writes only when z matches. . . useful for stenciling things out + // by rendering the desired Z values ahead of time. + void ForceDepthFuncEquals( bool bEnable ); + + // Forces Z buffering on or off + void OverrideDepthEnable( bool bEnable, bool bDepthEnable ); + void OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable ); + void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable ); + + // Sets the shade mode + void ShadeMode( ShaderShadeMode_t mode ); + + // Binds a particular material to render with + void Bind( IMaterial* pMaterial ); + + // Returns the nearest supported format + ImageFormat GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired = true ) const; + ImageFormat GetNearestRenderTargetFormat( ImageFormat fmt ) const; + + // Sets the texture state + void BindTexture( Sampler_t stage, ShaderAPITextureHandle_t textureHandle ); + + void SetRenderTarget( ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle ) + { + } + + void SetRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle ) + { + } + + // Indicates we're going to be modifying this texture + // TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter + // all use the texture specified by this function. + void ModifyTexture( ShaderAPITextureHandle_t textureHandle ); + + // Texture management methods + void TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int zOffset, int width, int height, + ImageFormat srcFormat, bool bSrcIsTiled, void *imageData ); + void TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int zOffset, int width, int height, + ImageFormat srcFormat, int srcStride, bool bSrcIsTiled, void *imageData ); + + void TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame ); + + bool TexLock( int level, int cubeFaceID, int xOffset, int yOffset, + int width, int height, CPixelWriter& writer ); + void TexUnlock( ); + + // These are bound to the texture, not the texture environment + void TexMinFilter( ShaderTexFilterMode_t texFilterMode ); + void TexMagFilter( ShaderTexFilterMode_t texFilterMode ); + void TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode ); + void TexSetPriority( int priority ); + + ShaderAPITextureHandle_t CreateTexture( + int width, + int height, + int depth, + ImageFormat dstImageFormat, + int numMipLevels, + int numCopies, + int flags, + const char *pDebugName, + const char *pTextureGroupName ); + // Create a multi-frame texture (equivalent to calling "CreateTexture" multiple times, but more efficient) + 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 ); + ShaderAPITextureHandle_t CreateDepthTexture( ImageFormat renderFormat, int width, int height, const char *pDebugName, bool bTexture ); + void DeleteTexture( ShaderAPITextureHandle_t textureHandle ); + bool IsTexture( ShaderAPITextureHandle_t textureHandle ); + bool IsTextureResident( ShaderAPITextureHandle_t textureHandle ); + + // stuff that isn't to be used from within a shader + void ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth ); + void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ); + void PerformFullScreenStencilOperation( void ); + void ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat ); + virtual void ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride ); + + // Selection mode methods + int SelectionMode( bool selectionMode ); + void SelectionBuffer( unsigned int* pBuffer, int size ); + void ClearSelectionNames( ); + void LoadSelectionName( int name ); + void PushSelectionName( int name ); + void PopSelectionName(); + + void FlushHardware(); + void ResetRenderState( bool bFullReset = true ); + + void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor ); + + // Can we download textures? + virtual bool CanDownloadTextures() const; + + // Board-independent calls, here to unify how shaders set state + // Implementations should chain back to IShaderUtil->BindTexture(), etc. + + // Use this to begin and end the frame + void BeginFrame(); + void EndFrame(); + + // returns current time + double CurrentTime() const; + + // Get the current camera position in world space. + void GetWorldSpaceCameraPosition( float * pPos ) const; + + // Members of IMaterialSystemHardwareConfig + bool HasDestAlphaBuffer() const; + bool HasStencilBuffer() const; + virtual int MaxViewports() const; + virtual void OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport ) {} + virtual int GetShadowFilterMode() const; + int StencilBufferBits() const; + int GetFrameBufferColorDepth() const; + int GetSamplerCount() const; + bool HasSetDeviceGammaRamp() const; + bool SupportsCompressedTextures() const; + VertexCompressionType_t SupportsCompressedVertices() const; + bool SupportsVertexAndPixelShaders() const; + bool SupportsPixelShaders_1_4() const; + bool SupportsPixelShaders_2_0() const; + bool SupportsPixelShaders_2_b() const; + bool ActuallySupportsPixelShaders_2_b() const; + bool SupportsStaticControlFlow() const; + bool SupportsVertexShaders_2_0() const; + bool SupportsShaderModel_3_0() const; + int MaximumAnisotropicLevel() const; + int MaxTextureWidth() const; + int MaxTextureHeight() const; + int MaxTextureAspectRatio() const; + int GetDXSupportLevel() const; + const char *GetShaderDLLName() const + { + return "GL"; + } + int TextureMemorySize() const; + bool SupportsOverbright() const; + bool SupportsCubeMaps() const; + bool SupportsMipmappedCubemaps() const; + bool SupportsNonPow2Textures() const; + int GetTextureStageCount() const; + int NumVertexShaderConstants() const; + int NumBooleanVertexShaderConstants() const; + int NumIntegerVertexShaderConstants() const; + int NumPixelShaderConstants() const; + int MaxNumLights() const; + bool SupportsHardwareLighting() const; + int MaxBlendMatrices() const; + int MaxBlendMatrixIndices() const; + int MaxVertexShaderBlendMatrices() const; + int MaxUserClipPlanes() const; + bool UseFastClipping() const + { + return false; + } + bool SpecifiesFogColorInLinearSpace() const; + virtual bool SupportsSRGB() const; + virtual bool FakeSRGBWrite() const; + virtual bool CanDoSRGBReadFromRTs() const; + virtual bool SupportsGLMixedSizeTargets() const; + + const char *GetHWSpecificShaderDLLName() const; + bool NeedsAAClamp() const + { + return false; + } + bool SupportsSpheremapping() const; + virtual int MaxHWMorphBatchCount() const { return 0; } + + // This is the max dx support level supported by the card + virtual int GetMaxDXSupportLevel() const; + + bool ReadPixelsFromFrontBuffer() const; + bool PreferDynamicTextures() const; + virtual bool PreferReducedFillrate() const; + bool HasProjectedBumpEnv() const; + void ForceHardwareSync( void ); + + int GetCurrentNumBones( void ) const; + bool IsHWMorphingEnabled( void ) const; + int GetCurrentLightCombo( void ) const; + void GetDX9LightState( LightState_t *state ) const; + MaterialFogMode_t GetCurrentFogType( void ) const; + + void RecordString( const char *pStr ); + + void EvictManagedResources(); + + void SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected ); + void DisableTextureTransform( TextureStage_t textureStage ) + { + } + void SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 ); + + // Gets the lightmap dimensions + virtual void GetLightmapDimensions( int *w, int *h ); + + virtual void SyncToken( const char *pToken ); + + // Setup standard vertex shader constants (that don't change) + // This needs to be called anytime that overbright changes. + virtual void SetStandardVertexShaderConstants( float fOverbright ) + { + } + + // Level of anisotropic filtering + virtual void SetAnisotropicLevel( int nAnisotropyLevel ); + + bool SupportsHDR() const + { + return false; + } + HDRType_t GetHDRType() const + { + return HDR_TYPE_NONE; + } + HDRType_t GetHardwareHDRType() const + { + return HDR_TYPE_NONE; + } + virtual bool NeedsATICentroidHack() const + { + return false; + } + virtual bool SupportsColorOnSecondStream() const + { + return false; + } + virtual bool SupportsStaticPlusDynamicLighting() const + { + return false; + } + virtual bool SupportsStreamOffset() const + { + return false; + } + void SetDefaultDynamicState() + { + } + virtual void CommitPixelShaderLighting( int pshReg ) + { + } + + ShaderAPIOcclusionQuery_t CreateOcclusionQueryObject( void ) + { + return INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE; + } + + void DestroyOcclusionQueryObject( ShaderAPIOcclusionQuery_t handle ) + { + } + + void BeginOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle ) + { + } + + void EndOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle ) + { + } + + int OcclusionQuery_GetNumPixelsRendered( ShaderAPIOcclusionQuery_t handle, bool bFlush ) + { + return 0; + } + + virtual void AcquireThreadOwnership() {} + virtual void ReleaseThreadOwnership() {} + + virtual bool SupportsBorderColor() const { return false; } + virtual bool SupportsFetch4() const { return false; } + virtual bool CanStretchRectFromTextures( void ) const { return false; } + virtual void EnableBuffer2FramesAhead( bool bEnable ) {} + + virtual void SetPSNearAndFarZ( int pshReg ) { } + + virtual void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale ) {} + + void SetPixelShaderFogParams( int reg ) + { + } + + virtual bool InFlashlightMode() const + { + return false; + } + + virtual bool InEditorMode() const + { + return false; + } + + // What fields in the morph do we actually use? + virtual MorphFormat_t ComputeMorphFormat( int numSnapshots, StateSnapshot_t* pIds ) const + { + return 0; + } + + // Gets the bound morph's vertex format; returns 0 if no morph is bound + virtual MorphFormat_t GetBoundMorphFormat() + { + return 0; + } + + // Binds a standard texture + virtual void BindStandardTexture( Sampler_t stage, StandardTextureId_t id ) + { + } + + virtual void BindStandardVertexTexture( VertexTextureSampler_t stage, StandardTextureId_t id ) + { + } + + virtual void GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id ) + { + *pWidth = *pHeight = 0; + } + + + virtual void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture ) + { + } + + virtual void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture ) + { + } + + virtual const FlashlightState_t &GetFlashlightState( VMatrix &worldToTexture ) const + { + static FlashlightState_t blah; + return blah; + } + + virtual const FlashlightState_t &GetFlashlightStateEx( VMatrix &worldToTexture, ITexture **pFlashlightDepthTexture ) const + { + static FlashlightState_t blah; + return blah; + } + + virtual void ClearVertexAndPixelShaderRefCounts() + { + } + + virtual void PurgeUnusedVertexAndPixelShaders() + { + } + + virtual bool IsAAEnabled() const + { + return false; + } + + virtual int GetVertexTextureCount() const + { + return 0; + } + + virtual int GetMaxVertexTextureDimension() const + { + return 0; + } + + virtual int MaxTextureDepth() const + { + return 0; + } + + // Binds a vertex texture to a particular texture stage in the vertex pipe + virtual void BindVertexTexture( VertexTextureSampler_t nSampler, ShaderAPITextureHandle_t hTexture ) + { + } + + // Sets morph target factors + virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights ) + { + } + + // NOTE: Stuff after this is added after shipping HL2. + ITexture *GetRenderTargetEx( int nRenderTargetID ) + { + return NULL; + } + + void SetToneMappingScaleLinear( const Vector &scale ) + { + } + + const Vector &GetToneMappingScaleLinear( void ) const + { + static Vector dummy; + return dummy; + } + + virtual float GetLightMapScaleFactor( void ) const + { + return 1.0; + } + + + // For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer) + virtual void HandleDeviceLost() + { + } + + virtual void EnableLinearColorSpaceFrameBuffer( bool bEnable ) + { + } + + // Lets the shader know about the full-screen texture so it can + virtual void SetFullScreenTextureHandle( ShaderAPITextureHandle_t h ) + { + } + + void SetFloatRenderingParameter(int parm_number, float value) + { + } + + void SetIntRenderingParameter(int parm_number, int value) + { + } + void SetVectorRenderingParameter(int parm_number, Vector const &value) + { + } + + float GetFloatRenderingParameter(int parm_number) const + { + return 0; + } + + int GetIntRenderingParameter(int parm_number) const + { + return 0; + } + + Vector GetVectorRenderingParameter(int parm_number) const + { + return Vector(0,0,0); + } + + // Methods related to stencil + void SetStencilEnable(bool onoff) + { + } + + void SetStencilFailOperation(StencilOperation_t op) + { + } + + void SetStencilZFailOperation(StencilOperation_t op) + { + } + + void SetStencilPassOperation(StencilOperation_t op) + { + } + + void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn) + { + } + + void SetStencilReferenceValue(int ref) + { + } + + void SetStencilTestMask(uint32 msk) + { + } + + void SetStencilWriteMask(uint32 msk) + { + } + + void ClearStencilBufferRectangle( int xmin, int ymin, int xmax, int ymax,int value) + { + } + + virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel) + { + max_dxlevel=recommended_dxlevel=90; + } + + virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices ) + { + *pMaxVerts = 32768; + *pMaxIndices = 32768; + } + + // Returns the max possible vertices + indices to render in a single draw call + virtual int GetMaxVerticesToRender( IMaterial *pMaterial ) + { + return 32768; + } + + virtual int GetMaxIndicesToRender( ) + { + return 32768; + } + virtual int CompareSnapshots( StateSnapshot_t snapshot0, StateSnapshot_t snapshot1 ) { return 0; } + + virtual void DisableAllLocalLights() {} + + virtual bool SupportsMSAAMode( int nMSAAMode ) { return false; } + + virtual bool SupportsCSAAMode( int nNumSamples, int nQualityLevel ) { return false; } + + // Hooks for firing PIX events from outside the Material System... + virtual void BeginPIXEvent( unsigned long color, const char *szName ) {} + virtual void EndPIXEvent() {} + virtual void SetPIXMarker( unsigned long color, const char *szName ) {} + + virtual void ComputeVertexDescription( unsigned char* pBuffer, VertexFormat_t vertexFormat, MeshDesc_t& desc ) const {} + + virtual bool SupportsShadowDepthTextures() { return false; } + + virtual bool SupportsFetch4() { return false; } + + virtual int NeedsShaderSRGBConversion(void) const { return 0; } + virtual bool UsesSRGBCorrectBlending() const { return false; } + + virtual bool HasFastVertexTextures() const { return false; } + + virtual void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias ) {} + + virtual void SetDisallowAccess( bool ) {} + virtual void EnableShaderShaderMutex( bool ) {} + virtual void ShaderLock() {} + virtual void ShaderUnlock() {} + +// ------------ New Vertex/Index Buffer interface ---------------------------- + void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions1 ) + { + } + void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes ) + { + } + void Draw( MaterialPrimitiveType_t primitiveType, int firstIndex, int numIndices ) + { + } +// ------------ End ---------------------------- + + virtual int GetVertexBufferCompression( void ) const { return 0; }; + + virtual bool ShouldWriteDepthToDestAlpha( void ) const { return false; }; + virtual bool SupportsHDRMode( HDRType_t nHDRMode ) const { return false; }; + virtual bool IsDX10Card() const { return false; }; + + void PushDeformation( const DeformationBase_t *pDeformation ) + { + } + + virtual void PopDeformation( ) + { + } + + int GetNumActiveDeformations( ) const + { + return 0; + } + + // for shaders to set vertex shader constants. returns a packed state which can be used to set the dynamic combo + int GetPackedDeformationInformation( int nMaskOfUnderstoodDeformations, + float *pConstantValuesOut, + int nBufferSize, + int nMaximumDeformations, + int *pNumDefsOut ) const + { + *pNumDefsOut = 0; + return 0; + } + + void SetStandardTextureHandle(StandardTextureId_t,ShaderAPITextureHandle_t) + { + } + + virtual void ExecuteCommandBuffer( uint8 *pData ) + { + } + virtual bool GetHDREnabled( void ) const { return true; } + virtual void SetHDREnabled( bool bEnable ) {} + + virtual void CopyRenderTargetToScratchTexture( ShaderAPITextureHandle_t srcRt, ShaderAPITextureHandle_t dstTex, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL ) + { + } + + // 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 ) + { + } + + virtual void UnlockRect( ShaderAPITextureHandle_t texHandle, int mipmap ) + { + } + + virtual void TexLodClamp( int finest ) {} + + virtual void TexLodBias( float bias ) {} + + virtual void CopyTextureToTexture( ShaderAPITextureHandle_t srcTex, ShaderAPITextureHandle_t dstTex ) {} + + void PrintfVA( char *fmt, va_list vargs ) {} + void Printf( const char *fmt, ... ) {} + float Knob( char *knobname, float *setvalue = NULL ) { return 0.0f; }; + +private: + enum + { + TRANSLUCENT = 0x1, + ALPHATESTED = 0x2, + VERTEX_AND_PIXEL_SHADERS = 0x4, + DEPTHWRITE = 0x8, + }; + + CGLMesh m_Mesh; + + void EnableAlphaToCoverage() {} ; + void DisableAlphaToCoverage() {} ; + + ImageFormat GetShadowDepthTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }; + ImageFormat GetNullTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }; +}; + +static CShaderAPIGL g_ShaderAPIGL; + +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIGL, IMaterialSystemHardwareConfig, + MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, g_ShaderAPIGL ) + +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIGL, IDebugTextureInfo, + DEBUG_TEXTURE_INFO_VERSION, g_ShaderAPIGL ) + +#endif \ No newline at end of file diff --git a/materialsystem/shaderapigl/shaderdevicebase.cpp b/materialsystem/shaderapigl/shaderdevicebase.cpp new file mode 100644 index 00000000..e69de29b diff --git a/materialsystem/shaderapigl/shaderdevicebase.h b/materialsystem/shaderapigl/shaderdevicebase.h new file mode 100644 index 00000000..e69de29b diff --git a/materialsystem/shaderapigl/shadershadowgl.cpp b/materialsystem/shaderapigl/shadershadowgl.cpp new file mode 100644 index 00000000..e5782238 --- /dev/null +++ b/materialsystem/shaderapigl/shadershadowgl.cpp @@ -0,0 +1,205 @@ +#include "utlvector.h" +#include "materialsystem/imaterialsystem.h" +#include "shaderapi/ishaderutil.h" +#include "shaderapi/ishaderapi.h" +#include "materialsystem/imesh.h" +#include "materialsystem/idebugtextureinfo.h" +#include "materialsystem/deformations.h" +#include "meshgl.h" +#include "shaderapigl.h" +#include "shaderapidevicegl.h" +#include "shadershadowgl.h" + + +//----------------------------------------------------------------------------- +// The shader shadow interface +//----------------------------------------------------------------------------- +CShaderShadowGL::CShaderShadowGL() +{ + m_IsTranslucent = false; + m_IsAlphaTested = false; + m_bIsDepthWriteEnabled = true; + m_bUsesVertexAndPixelShaders = false; +} + +CShaderShadowGL::~CShaderShadowGL() +{ +} + +// Sets the default *shadow* state +void CShaderShadowGL::SetDefaultState() +{ + m_IsTranslucent = false; + m_IsAlphaTested = false; + m_bIsDepthWriteEnabled = true; + m_bUsesVertexAndPixelShaders = false; +} + +// Methods related to depth buffering +void CShaderShadowGL::DepthFunc( ShaderDepthFunc_t depthFunc ) +{ +} + +void CShaderShadowGL::EnableDepthWrites( bool bEnable ) +{ + m_bIsDepthWriteEnabled = bEnable; +} + +void CShaderShadowGL::EnableDepthTest( bool bEnable ) +{ +} + +void CShaderShadowGL::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode ) +{ +} + +// Suppresses/activates color writing +void CShaderShadowGL::EnableColorWrites( bool bEnable ) +{ +} + +// Suppresses/activates alpha writing +void CShaderShadowGL::EnableAlphaWrites( bool bEnable ) +{ +} + +// Methods related to alpha blending +void CShaderShadowGL::EnableBlending( bool bEnable ) +{ + m_IsTranslucent = bEnable; +} + +void CShaderShadowGL::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ) +{ +} + +// A simpler method of dealing with alpha modulation +void CShaderShadowGL::EnableAlphaPipe( bool bEnable ) +{ +} + +void CShaderShadowGL::EnableConstantAlpha( bool bEnable ) +{ +} + +void CShaderShadowGL::EnableVertexAlpha( bool bEnable ) +{ +} + +void CShaderShadowGL::EnableTextureAlpha( TextureStage_t stage, bool bEnable ) +{ +} + + +// Alpha testing +void CShaderShadowGL::EnableAlphaTest( bool bEnable ) +{ + m_IsAlphaTested = bEnable; +} + +void CShaderShadowGL::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ ) +{ +} + + +// Wireframe/filled polygons +void CShaderShadowGL::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode ) +{ +} + + +// Back face culling +void CShaderShadowGL::EnableCulling( bool bEnable ) +{ +} + + +// Alpha to coverage +void CShaderShadowGL::EnableAlphaToCoverage( bool bEnable ) +{ +} + + +// constant color + transparency +void CShaderShadowGL::EnableConstantColor( bool bEnable ) +{ +} + +// Indicates the vertex format for use with a vertex shader +// The flags to pass in here come from the VertexFormatFlags_t enum +// If pTexCoordDimensions is *not* specified, we assume all coordinates +// are 2-dimensional +void CShaderShadowGL::VertexShaderVertexFormat( unsigned int nFlags, + int nTexCoordCount, + int* pTexCoordDimensions, + int nUserDataSize ) +{ +} + +// Indicates we're going to light the model +void CShaderShadowGL::EnableLighting( bool bEnable ) +{ +} + +void CShaderShadowGL::EnableSpecular( bool bEnable ) +{ +} + +// Activate/deactivate skinning +void CShaderShadowGL::EnableVertexBlend( bool bEnable ) +{ +} + +// per texture unit stuff +void CShaderShadowGL::OverbrightValue( TextureStage_t stage, float value ) +{ +} + +void CShaderShadowGL::EnableTexture( Sampler_t stage, bool bEnable ) +{ +} + +void CShaderShadowGL::EnableCustomPixelPipe( bool bEnable ) +{ +} + +void CShaderShadowGL::CustomTextureStages( int stageCount ) +{ +} + +void CShaderShadowGL::CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel, + ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 ) +{ +} + +void CShaderShadowGL::EnableTexGen( TextureStage_t stage, bool bEnable ) +{ +} + +void CShaderShadowGL::TexGen( TextureStage_t stage, ShaderTexGenParam_t param ) +{ +} + +// Sets the vertex and pixel shaders +void CShaderShadowGL::SetVertexShader( const char *pShaderName, int vshIndex ) +{ + m_bUsesVertexAndPixelShaders = ( pShaderName != NULL ); +} + +void CShaderShadowGL::EnableBlendingSeparateAlpha( bool bEnable ) +{ +} +void CShaderShadowGL::SetPixelShader( const char *pShaderName, int pshIndex ) +{ + m_bUsesVertexAndPixelShaders = ( pShaderName != NULL ); +} + +void CShaderShadowGL::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ) +{ +} +// indicates what per-vertex data we're providing +void CShaderShadowGL::DrawFlags( unsigned int drawFlags ) +{ +} + + diff --git a/materialsystem/shaderapigl/shadershadowgl.h b/materialsystem/shaderapigl/shadershadowgl.h new file mode 100644 index 00000000..fc91681c --- /dev/null +++ b/materialsystem/shaderapigl/shadershadowgl.h @@ -0,0 +1,172 @@ +#ifndef SHADERSHADOWGL_H +#define SHADERSHADOWGL_H + +#include "shaderapi/ishadershadow.h" + +//----------------------------------------------------------------------------- +// The empty shader shadow +//----------------------------------------------------------------------------- +class CShaderShadowGL : public IShaderShadow +{ +public: + CShaderShadowGL(); + virtual ~CShaderShadowGL(); + + // Sets the default *shadow* state + void SetDefaultState(); + + // Methods related to depth buffering + void DepthFunc( ShaderDepthFunc_t depthFunc ); + void EnableDepthWrites( bool bEnable ); + void EnableDepthTest( bool bEnable ); + void EnablePolyOffset( PolygonOffsetMode_t nOffsetMode ); + + // Suppresses/activates color writing + void EnableColorWrites( bool bEnable ); + void EnableAlphaWrites( bool bEnable ); + + // Methods related to alpha blending + void EnableBlending( bool bEnable ); + void BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ); + + // Alpha testing + void EnableAlphaTest( bool bEnable ); + void AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ ); + + // Wireframe/filled polygons + void PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode ); + + // Back face culling + void EnableCulling( bool bEnable ); + + // constant color + transparency + void EnableConstantColor( bool bEnable ); + + // Indicates the vertex format for use with a vertex shader + // The flags to pass in here come from the VertexFormatFlags_t enum + // If pTexCoordDimensions is *not* specified, we assume all coordinates + // are 2-dimensional + void VertexShaderVertexFormat( unsigned int nFlags, + int nTexCoordCount, int* pTexCoordDimensions, int nUserDataSize ); + + // Indicates we're going to light the model + void EnableLighting( bool bEnable ); + void EnableSpecular( bool bEnable ); + + // vertex blending + void EnableVertexBlend( bool bEnable ); + + // per texture unit stuff + void OverbrightValue( TextureStage_t stage, float value ); + void EnableTexture( Sampler_t stage, bool bEnable ); + void EnableTexGen( TextureStage_t stage, bool bEnable ); + void TexGen( TextureStage_t stage, ShaderTexGenParam_t param ); + + // alternate method of specifying per-texture unit stuff, more flexible and more complicated + // Can be used to specify different operation per channel (alpha/color)... + void EnableCustomPixelPipe( bool bEnable ); + void CustomTextureStages( int stageCount ); + void CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel, + ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 ); + + // indicates what per-vertex data we're providing + void DrawFlags( unsigned int drawFlags ); + + // A simpler method of dealing with alpha modulation + void EnableAlphaPipe( bool bEnable ); + void EnableConstantAlpha( bool bEnable ); + void EnableVertexAlpha( bool bEnable ); + void EnableTextureAlpha( TextureStage_t stage, bool bEnable ); + + // GR - Separate alpha blending + void EnableBlendingSeparateAlpha( bool bEnable ); + void BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ); + + // Sets the vertex and pixel shaders + void SetVertexShader( const char *pFileName, int vshIndex ); + void SetPixelShader( const char *pFileName, int pshIndex ); + + // Convert from linear to gamma color space on writes to frame buffer. + void EnableSRGBWrite( bool bEnable ) + { + } + + void EnableSRGBRead( Sampler_t stage, bool bEnable ) + { + } + + virtual void FogMode( ShaderFogMode_t fogMode ) + { + } + + virtual void DisableFogGammaCorrection( bool bDisable ) + { + } + + virtual void SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource ) + { + } + + virtual void SetMorphFormat( MorphFormat_t flags ) + { + } + + virtual void EnableStencil( bool bEnable ) + { + } + virtual void StencilFunc( ShaderStencilFunc_t stencilFunc ) + { + } + virtual void StencilPassOp( ShaderStencilOp_t stencilOp ) + { + } + virtual void StencilFailOp( ShaderStencilOp_t stencilOp ) + { + } + virtual void StencilDepthFailOp( ShaderStencilOp_t stencilOp ) + { + } + virtual void StencilReference( int nReference ) + { + } + virtual void StencilMask( int nMask ) + { + } + virtual void StencilWriteMask( int nMask ) + { + } + + virtual void ExecuteCommandBuffer( uint8 *pBuf ) + { + } + // Alpha to coverage + void EnableAlphaToCoverage( bool bEnable ); + + virtual void SetShadowDepthFiltering( Sampler_t stage ) + { + } + + virtual void BlendOp( ShaderBlendOp_t blendOp ) {} + virtual void BlendOpSeparateAlpha( ShaderBlendOp_t blendOp ) {} + + bool m_IsTranslucent; + bool m_IsAlphaTested; + bool m_bIsDepthWriteEnabled; + bool m_bUsesVertexAndPixelShaders; +}; + +//----------------------------------------------------------------------------- +// Class Factory +//----------------------------------------------------------------------------- + +static CShaderShadowGL g_ShaderShadow; + +// FIXME: Remove; it's for backward compat with the materialsystem only for now +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIGL, IShaderAPI, + SHADERAPI_INTERFACE_VERSION, g_ShaderAPIGL ) + +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderShadowGL, IShaderShadow, + SHADERSHADOW_INTERFACE_VERSION, g_ShaderShadow ) + + +#endif \ No newline at end of file diff --git a/materialsystem/shaderapigl/wscript b/materialsystem/shaderapigl/wscript new file mode 100755 index 00000000..2d56c673 --- /dev/null +++ b/materialsystem/shaderapigl/wscript @@ -0,0 +1,56 @@ +#! /usr/bin/env python +# encoding: utf-8 + +from waflib import Utils +import os + +top = '.' +PROJECT_NAME = 'shaderapigl' + +def options(opt): + # stub + return + +def configure(conf): + conf.env.append_unique('DEFINES',[ + 'SHADER_DLL_EXPORT', + 'PROTECTED_THINGS_ENABLE' + ]) + +def build(bld): + source = [ + 'shaderapigl.cpp', + 'shaderapidevicegl.cpp', + 'shadershadowgl.cpp', + 'meshgl.cpp', + '../../public/tier0/memoverride.cpp' + ] + + includes = [ + '.', + '../../public', + '../../public/tier0', + '../../public/tier1', + '../../common', + '../' + ] + bld.env.INCLUDES_SDL2 + + defines = [] + + libs = ['tier0','tier1'] + + install_path = bld.env.LIBDIR + + bld.shlib( + source = source, + target = PROJECT_NAME, + name = PROJECT_NAME, + features = 'c cxx', + includes = includes, + defines = defines, + use = libs, + install_path = install_path, + subsystem = bld.env.MSVC_SUBSYSTEM, + idx = bld.get_taskgen_count() + ) + diff --git a/wscript b/wscript index 4690d56d..0bff80e1 100644 --- a/wscript +++ b/wscript @@ -51,7 +51,7 @@ projects={ 'launcher', 'launcher_main', 'materialsystem', -# 'materialsystem/shaderapiempty', + 'materialsystem/shaderapigl', 'materialsystem/shaderapidx9', 'materialsystem/shaderlib', 'materialsystem/stdshaders',