shaderapiempty.cpp

hl2 source code. Do not use it illegal.

void CShaderAPIEmpty::BindNormalizationCubeMap( TextureStage_t stage )
{
}

void CShaderAPIEmpty::BindSyncTexture( TextureStage_t stage, int texture )
{
}

void CShaderAPIEmpty::BindFBTexture( TextureStage_t stage )
{
}

void CShaderAPIEmpty::CopyRenderTargetToTexture( int texID )
{
}

// Flushes any primitives that are buffered
void CShaderAPIEmpty::FlushBufferedPrimitives()
{
}

IMesh* CShaderAPIEmpty::CreateStaticMesh( IMaterial* pMaterial, bool bForceTempMesh )
{
	return &m_Mesh;
}

// Creates/destroys Mesh
IMesh* CShaderAPIEmpty::CreateStaticMesh( VertexFormat_t fmt, bool bSoftwareVertexShader )
{
	return &m_Mesh;
}

void CShaderAPIEmpty::DestroyStaticMesh( IMesh* mesh )
{
}

// 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* CShaderAPIEmpty::GetDynamicMesh( IMaterial* pMaterial, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride )
{
	return &m_Mesh;
}


// Begins a rendering pass that uses a state snapshot
void CShaderAPIEmpty::BeginPass( StateSnapshot_t snapshot  )
{
}

// Renders a single pass of a material
void CShaderAPIEmpty::RenderPass( )
{
}

// Page flip
void CShaderAPIEmpty::SwapBuffers( )
{
}

// stuff related to matrix stacks
void CShaderAPIEmpty::MatrixMode( MaterialMatrixMode_t matrixMode )
{
}

void CShaderAPIEmpty::PushMatrix()
{
}

void CShaderAPIEmpty::PopMatrix()
{
}

void CShaderAPIEmpty::LoadMatrix( float *m )
{
}

void CShaderAPIEmpty::MultMatrix( float *m )
{
}

void CShaderAPIEmpty::MultMatrixLocal( float *m )
{
}

void CShaderAPIEmpty::GetMatrix( MaterialMatrixMode_t matrixMode, float *dst )
{
}

void CShaderAPIEmpty::LoadIdentity( void )
{
}

void CShaderAPIEmpty::LoadCameraToWorld( void )
{
}

void CShaderAPIEmpty::Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
{
}

void CShaderAPIEmpty::PerspectiveX( double fovx, double aspect, double zNear, double zFar )
{
}

void CShaderAPIEmpty::PickMatrix( int x, int y, int width, int height )
{
}

void CShaderAPIEmpty::Rotate( float angle, float x, float y, float z )
{
}

void CShaderAPIEmpty::Translate( float x, float y, float z )
{
}

void CShaderAPIEmpty::Scale( float x, float y, float z )
{
}

void CShaderAPIEmpty::ScaleXY( float x, float y )
{
}

// Fog methods...
void CShaderAPIEmpty::FogMode( MaterialFogMode_t fogMode )
{
}

void CShaderAPIEmpty::FogStart( float fStart )
{
}

void CShaderAPIEmpty::FogEnd( float fEnd )
{
}

void CShaderAPIEmpty::SetFogZ( float fogZ )
{
}

float CShaderAPIEmpty::GetFogStart( void ) const
{
	return 0.0;
}

float CShaderAPIEmpty::GetFogEnd( void ) const
{
	return 0.0;
}

void CShaderAPIEmpty::SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
}

void CShaderAPIEmpty::GetSceneFogColor( unsigned char *rgb )
{
	rgb[0] = 0;
	rgb[1] = 0;
	rgb[2] = 0;
}

void CShaderAPIEmpty::SceneFogMode( MaterialFogMode_t fogMode )
{
}

MaterialFogMode_t CShaderAPIEmpty::GetSceneFogMode( )
{
	return MATERIAL_FOG_NONE;
}

void CShaderAPIEmpty::FogColor3f( float r, float g, float b )
{
}

void CShaderAPIEmpty::FogColor3fv( float const* rgb )
{
}

void CShaderAPIEmpty::FogColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
}

void CShaderAPIEmpty::FogColor3ubv( unsigned char const* rgb )
{
}

void CShaderAPIEmpty::Viewport( int x, int y, int width, int height )
{
}

void CShaderAPIEmpty::GetViewport( int& x, int& y, int& width, int& height ) const
{
}

// Sets the vertex and pixel shaders
void CShaderAPIEmpty::SetVertexShaderIndex( int vshIndex )
{
}

void CShaderAPIEmpty::SetPixelShaderIndex( int pshIndex )
{
}

// Sets the constant register for vertex and pixel shaders
void CShaderAPIEmpty::SetVertexShaderConstant( int var, float const* pVec, int numConst, bool bForce )
{
}

void CShaderAPIEmpty::SetPixelShaderConstant( int var, float const* pVec, int numConst, bool bForce )
{
}


// Returns the nearest supported format
ImageFormat CShaderAPIEmpty::GetNearestSupportedFormat( ImageFormat fmt ) const
{
	return fmt;
}

ImageFormat CShaderAPIEmpty::GetNearestRenderTargetFormat( ImageFormat fmt ) const
{
	return fmt;
}

// Sets the texture state
void CShaderAPIEmpty::BindTexture( TextureStage_t stage, unsigned int textureNum )
{
}

void CShaderAPIEmpty::SetRenderTarget( unsigned int textureNum, unsigned int ztexture )
{
}

void CShaderAPIEmpty::ClearColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
}

void CShaderAPIEmpty::ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
{
}

ImageFormat CShaderAPIEmpty::GetBackBufferFormat() const
{
	return IMAGE_FORMAT_RGB888;
}

void CShaderAPIEmpty::GetBackBufferDimensions( int& width, int& height ) const
{
	width = 1024;
	height = 768;
}

// Indicates we're going to be modifying this texture
// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter
// all use the texture specified by this function.
void CShaderAPIEmpty::ModifyTexture( unsigned int textureNum )
{
}

// Texture management methods
void CShaderAPIEmpty::TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int width, int height, 
						 ImageFormat srcFormat, void *imageData )
{
}

void CShaderAPIEmpty::TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int width, int height,
						 ImageFormat srcFormat, int srcStride, void *imageData )
{
}

bool CShaderAPIEmpty::TexLock( int level, int cubeFaceID, int xOffset, int yOffset, 
								int width, int height, CPixelWriter& writer )
{
	return false;
}

void CShaderAPIEmpty::TexUnlock( )
{
}


// These are bound to the texture, not the texture environment
void CShaderAPIEmpty::TexMinFilter( ShaderTexFilterMode_t texFilterMode )
{
}

void CShaderAPIEmpty::TexMagFilter( ShaderTexFilterMode_t texFilterMode )
{
}

void CShaderAPIEmpty::TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode )
{
}

void CShaderAPIEmpty::TexSetPriority( int priority )
{
}

void CShaderAPIEmpty::SetLightmapTextureIdRange( int firstId, int lastId )
{
}

void CShaderAPIEmpty::CreateTexture( unsigned int textureNum, int width, int height,
		ImageFormat dstImageFormat, int numMipLevels, int numCopies, int flags )
{
}

void CShaderAPIEmpty::CreateDepthTexture( unsigned int textureNum, ImageFormat renderFormat, int width, int height )
{
}

void CShaderAPIEmpty::DeleteTexture( unsigned int textureNum )
{
}

bool CShaderAPIEmpty::IsTexture( unsigned int textureNum )
{
	return true;
}

bool CShaderAPIEmpty::IsTextureResident( unsigned int textureNum )
{
	return false;
}

// stuff that isn't to be used from within a shader
void CShaderAPIEmpty::DepthRange( float zNear, float zFar )
{
}

void CShaderAPIEmpty::ClearBuffers( bool bClearColor, bool bClearDepth, int renderTargetWidth, int renderTargetHeight )
{
}

void CShaderAPIEmpty::ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat )
{
}

void CShaderAPIEmpty::FlushHardware()
{
}

void CShaderAPIEmpty::ResetRenderState()
{
}

// Set the number of bone weights
void CShaderAPIEmpty::SetNumBoneWeights( int numBones )
{
}

// Point size...
void CShaderAPIEmpty::PointSize( float size )
{
}

// Selection mode methods
int CShaderAPIEmpty::SelectionMode( bool selectionMode )
{
	return 0;
}

void CShaderAPIEmpty::SelectionBuffer( unsigned int* pBuffer, int size )
{
}

void CShaderAPIEmpty::ClearSelectionNames( )
{
}

void CShaderAPIEmpty::LoadSelectionName( int name )
{
}

void CShaderAPIEmpty::PushSelectionName( int name )
{
}

void CShaderAPIEmpty::PopSelectionName()
{
}


// Use this to get the mesh builder that allows us to modify vertex data
CMeshBuilder* CShaderAPIEmpty::GetVertexModifyBuilder()
{
	return 0;
}

// Board-independent calls, here to unify how shaders set state
// Implementations should chain back to IShaderUtil->BindTexture(), etc.

// Use this to spew information about the 3D layer 
void CShaderAPIEmpty::SpewDriverInfo() const
{
	Warning("Empty shader\n");
}

// Use this to begin and end the frame
void CShaderAPIEmpty::BeginFrame()
{
}

void CShaderAPIEmpty::EndFrame()
{
}

// returns the current time in seconds....
double CShaderAPIEmpty::CurrentTime() const
{
	return Sys_FloatTime();
}

// Get the current camera position in world space.
void CShaderAPIEmpty::GetWorldSpaceCameraPosition( float * pPos ) const
{
}

void CShaderAPIEmpty::SetSoftwareVertexShader( SoftwareVertexShader_t shader )
{
}

void CShaderAPIEmpty::CallSoftwareVertexShader( CMeshBuilder *pMeshBuilder )
{
}

void CShaderAPIEmpty::ForceHardwareSync( void )
{
}

void CShaderAPIEmpty::DrawDebugText( int desiredLeft, int desiredTop, 
									 MaterialRect_t *pActualRect, const char *pText )
{
}

void CShaderAPIEmpty::SetHeightClipZ( float z )
{
}

void CShaderAPIEmpty::SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode )
{
}

void CShaderAPIEmpty::SetClipPlane( int index, const float *pPlane )
{
}

void CShaderAPIEmpty::EnableClipPlane( int index, bool bEnable )
{
}

int CShaderAPIEmpty::GetCurrentNumBones( void ) const
{
	return 0;
}

int CShaderAPIEmpty::GetCurrentLightCombo( void ) const
{
	return 0;
}

int CShaderAPIEmpty::GetCurrentFogType( void ) const
{
	return 0;
}

void CShaderAPIEmpty::RecordString( const char *pStr )
{
}

bool CShaderAPIEmpty::ReadPixelsFromFrontBuffer() const
{
	return true;
}

bool CShaderAPIEmpty::PreferDynamicTextures() const
{
	return false;
}

bool CShaderAPIEmpty::HasProjectedBumpEnv() const
{
	return true;
}

void CShaderAPIEmpty::DestroyVertexBuffers()
{
}

void CShaderAPIEmpty::EvictManagedResources()
{
}

void CShaderAPIEmpty::SetTextureTransformDimension( int textureStage, int dimension, bool projected )
{
}

void CShaderAPIEmpty::SetBumpEnvMatrix( int textureStage, float m00, float m01, float m10, float m11 )
{
}

// Adds/removes precompiled shader dictionaries
ShaderDLL_t CShaderAPIEmpty::AddShaderDLL( )
{
	return 0;
}

void CShaderAPIEmpty::RemoveShaderDLL( ShaderDLL_t hShaderDLL ) 
{
}

void CShaderAPIEmpty::AddShaderDictionary( ShaderDLL_t hShaderDLL, IPrecompiledShaderDictionary *pDict )
{
}

void CShaderAPIEmpty::SetShaderDLL( ShaderDLL_t hShaderDLL )
{
}

void CShaderAPIEmpty::SyncToken( const char *pToken )
{
}