diff options
Diffstat (limited to 'vtf/cvtf.h')
| -rw-r--r-- | vtf/cvtf.h | 441 |
1 files changed, 441 insertions, 0 deletions
diff --git a/vtf/cvtf.h b/vtf/cvtf.h new file mode 100644 index 0000000..3965de9 --- /dev/null +++ b/vtf/cvtf.h @@ -0,0 +1,441 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Local header for CVTFTexture class declaration - allows platform-specific +// implementation to be placed in separate cpp files. +// +// $NoKeywords: $ +//===========================================================================// + +#ifndef CVTF_H +#define CVTF_H + +#ifdef _WIN32 +#pragma once +#endif + +#include "s3tc_decode.h" +#include "vtf/vtf.h" +#include "byteswap.h" +#include "filesystem.h" + +class CEdgePos +{ +public: + CEdgePos() {} + CEdgePos( int ix, int iy ) + { + x = ix; + y = iy; + } + + void operator +=( const CEdgePos &other ) + { + x += other.x; + y += other.y; + } + + void operator /=( int val ) + { + x /= val; + y /= val; + } + + CEdgePos operator >>( int shift ) + { + return CEdgePos( x >> shift, y >> shift ); + } + + CEdgePos operator *( int shift ) + { + return CEdgePos( x * shift, y * shift ); + } + + CEdgePos operator -( const CEdgePos &other ) + { + return CEdgePos( x - other.x, y - other.y ); + } + + CEdgePos operator +( const CEdgePos &other ) + { + return CEdgePos( x + other.x, y + other.y ); + } + + bool operator!=( const CEdgePos &other ) + { + return !( *this == other ); + } + + bool operator==( const CEdgePos &other ) + { + return x==other.x && y==other.y; + } + + int x, y; +}; + + +class CEdgeIncrements +{ +public: + CEdgePos iFace1Start, iFace1End; + CEdgePos iFace1Inc, iFace2Inc; + CEdgePos iFace2Start, iFace2End; +}; + + +class CEdgeMatch +{ +public: + int m_iFaces[2]; // Which faces are touching. + int m_iEdges[2]; // Which edge on each face is touching. + int m_iCubeVerts[2];// Which of the cube's verts comprise this edge? + bool m_bFlipFace2Edge; +}; + + +class CCornerMatch +{ +public: + // The info for the 3 edges that match at this corner. + int m_iFaces[3]; + int m_iFaceEdges[3]; +}; + + +class CEdgeFaceIndex +{ +public: + int m_iEdge; + int m_iFace; +}; + + +#define NUM_EDGE_MATCHES 12 +#define NUM_CORNER_MATCHES 8 + + +//----------------------------------------------------------------------------- +// Implementation of the VTF Texture +//----------------------------------------------------------------------------- +class CVTFTexture : public IVTFTexture +{ +public: + CVTFTexture(); + virtual ~CVTFTexture(); + + virtual bool Init( int nWidth, int nHeight, int nDepth, ImageFormat fmt, int iFlags, int iFrameCount, int nForceMipCount ); + + // Methods to initialize the low-res image + virtual void InitLowResImage( int nWidth, int nHeight, ImageFormat fmt ); + + virtual void *SetResourceData( uint32 eType, void const *pData, size_t nDataSize ); + virtual void *GetResourceData( uint32 eType, size_t *pDataSize ) const; + + // Locates the resource entry info if it's present, easier than crawling array types + virtual bool HasResourceEntry( uint32 eType ) const; + + // Retrieve available resource types of this IVTFTextures + // arrTypesBuffer buffer to be filled with resource types available. + // numTypesBufferElems how many resource types the buffer can accomodate. + // Returns: + // number of resource types available (can be greater than "numTypesBufferElems" + // in which case only first "numTypesBufferElems" are copied to "arrTypesBuffer") + virtual unsigned int GetResourceTypes( uint32 *arrTypesBuffer, int numTypesBufferElems ) const; + + // Methods to set other texture fields + virtual void SetBumpScale( float flScale ); + virtual void SetReflectivity( const Vector &vecReflectivity ); + + // These are methods to help with optimization of file access + virtual void LowResFileInfo( int *pStartLocation, int *pSizeInBytes ) const; + virtual void ImageFileInfo( int nFrame, int nFace, int nMip, int *pStartLocation, int *pSizeInBytes) const; + virtual int FileSize( int nMipSkipCount = 0 ) const; + + // When unserializing, we can skip a certain number of mip levels, + // and we also can just load everything but the image data + virtual bool Unserialize( CUtlBuffer &buf, bool bBufferHeaderOnly = false, int nSkipMipLevels = 0 ); + virtual bool UnserializeEx( CUtlBuffer &buf, bool bHeaderOnly = false, int nForceFlags = 0, int nSkipMipLevels = 0 ); + virtual bool Serialize( CUtlBuffer &buf ); + + virtual void GetMipmapRange( int* pOutFinest, int* pOutCoarsest ); + + // Attributes... + virtual int Width() const; + virtual int Height() const; + virtual int Depth() const; + virtual int MipCount() const; + + virtual int RowSizeInBytes( int nMipLevel ) const; + virtual int FaceSizeInBytes( int nMipLevel ) const; + + virtual ImageFormat Format() const; + virtual int FaceCount() const; + virtual int FrameCount() const; + virtual int Flags() const; + + virtual float BumpScale() const; + virtual const Vector &Reflectivity() const; + + virtual bool IsCubeMap() const; + virtual bool IsNormalMap() const; + virtual bool IsVolumeTexture() const; + + virtual int LowResWidth() const; + virtual int LowResHeight() const; + virtual ImageFormat LowResFormat() const; + + // Computes the size (in bytes) of a single mipmap of a single face of a single frame + virtual int ComputeMipSize( int iMipLevel ) const; + + // Computes the size (in bytes) of a single face of a single frame + // All mip levels starting at the specified mip level are included + virtual int ComputeFaceSize( int iStartingMipLevel = 0 ) const; + + // Computes the total size of all faces, all frames + virtual int ComputeTotalSize( ) const; + + // Computes the dimensions of a particular mip level + virtual void ComputeMipLevelDimensions( int iMipLevel, int *pWidth, int *pHeight, int *pMipDepth ) const; + + // Computes the size of a subrect (specified at the top mip level) at a particular lower mip level + virtual void ComputeMipLevelSubRect( Rect_t* pSrcRect, int nMipLevel, Rect_t *pSubRect ) const; + + // Returns the base address of the image data + virtual unsigned char *ImageData(); + + // Returns a pointer to the data associated with a particular frame, face, and mip level + virtual unsigned char *ImageData( int iFrame, int iFace, int iMipLevel ); + + // Returns a pointer to the data associated with a particular frame, face, mip level, and offset + virtual unsigned char *ImageData( int iFrame, int iFace, int iMipLevel, int x, int y, int z ); + + // Returns the base address of the low-res image data + virtual unsigned char *LowResImageData(); + + // Converts the texture's image format. Use IMAGE_FORMAT_DEFAULT + virtual void ConvertImageFormat( ImageFormat fmt, bool bNormalToDUDV ); + + // Generate spheremap based on the current cube faces (only works for cubemaps) + // The look dir indicates the direction of the center of the sphere + virtual void GenerateSpheremap( LookDir_t lookDir ); + + virtual void GenerateHemisphereMap( unsigned char *pSphereMapBitsRGBA, int targetWidth, + int targetHeight, LookDir_t lookDir, int iFrame ); + + // Fixes the cubemap faces orientation from our standard to the + // standard the material system needs. + virtual void FixCubemapFaceOrientation( ); + + // Normalize the top mip level if necessary + virtual void NormalizeTopMipLevel(); + + // Generates mipmaps from the base mip levels + virtual void GenerateMipmaps(); + + // Put 1/miplevel (1..n) into alpha. + virtual void PutOneOverMipLevelInAlpha(); + + // Computes the reflectivity + virtual void ComputeReflectivity( ); + + // Computes the alpha flags + virtual void ComputeAlphaFlags(); + + // Gets the texture all internally consistent assuming you've loaded + // mip 0 of all faces of all frames + virtual void PostProcess(bool bGenerateSpheremap, LookDir_t lookDir = LOOK_DOWN_Z, bool bAllowFixCubemapOrientation = true); + virtual void SetPostProcessingSettings( VtfProcessingOptions const *pOptions ); + + // Generate the low-res image bits + virtual bool ConstructLowResImage(); + + virtual void MatchCubeMapBorders( int iStage, ImageFormat finalFormat, bool bSkybox ); + + // Sets threshhold values for alphatest mipmapping + virtual void SetAlphaTestThreshholds( float flBase, float flHighFreq ); + +#if defined( _X360 ) + virtual int UpdateOrCreate( const char *pFilename, const char *pPathID = NULL, bool bForce = false ); + virtual int FileSize( bool bPreloadOnly, int nMipSkipCount ) const; + virtual bool UnserializeFromBuffer( CUtlBuffer &buf, bool bBufferIsVolatile, bool bHeaderOnly, bool bPreloadOnly, int nMipSkipCount ); + virtual bool IsPreTiled() const; + virtual int MappingWidth() const; + virtual int MappingHeight() const; + virtual int MappingDepth() const; + virtual int MipSkipCount() const; + virtual unsigned char *LowResImageSample(); + virtual void ReleaseImageMemory(); +#endif + +private: + // Unserialization + bool ReadHeader( CUtlBuffer &buf, VTFFileHeader_t &header ); + + void BlendCubeMapEdgePalettes( + int iFrame, + int iMipLevel, + const CEdgeMatch *pMatch ); + + void BlendCubeMapCornerPalettes( + int iFrame, + int iMipLevel, + const CCornerMatch *pMatch ); + + void MatchCubeMapS3TCPalettes( + CEdgeMatch edgeMatches[NUM_EDGE_MATCHES], + CCornerMatch cornerMatches[NUM_CORNER_MATCHES] + ); + + void SetupFaceVert( int iMipLevel, int iVert, CEdgePos &out ); + void SetupEdgeIncrement( CEdgePos &start, CEdgePos &end, CEdgePos &inc ); + + void SetupTextureEdgeIncrements( + int iMipLevel, + int iFace1Edge, + int iFace2Edge, + bool bFlipFace2Edge, + CEdgeIncrements *incs ); + + void BlendCubeMapFaceEdges( + int iFrame, + int iMipLevel, + const CEdgeMatch *pMatch ); + + void BlendCubeMapFaceCorners( + int iFrame, + int iMipLevel, + const CCornerMatch *pMatch ); + + void BuildCubeMapMatchLists( CEdgeMatch edgeMatches[NUM_EDGE_MATCHES], CCornerMatch cornerMatches[NUM_CORNER_MATCHES], bool bSkybox ); + + // Allocate image data blocks with an eye toward re-using memory + bool AllocateImageData( int nMemorySize ); + bool AllocateLowResImageData( int nMemorySize ); + + // Compute the mip count based on the size + flags + int ComputeMipCount( ) const; + + // Unserialization of low-res data + bool LoadLowResData( CUtlBuffer &buf ); + + // Unserialization of new resource data + bool LoadNewResources( CUtlBuffer &buf ); + + // Unserialization of image data + bool LoadImageData( CUtlBuffer &buf, const VTFFileHeader_t &header, int nSkipMipLevels ); + + // Shutdown + void Shutdown(); + void ReleaseResources(); + + // Makes a single frame of spheremap + void ComputeSpheremapFrame( unsigned char **ppCubeFaces, unsigned char *pSpheremap, LookDir_t lookDir ); + + // Makes a single frame of spheremap + void ComputeHemispheremapFrame( unsigned char **ppCubeFaces, unsigned char *pSpheremap, LookDir_t lookDir ); + + // Serialization of image data + bool WriteImageData( CUtlBuffer &buf ); + + // Computes the size (in bytes) of a single mipmap of a single face of a single frame + int ComputeMipSize( int iMipLevel, ImageFormat fmt ) const; + + // Computes the size (in bytes) of a single face of a single frame + // All mip levels starting at the specified mip level are included + int ComputeFaceSize( int iStartingMipLevel, ImageFormat fmt ) const; + + // Computes the total size of all faces, all frames + int ComputeTotalSize( ImageFormat fmt ) const; + + // Computes the location of a particular face, frame, and mip level + int GetImageOffset( int iFrame, int iFace, int iMipLevel, ImageFormat fmt ) const; + + // Determines if the vtf or vtfx file needs to be swapped to the current platform + bool SetupByteSwap( CUtlBuffer &buf ); + + // Locates the resource entry info if it's present + ResourceEntryInfo *FindResourceEntryInfo( unsigned int eType ); + ResourceEntryInfo const *FindResourceEntryInfo( unsigned int eType ) const; + + // Inserts the resource entry info if it's not present + ResourceEntryInfo *FindOrCreateResourceEntryInfo( unsigned int eType ); + + // Removes the resource entry info if it's present + bool RemoveResourceEntryInfo( unsigned int eType ); + +#if defined( _X360 ) + bool ReadHeader( CUtlBuffer &buf, VTFFileHeaderX360_t &header ); + bool LoadImageData( CUtlBuffer &buf, bool bBufferIsVolatile, int nMipSkipCount ); +#endif + +private: + // This is to make sure old-format .vtf files are read properly + int m_nVersion[2]; + + int m_nWidth; + int m_nHeight; + int m_nDepth; + ImageFormat m_Format; + + int m_nMipCount; + int m_nFaceCount; + int m_nFrameCount; + + int m_nImageAllocSize; + int m_nFlags; + unsigned char *m_pImageData; + + Vector m_vecReflectivity; + float m_flBumpScale; + + // FIXME: Do I need this? + int m_iStartFrame; + + // Low res data + int m_nLowResImageAllocSize; + ImageFormat m_LowResImageFormat; + int m_nLowResImageWidth; + int m_nLowResImageHeight; + unsigned char *m_pLowResImageData; + + // Used while fixing mipmap edges. + CUtlVector<S3RGBA> m_OriginalData; + + // Alpha threshholds + float m_flAlphaThreshhold; + float m_flAlphaHiFreqThreshhold; + + CByteswap m_Swap; + + int m_nFinestMipmapLevel; + int m_nCoarsestMipmapLevel; + +#if defined( _X360 ) + int m_iPreloadDataSize; + int m_iCompressedSize; + // resolves actual dimensions to/from mapping dimensions due to pre-picmipping + int m_nMipSkipCount; + unsigned char m_LowResImageSample[4]; +#endif + + CUtlVector< ResourceEntryInfo > m_arrResourcesInfo; + + struct ResourceMemorySection + { + ResourceMemorySection() { memset( this, 0, sizeof( *this ) ); } + + int m_nDataAllocSize; + int m_nDataLength; + unsigned char *m_pData; + + bool AllocateData( int nMemorySize ); + bool LoadData( CUtlBuffer &buf, CByteswap &byteSwap ); + bool WriteData( CUtlBuffer &buf ) const; + }; + CUtlVector< ResourceMemorySection > m_arrResourcesData; + CUtlVector< ResourceMemorySection > m_arrResourcesData_ForReuse; // Maintained to keep allocated memory blocks when unserializing from files + + VtfProcessingOptions m_Options; +}; + +#endif // CVTF_H |