Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.

291 lines
8.0 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "movieobjects/dmetexture.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "movieobjects_interfaces.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imaterialsystem.h"
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeBaseTexture, CDmeBaseTexture );
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
void CDmeBaseTexture::OnConstruction()
{
m_pVTFTexture = CreateVTFTexture();
m_bClampS.Init( this, "clampS" );
m_bClampT.Init( this, "clampT" );
m_bClampU.Init( this, "clampU" );
m_bNoLod.Init( this, "noMipmapLOD" );
m_bNiceFiltered.Init( this, "niceFiltered" );
m_bNormalMap.Init( this, "normalMap" );
m_flBumpScale.Init( this, "bumpScale" );
m_nCompressType.Init( this, "compressType" );
m_nFilterType.Init( this, "filterType" );
m_nMipmapType.Init( this, "mipmapType" );
}
void CDmeBaseTexture::OnDestruction()
{
if ( m_pVTFTexture )
{
DestroyVTFTexture( m_pVTFTexture );
m_pVTFTexture = NULL;
}
}
//-----------------------------------------------------------------------------
// accessor for cached ITexture
//-----------------------------------------------------------------------------
ITexture *CDmeBaseTexture::GetCachedTexture()
{
return m_Texture;
}
//-----------------------------------------------------------------------------
// Computes texture flags
//-----------------------------------------------------------------------------
int CDmeBaseTexture::CalcTextureFlags( int nDepth ) const
{
int nFlags = 0;
if ( m_bClampS )
{
nFlags |= TEXTUREFLAGS_CLAMPS;
}
if ( m_bClampT )
{
nFlags |= TEXTUREFLAGS_CLAMPT;
}
if ( m_bClampU )
{
nFlags |= TEXTUREFLAGS_CLAMPU;
}
if ( m_bNoLod )
{
nFlags |= TEXTUREFLAGS_NOLOD;
}
if ( m_bNiceFiltered )
{
nFlags |= TEXTUREFLAGS_NICEFILTERED;
}
if ( m_bNormalMap )
{
nFlags |= TEXTUREFLAGS_NORMAL;
}
if ( m_bNormalMap )
{
nFlags |= TEXTUREFLAGS_NORMAL;
}
if ( m_bNoDebugOverride )
{
nFlags |= TEXTUREFLAGS_NODEBUGOVERRIDE;
}
switch ( m_nCompressType )
{
case DMETEXTURE_COMPRESS_DEFAULT:
case DMETEXTURE_COMPRESS_DXT1:
break;
case DMETEXTURE_COMPRESS_NONE:
nFlags |= TEXTUREFLAGS_NOCOMPRESS;
break;
case DMETEXTURE_COMPRESS_DXT5:
nFlags |= TEXTUREFLAGS_HINT_DXT5;
break;
}
switch ( m_nFilterType )
{
case DMETEXTURE_FILTER_DEFAULT:
case DMETEXTURE_FILTER_BILINEAR:
break;
case DMETEXTURE_FILTER_ANISOTROPIC:
nFlags |= TEXTUREFLAGS_ANISOTROPIC;
break;
case DMETEXTURE_FILTER_TRILINEAR:
nFlags |= TEXTUREFLAGS_TRILINEAR;
break;
case DMETEXTURE_FILTER_POINT:
nFlags |= TEXTUREFLAGS_POINTSAMPLE;
break;
}
switch ( m_nMipmapType )
{
case DMETEXTURE_MIPMAP_DEFAULT:
case DMETEXTURE_MIPMAP_ALL_LEVELS:
break;
case DMETEXTURE_MIPMAP_NONE:
nFlags |= TEXTUREFLAGS_NOMIP;
break;
}
if ( nDepth > 1 )
{
// FIXME: Volume textures don't currently support DXT compression
nFlags &= ~TEXTUREFLAGS_HINT_DXT5;
nFlags |= TEXTUREFLAGS_NOCOMPRESS;
// FIXME: Volume textures don't currently support NICE filtering
nFlags &= ~TEXTUREFLAGS_NICEFILTERED;
}
return nFlags;
}
//-----------------------------------------------------------------------------
// Computes the desired texture format based on flags
//-----------------------------------------------------------------------------
ImageFormat CDmeBaseTexture::ComputeDesiredImageFormat( ImageFormat srcFormat, int nWidth, int nHeight, int nDepth, int nFlags )
{
// HDRFIXME: Need to figure out what format to use here.
if ( srcFormat == IMAGE_FORMAT_RGB323232F )
return IMAGE_FORMAT_RGBA16161616F;
/*
if( bDUDVTarget)
{
if ( bCopyAlphaToLuminance && ( nFlags & ( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA ) ) )
return IMAGE_FORMAT_UVLX8888;
return IMAGE_FORMAT_UV88;
}
*/
// can't compress textures that are smaller than 4x4
if ( (nFlags & TEXTUREFLAGS_NOCOMPRESS) || (nFlags & TEXTUREFLAGS_PROCEDURAL) ||
( nWidth < 4 ) || ( nHeight < 4 ) || ( nDepth > 1 ) )
{
if ( nFlags & ( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA ) )
return IMAGE_FORMAT_BGRA8888;
return IMAGE_FORMAT_BGR888;
}
if( nFlags & TEXTUREFLAGS_HINT_DXT5 )
return IMAGE_FORMAT_DXT5;
// compressed with alpha blending
if ( nFlags & TEXTUREFLAGS_EIGHTBITALPHA )
return IMAGE_FORMAT_DXT5;
if ( nFlags & TEXTUREFLAGS_ONEBITALPHA )
return IMAGE_FORMAT_DXT5; // IMAGE_FORMAT_DXT1_ONEBITALPHA
return IMAGE_FORMAT_DXT1;
}
//-----------------------------------------------------------------------------
//
// Normal texture
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeTexture, CDmeTexture );
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
void CDmeTexture::OnConstruction()
{
m_Images.Init( this, "images" );
}
void CDmeTexture::OnDestruction()
{
}
//-----------------------------------------------------------------------------
// Build a VTF representing the
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// resolve
//-----------------------------------------------------------------------------
void CDmeTexture::Resolve()
{
// FIXME: Could change this to not shutdown if only the bits have changed
m_Texture.Shutdown();
int nFrameCount = m_Images.Count();
if ( nFrameCount == 0 )
return;
// Use the size of the 0th image
CDmeImage *pImage = m_Images[0];
int nWidth = pImage->m_Width;
int nHeight = pImage->m_Height;
int nDepth = pImage->m_Depth;
ImageFormat srcFormat = pImage->Format();
// FIXME: How should this work exactly?
int nFlags = CalcTextureFlags( nDepth );
m_pVTFTexture->Init( nWidth, nHeight, nDepth, srcFormat, nFlags, nFrameCount );
ImageFormat format = ComputeDesiredImageFormat( pImage->Format(), nWidth, nHeight, nDepth, nFlags );
// m_Texture.InitProceduralTexture( GetName(), "DmeTexture", nWidth, nHeight, nDepth, nFrameCount, format, nFlags );
// m_Texture->SetTextureRegenerator( this );
// Fill in the texture bits
}
/*
//-----------------------------------------------------------------------------
// Fill in the texture bits
//-----------------------------------------------------------------------------
void CDmeTexture::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
{
}
*/
//-----------------------------------------------------------------------------
//
// Cube texture
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeCubeTexture, CDmeCubeTexture );
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
void CDmeCubeTexture::OnConstruction()
{
m_ImagesPosX.Init( this, "imagesPosX" );
m_ImagesNegX.Init( this, "imagesNegX" );
m_ImagesPosY.Init( this, "imagesPosY" );
m_ImagesNegY.Init( this, "imagesNegY" );
m_ImagesPosZ.Init( this, "imagesPosZ" );
m_ImagesNegZ.Init( this, "imagesNegZ" );
}
void CDmeCubeTexture::OnDestruction()
{
}