You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
418 lines
11 KiB
418 lines
11 KiB
//====== Copyright © 1996-2004, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// A class representing a procedural texture
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef DMETEXTURE_H
|
|
#define DMETEXTURE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "datamodel/dmelement.h"
|
|
#include "materialsystem/materialsystemutil.h"
|
|
#include "materialobjects/dmeimage.h"
|
|
#include "tier1/functors.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
enum ImageFormat;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compression types
|
|
//-----------------------------------------------------------------------------
|
|
enum DmeTextureCompress_t
|
|
{
|
|
DMETEXTURE_COMPRESS_DEFAULT = 0,
|
|
DMETEXTURE_COMPRESS_NONE,
|
|
DMETEXTURE_COMPRESS_DXT1,
|
|
DMETEXTURE_COMPRESS_DXT5,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Filter types
|
|
//-----------------------------------------------------------------------------
|
|
enum DmeTextureFilter_t
|
|
{
|
|
DMETEXTURE_FILTER_DEFAULT = 0,
|
|
DMETEXTURE_FILTER_ANISOTROPIC,
|
|
DMETEXTURE_FILTER_TRILINEAR,
|
|
DMETEXTURE_FILTER_BILINEAR,
|
|
DMETEXTURE_FILTER_POINT,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Mipmap types
|
|
//-----------------------------------------------------------------------------
|
|
enum DmeTextureMipmap_t
|
|
{
|
|
DMETEXTURE_MIPMAP_DEFAULT = 0,
|
|
DMETEXTURE_MIPMAP_ALL_LEVELS,
|
|
DMETEXTURE_MIPMAP_NONE,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Texture types
|
|
//-----------------------------------------------------------------------------
|
|
enum DmeTextureType_t
|
|
{
|
|
DMETEXTURE_TYPE_NORMAL = 0,
|
|
DMETEXTURE_TYPE_CUBEMAP,
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A class for textures
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeTextureFrame : public CDmElement
|
|
{
|
|
DEFINE_ELEMENT( CDmeTextureFrame, CDmElement );
|
|
|
|
public:
|
|
int MipLevelCount() const;
|
|
CDmeImageArray *GetMipLevel( int nIndex ) const;
|
|
void AddMipLevel( CDmeImageArray *pImages );
|
|
CDmeImageArray *AddMipLevel( );
|
|
|
|
int ImageCount() const;
|
|
|
|
private:
|
|
// Mip levels for the texture
|
|
CDmaElementArray< CDmeImageArray > m_MipLevels;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper functors
|
|
//-----------------------------------------------------------------------------
|
|
template< typename ObjectType_t > class CImageMemberFunctor
|
|
{
|
|
public:
|
|
CImageMemberFunctor( ObjectType_t *pObject, bool (ObjectType_t::*pMemberFunc)( CDmeImage * ) )
|
|
{
|
|
m_pObject = pObject;
|
|
m_pMemberFunc = pMemberFunc;
|
|
}
|
|
|
|
bool operator()( CDmeImage *pImage )
|
|
{
|
|
return m_pObject->*m_pMemberFunc( pImage );
|
|
}
|
|
|
|
private:
|
|
ObjectType_t *m_pObject;
|
|
bool (ObjectType_t::*m_pMemberFunc)( CDmeImage * );
|
|
};
|
|
|
|
class CImageFunctor
|
|
{
|
|
public:
|
|
CImageFunctor( bool (*pMemberFunc)( CDmeImage * ) )
|
|
{
|
|
m_pFunc = pMemberFunc;
|
|
}
|
|
|
|
bool operator()( CDmeImage *pImage )
|
|
{
|
|
return m_pFunc( pImage );
|
|
}
|
|
|
|
private:
|
|
bool (*m_pFunc)( CDmeImage * );
|
|
};
|
|
|
|
|
|
template< typename ObjectType_t > class CImageProcessorMemberFunctor
|
|
{
|
|
public:
|
|
CImageProcessorMemberFunctor( ObjectType_t *pObject, void (ObjectType_t::*pMemberFunc)( CDmeImage *, CDmeImage * ) )
|
|
{
|
|
m_pObject = pObject;
|
|
m_pMemberFunc = pMemberFunc;
|
|
}
|
|
|
|
void operator()( CDmeImage *pDstImage, CDmeImage *pSrcImage )
|
|
{
|
|
(m_pObject->*m_pMemberFunc)( pDstImage, pSrcImage );
|
|
}
|
|
|
|
private:
|
|
ObjectType_t *m_pObject;
|
|
void (ObjectType_t::*m_pMemberFunc)( CDmeImage *, CDmeImage * );
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A class for textures
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeTexture : public CDmElement
|
|
{
|
|
DEFINE_ELEMENT( CDmeTexture, CDmElement );
|
|
|
|
public:
|
|
// Compression type
|
|
void SetCompressionType( DmeTextureCompress_t type );
|
|
DmeTextureCompress_t GetCompressionType() const;
|
|
|
|
// Filter type
|
|
void SetFilterType( DmeTextureFilter_t type );
|
|
DmeTextureFilter_t GetFilterType() const;
|
|
|
|
// Mipmap type
|
|
void SetMipmapType( DmeTextureMipmap_t type );
|
|
DmeTextureMipmap_t GetMipmapType() const;
|
|
|
|
// Texture type
|
|
void SetTextureType( DmeTextureType_t type );
|
|
DmeTextureType_t GetTextureType() const;
|
|
|
|
CDmeTextureFrame *AddFrame();
|
|
int FrameCount() const;
|
|
CDmeTextureFrame *GetFrame( int nIndex ) const;
|
|
void RemoveAllFrames();
|
|
|
|
// Gets dimensions
|
|
int Width() const;
|
|
int Height() const;
|
|
int Depth() const;
|
|
int MipLevelCount() const;
|
|
int ImageCount() const;
|
|
|
|
// Methods related to image format
|
|
ImageFormat Format() const;
|
|
|
|
// Returns all images associated with a particular frame + face (mip count amount)
|
|
void GetImages( int nFrame, int nImageIndex, CDmeImage **ppImages, int nSize );
|
|
|
|
// Iterates over all images, processes them
|
|
template< typename Functor > void ProcessTexture( CDmeTexture *pSrcTexture, Functor &func );
|
|
template< typename ObjectType_t > void ProcessTexture( CDmeTexture *pSrcTexture, ObjectType_t *pObject, void (ObjectType_t::*pMemberFunc)( CDmeImage *, CDmeImage * ) );
|
|
|
|
// Iterates over all images, runs a functor
|
|
template< typename Functor > void ForEachImage( Functor &func );
|
|
template< typename ObjectType_t > void ForEachImage( ObjectType_t *pObject, bool (ObjectType_t::*pMemberFunc)( CDmeImage * ) );
|
|
void ForEachImage( bool (*pFunc)( CDmeImage * ) );
|
|
|
|
void CompressTexture( CDmeTexture *pSrcTexture, ImageFormat fmt );
|
|
|
|
//-------------------------------------
|
|
// Ignore the macro! To use this nifty feature, use code that looks like this:
|
|
// pTexture->ForEachImage( &CDmeImage::ConvertFormat, dstFormat );
|
|
//-------------------------------------
|
|
#define DEFINE_FOR_EACH_IMAGE(N) \
|
|
template <typename FUNCTION_RETTYPE FUNC_TEMPLATE_FUNC_PARAMS_##N FUNC_TEMPLATE_ARG_PARAMS_##N> \
|
|
void ForEachImage( FUNCTION_RETTYPE ( CDmeImage::*pfnProxied )( FUNC_BASE_TEMPLATE_FUNC_PARAMS_##N ) FUNC_ARG_FORMAL_PARAMS_##N ) \
|
|
{ \
|
|
int nFrameCount = FrameCount(); \
|
|
for ( int f = 0; f < nFrameCount; ++f ) \
|
|
{ \
|
|
CDmeTextureFrame *pFrame = GetFrame( f ); \
|
|
if ( !pFrame ) \
|
|
continue; \
|
|
int nMipCount = pFrame->MipLevelCount(); \
|
|
for ( int m = 0; m < nMipCount; ++m ) \
|
|
{ \
|
|
CDmeImageArray *pImageArray = pFrame->GetMipLevel( m ); \
|
|
if ( !pImageArray ) \
|
|
continue; \
|
|
int nImageCount = pImageArray->ImageCount(); \
|
|
for ( int i = 0; i < nImageCount; ++i ) \
|
|
{ \
|
|
CDmeImage *pImage = pImageArray->GetImage( i ); \
|
|
if ( !pImage ) \
|
|
continue; \
|
|
FunctorDirectCall( pImage, pfnProxied FUNC_FUNCTOR_CALL_ARGS_##N ); \
|
|
} \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
FUNC_GENERATE_ALL( DEFINE_FOR_EACH_IMAGE );
|
|
#undef DEFINE_FOR_EACH_IMAGE
|
|
|
|
public:
|
|
virtual void Resolve();
|
|
|
|
public:
|
|
CDmaVar<bool> m_bClampS;
|
|
CDmaVar<bool> m_bClampT;
|
|
CDmaVar<bool> m_bClampU;
|
|
CDmaVar<bool> m_bNoDebugOverride;
|
|
CDmaVar<bool> m_bNoLod;
|
|
CDmaVar<bool> m_bNiceFiltered;
|
|
CDmaVar<bool> m_bNormalMap;
|
|
CDmaVar<float> m_flBumpScale;
|
|
|
|
protected:
|
|
// Computes texture flags
|
|
int CalcTextureFlags( int nDepth ) const;
|
|
|
|
// Computes the desired texture format based on flags
|
|
ImageFormat ComputeDesiredImageFormat( ImageFormat srcFormat, int nWidth, int nHeight, int nDepth, int nFlags );
|
|
|
|
CDmaVar<int> m_nCompressType;
|
|
CDmaVar<int> m_nFilterType;
|
|
CDmaVar<int> m_nMipmapType;
|
|
CDmaVar<int> m_nTextureType;
|
|
|
|
// Array of images in an animated texture
|
|
CDmaElementArray< CDmeTextureFrame > m_Frames;
|
|
|
|
// Computed values
|
|
// CTextureReference m_Texture;
|
|
// IVTFTexture *m_pVTFTexture;
|
|
Vector m_vecReflectivity;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inline methods
|
|
//-----------------------------------------------------------------------------
|
|
inline void CDmeTexture::SetCompressionType( DmeTextureCompress_t type )
|
|
{
|
|
m_nCompressType = type;
|
|
}
|
|
|
|
inline DmeTextureCompress_t CDmeTexture::GetCompressionType() const
|
|
{
|
|
return (DmeTextureCompress_t)m_nCompressType.Get();
|
|
}
|
|
|
|
inline void CDmeTexture::SetFilterType( DmeTextureFilter_t type )
|
|
{
|
|
m_nFilterType = type;
|
|
}
|
|
|
|
inline DmeTextureFilter_t CDmeTexture::GetFilterType() const
|
|
{
|
|
return (DmeTextureFilter_t)m_nFilterType.Get();
|
|
}
|
|
|
|
inline void CDmeTexture::SetMipmapType( DmeTextureMipmap_t type )
|
|
{
|
|
m_nMipmapType = type;
|
|
}
|
|
|
|
inline DmeTextureMipmap_t CDmeTexture::GetMipmapType() const
|
|
{
|
|
return (DmeTextureMipmap_t)m_nMipmapType.Get();
|
|
}
|
|
|
|
inline void CDmeTexture::SetTextureType( DmeTextureType_t type )
|
|
{
|
|
m_nTextureType = type;
|
|
}
|
|
|
|
inline DmeTextureType_t CDmeTexture::GetTextureType() const
|
|
{
|
|
return (DmeTextureType_t)m_nTextureType.Get();
|
|
}
|
|
|
|
inline int CDmeTexture::FrameCount() const
|
|
{
|
|
return m_Frames.Count();
|
|
}
|
|
|
|
inline CDmeTextureFrame *CDmeTexture::GetFrame( int nIndex ) const
|
|
{
|
|
return m_Frames[nIndex];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Invokes a functor on all images in the texture
|
|
//-----------------------------------------------------------------------------
|
|
template< typename Functor > inline void CDmeTexture::ForEachImage( Functor &func )
|
|
{
|
|
int nFrameCount = FrameCount();
|
|
for ( int f = 0; f < nFrameCount; ++f )
|
|
{
|
|
CDmeTextureFrame *pFrame = GetFrame( f );
|
|
if ( !pFrame )
|
|
continue;
|
|
|
|
int nMipCount = pFrame->MipLevelCount();
|
|
for ( int m = 0; m < nMipCount; ++m )
|
|
{
|
|
CDmeImageArray *pImageArray = pFrame->GetMipLevel( m );
|
|
if ( !pImageArray )
|
|
continue;
|
|
|
|
int nImageCount = pImageArray->ImageCount();
|
|
for ( int i = 0; i < nImageCount; ++i )
|
|
{
|
|
CDmeImage *pImage = pImageArray->GetImage( i );
|
|
if ( !pImage )
|
|
continue;
|
|
|
|
if ( !func( pImage ) )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template< typename ObjectType_t > inline void CDmeTexture::ForEachImage( ObjectType_t *pObject, bool (ObjectType_t::*pMemberFunc)( CDmeImage * ) )
|
|
{
|
|
CImageMemberFunctor< ObjectType_t > functor( pObject, pMemberFunc );
|
|
ForEachImage( functor );
|
|
}
|
|
|
|
inline void CDmeTexture::ForEachImage( bool (*pFunc)( CDmeImage * ) )
|
|
{
|
|
CImageFunctor functor( pFunc );
|
|
ForEachImage( functor );
|
|
}
|
|
|
|
|
|
// Iterates over all images, processes them
|
|
template< typename Functor > inline void CDmeTexture::ProcessTexture( CDmeTexture *pSrcTexture, Functor &func )
|
|
{
|
|
// FIXME: This pattern should go into some templatized type thingy
|
|
pSrcTexture->CopyAttributesTo( this, TD_NONE );
|
|
|
|
// Copying will copy references to src texture frames. Remove them.
|
|
RemoveAllFrames();
|
|
|
|
int nFrameCount = pSrcTexture->FrameCount();
|
|
for ( int f = 0; f < nFrameCount; ++f )
|
|
{
|
|
CDmeTextureFrame *pSrcFrame = pSrcTexture->GetFrame( f );
|
|
CDmeTextureFrame *pDstFrame = AddFrame();
|
|
|
|
int nMipCount = pSrcFrame->MipLevelCount();
|
|
for ( int m = 0; m < nMipCount; ++m )
|
|
{
|
|
CDmeImageArray *pSrcImageArray = pSrcFrame->GetMipLevel( m );
|
|
CDmeImageArray *pDstImageArray = pDstFrame->AddMipLevel();
|
|
if ( !pSrcImageArray )
|
|
continue;
|
|
int nImageCount = pSrcImageArray->ImageCount();
|
|
for ( int i = 0; i < nImageCount; ++i )
|
|
{
|
|
CDmeImage *pSrcImage = pSrcImageArray->GetImage( i );
|
|
CDmeImage *pDstImage = pDstImageArray->AddImage( );
|
|
if ( !pSrcImage )
|
|
continue;
|
|
|
|
func( pDstImage, pSrcImage );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template< typename ObjectType_t > inline void CDmeTexture::ProcessTexture( CDmeTexture *pSrcTexture, ObjectType_t *pObject, void (ObjectType_t::*pMemberFunc)( CDmeImage *, CDmeImage * ) )
|
|
{
|
|
CImageProcessorMemberFunctor< ObjectType_t > functor( pObject, pMemberFunc );
|
|
ProcessTexture( pSrcTexture, functor );
|
|
}
|
|
|
|
|
|
#endif // DMETEXTURE_H
|