593 lines
17 KiB
C++
593 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include "const.h"
|
|
#include "Sprite.h"
|
|
#include "Material.h" // FIXME: we need to work only with IEditorTexture!
|
|
#include "materialsystem/imaterial.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "Render3d.h"
|
|
#include "camera.h"
|
|
#include "tier1/utldict.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
class CSpriteDataCache
|
|
{
|
|
public:
|
|
CMaterial *m_pMaterial;
|
|
IMaterialVar *m_pFrameVar;
|
|
IMaterialVar *m_pRenderModeVar;
|
|
IMaterialVar *m_pOrientationVar;
|
|
IMaterialVar *m_pOriginVar;
|
|
int m_Width;
|
|
int m_Height;
|
|
bool m_bOriginVarFound;
|
|
bool m_bOrientationVarFound;
|
|
};
|
|
|
|
|
|
CUtlDict<CSpriteDataCache*, int> g_SpriteDataCache;
|
|
SpriteCache_t CSpriteCache::m_Cache[SPRITE_CACHE_SIZE];
|
|
int CSpriteCache::m_nItems = 0;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns an instance of a particular studio model. If the model is
|
|
// in the cache, a pointer to that model is returned. If not, a new one
|
|
// is created and added to the cache.
|
|
// Input : pszModelPath - Full path of the .MDL file.
|
|
//-----------------------------------------------------------------------------
|
|
CSpriteModel *CSpriteCache::CreateSprite(const char *pszSpritePath)
|
|
{
|
|
//
|
|
// First look for the sprite in the cache. If it's there, increment the
|
|
// reference count and return a pointer to the cached sprite.
|
|
//
|
|
for (int i = 0; i < m_nItems; i++)
|
|
{
|
|
if (!stricmp(pszSpritePath, m_Cache[i].pszPath))
|
|
{
|
|
m_Cache[i].nRefCount++;
|
|
return(m_Cache[i].pSprite);
|
|
}
|
|
}
|
|
|
|
//
|
|
// If it isn't there, try to create one.
|
|
//
|
|
CSpriteModel *pSprite = new CSpriteModel;
|
|
|
|
if (pSprite != NULL)
|
|
{
|
|
if (!pSprite->LoadSprite(pszSpritePath))
|
|
{
|
|
delete pSprite;
|
|
pSprite = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we successfully created it, add it to the cache.
|
|
//
|
|
if (pSprite != NULL)
|
|
{
|
|
CSpriteCache::AddSprite(pSprite, pszSpritePath);
|
|
}
|
|
|
|
return(pSprite);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds the model to the cache, setting the reference count to one.
|
|
// Input : pModel - Model to add to the cache.
|
|
// pszSpritePath - The full path of the .MDL file, which is used as a
|
|
// key in the sprite cache.
|
|
// Output : Returns TRUE if the sprite was successfully added, FALSE if we ran
|
|
// out of memory trying to add the sprite to the cache.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSpriteCache::AddSprite(CSpriteModel *pSprite, const char *pszSpritePath)
|
|
{
|
|
//
|
|
// Copy the sprite pointer.
|
|
//
|
|
m_Cache[m_nItems].pSprite = pSprite;
|
|
|
|
//
|
|
// Allocate space for and copy the model path.
|
|
//
|
|
m_Cache[m_nItems].pszPath = new char [strlen(pszSpritePath) + 1];
|
|
if (m_Cache[m_nItems].pszPath != NULL)
|
|
{
|
|
strcpy(m_Cache[m_nItems].pszPath, pszSpritePath);
|
|
}
|
|
else
|
|
{
|
|
return(false);
|
|
}
|
|
|
|
m_Cache[m_nItems].nRefCount = 1;
|
|
|
|
m_nItems++;
|
|
|
|
return(true);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Increments the reference count on a sprite in the cache. Called by
|
|
// client code when a pointer to the sprite is copied, making that
|
|
// reference independent.
|
|
// Input : pModel - Sprite for which to increment the reference count.
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteCache::AddRef(CSpriteModel *pSprite)
|
|
{
|
|
for (int i = 0; i < m_nItems; i++)
|
|
{
|
|
if (m_Cache[i].pSprite == pSprite)
|
|
{
|
|
m_Cache[i].nRefCount++;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called by client code to release an instance of a model. If the
|
|
// model's reference count is zero, the model is freed.
|
|
// Input : pModel - Pointer to the model to release.
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteCache::Release(CSpriteModel *pSprite)
|
|
{
|
|
for (int i = 0; i < m_nItems; i++)
|
|
{
|
|
if (m_Cache[i].pSprite == pSprite)
|
|
{
|
|
m_Cache[i].nRefCount--;
|
|
Assert(m_Cache[i].nRefCount >= 0);
|
|
|
|
//
|
|
// If this model is no longer referenced, free it and remove it
|
|
// from the cache.
|
|
//
|
|
if (m_Cache[i].nRefCount <= 0)
|
|
{
|
|
//
|
|
// Free the path, which was allocated by AddModel.
|
|
//
|
|
delete [] m_Cache[i].pszPath;
|
|
delete m_Cache[i].pSprite;
|
|
|
|
//
|
|
// Decrement the item count and copy the last element in the cache over
|
|
// this element.
|
|
//
|
|
m_nItems--;
|
|
|
|
m_Cache[i].pSprite = m_Cache[m_nItems].pSprite;
|
|
m_Cache[i].pszPath = m_Cache[m_nItems].pszPath;
|
|
m_Cache[i].nRefCount = m_Cache[m_nItems].nRefCount;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSpriteModel::CSpriteModel(void) :
|
|
m_pMaterial(0), m_NumFrames(-1), m_fScale(1.0), m_Origin(0,0,0), m_UL(0,0), m_LR(0,0), m_TexUL(0,1), m_TexLR(1,0), m_bInvert(false)
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor. Frees the sprite image and descriptor.
|
|
//-----------------------------------------------------------------------------
|
|
CSpriteModel::~CSpriteModel(void)
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the render mode
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteModel::SetRenderMode( const int mode )
|
|
{
|
|
if (m_pMaterial && m_pRenderModeVar)
|
|
{
|
|
if ( mode != m_pRenderModeVar->GetIntValue() )
|
|
{
|
|
m_pRenderModeVar->SetIntValue( mode );
|
|
m_pMaterial->GetMaterial()->RecomputeStateSnapshots();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pEntity -
|
|
// type -
|
|
// forward -
|
|
// right -
|
|
// up -
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteModel::GetSpriteAxes(QAngle& Angles, int type, Vector& forward, Vector& right, Vector& up, Vector& ViewUp, Vector& ViewRight, Vector& ViewForward)
|
|
{
|
|
int i;
|
|
float dot, angle, sr, cr;
|
|
Vector tvec;
|
|
|
|
// Automatically roll parallel sprites if requested
|
|
if (Angles[2] != 0 && type == SPR_VP_PARALLEL )
|
|
{
|
|
type = SPR_VP_PARALLEL_ORIENTED;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case SPR_FACING_UPRIGHT:
|
|
{
|
|
// generate the sprite's axes, with vup straight up in worldspace, and
|
|
// r_spritedesc.vright perpendicular to modelorg.
|
|
// This will not work if the view direction is very close to straight up or
|
|
// down, because the cross product will be between two nearly parallel
|
|
// vectors and starts to approach an undefined state, so we don't draw if
|
|
// the two vectors are less than 1 degree apart
|
|
tvec[0] = -m_Origin[0];
|
|
tvec[1] = -m_Origin[1];
|
|
tvec[2] = -m_Origin[2];
|
|
VectorNormalize (tvec);
|
|
dot = tvec[2]; // same as DotProduct (tvec, r_spritedesc.vup) because
|
|
// r_spritedesc.vup is 0, 0, 1
|
|
if ((dot > 0.999848) || (dot < -0.999848)) // cos(1 degree) = 0.999848
|
|
return;
|
|
up[0] = 0;
|
|
up[1] = 0;
|
|
up[2] = 1;
|
|
right[0] = tvec[1];
|
|
// CrossProduct(r_spritedesc.vup, -modelorg,
|
|
right[1] = -tvec[0];
|
|
// r_spritedesc.vright)
|
|
right[2] = 0;
|
|
VectorNormalize (right);
|
|
forward[0] = -right[1];
|
|
forward[1] = right[0];
|
|
forward[2] = 0;
|
|
// CrossProduct (r_spritedesc.vright, r_spritedesc.vup,
|
|
// r_spritedesc.vpn)
|
|
break;
|
|
}
|
|
|
|
case SPR_VP_PARALLEL:
|
|
{
|
|
// generate the sprite's axes, completely parallel to the viewplane. There
|
|
// are no problem situations, because the sprite is always in the same
|
|
// position relative to the viewer
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
up[i] = ViewUp[i];
|
|
right[i] = ViewRight[i];
|
|
forward[i] = ViewForward[i];
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SPR_VP_PARALLEL_UPRIGHT:
|
|
{
|
|
// generate the sprite's axes, with vup straight up in worldspace, and
|
|
// r_spritedesc.vright parallel to the viewplane.
|
|
// This will not work if the view direction is very close to straight up or
|
|
// down, because the cross product will be between two nearly parallel
|
|
// vectors and starts to approach an undefined state, so we don't draw if
|
|
// the two vectors are less than 1 degree apart
|
|
dot = ViewForward[2]; // same as DotProduct (vpn, r_spritedesc.vup) because
|
|
// r_spritedesc.vup is 0, 0, 1
|
|
if ((dot > 0.999848) || (dot < -0.999848)) // cos(1 degree) = 0.999848
|
|
return;
|
|
|
|
up[0] = 0;
|
|
up[1] = 0;
|
|
up[2] = 1;
|
|
|
|
right[0] = ViewForward[1];
|
|
right[1] = -ViewForward[0];
|
|
right[2] = 0;
|
|
VectorNormalize (right);
|
|
|
|
forward[0] = -right[1];
|
|
forward[1] = right[0];
|
|
forward[2] = 0;
|
|
break;
|
|
}
|
|
|
|
case SPR_ORIENTED:
|
|
{
|
|
// generate the sprite's axes, according to the sprite's world orientation
|
|
AngleVectors(Angles, &forward, &right, &up);
|
|
break;
|
|
}
|
|
|
|
case SPR_VP_PARALLEL_ORIENTED:
|
|
{
|
|
// generate the sprite's axes, parallel to the viewplane, but rotated in
|
|
// that plane around the center according to the sprite entity's roll
|
|
// angle. So vpn stays the same, but vright and vup rotate
|
|
angle = Angles[ROLL] * (M_PI*2 / 360);
|
|
sr = sin(angle);
|
|
cr = cos(angle);
|
|
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
forward[i] = ViewForward[i];
|
|
right[i] = ViewRight[i] * cr + ViewUp[i] * sr;
|
|
up[i] = ViewRight[i] * -sr + ViewUp[i] * cr;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
//Sys_Error ("R_DrawSprite: Bad sprite type %d", type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the sprite's scale
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::SetScale( const float fScale )
|
|
{
|
|
m_fScale = fScale;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the sprite's origin
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::SetOrigin( const Vector &v )
|
|
{
|
|
m_Origin = v;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the sprite's origin
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::GetOrigin( Vector &v )
|
|
{
|
|
v = m_Origin;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the sprite's vertical inversion
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::SetInvert( const bool b )
|
|
{
|
|
m_bInvert = b;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets the Euler angles for the model.
|
|
// Input : fAngles - A pointer to engine PITCH, YAW, and ROLL angles.
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteModel::SetAngles( const QAngle& pfAngles )
|
|
{
|
|
m_Angles[PITCH] = pfAngles[PITCH];
|
|
m_Angles[YAW] = pfAngles[YAW];
|
|
m_Angles[ROLL] = pfAngles[ROLL];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the material's primative type
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::SetMaterialPrimitiveType( const MaterialPrimitiveType_t type )
|
|
{
|
|
m_MaterialPrimitiveType = type;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders the sprite in 3D mode
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSpriteModel::DrawSprite3D( CRender3D *pRender, unsigned char color[3] )
|
|
{
|
|
Vector corner, spritex, spritey, spritez;
|
|
Vector ViewUp;
|
|
Vector ViewRight;
|
|
Vector ViewForward;
|
|
|
|
pRender->GetViewUp( ViewUp );
|
|
pRender->GetViewRight( ViewRight );
|
|
pRender->GetViewForward( ViewForward );
|
|
|
|
GetSpriteAxes(m_Angles, GetType(), spritez, spritex, spritey, ViewUp, ViewRight, ViewForward);
|
|
|
|
Vector2D ul, lr;
|
|
Vector2DMultiply( m_UL, m_fScale, ul );
|
|
Vector2DMultiply( m_LR, m_fScale, lr );
|
|
|
|
VectorMA( m_Origin, ul.x, spritex, corner );
|
|
VectorMA( corner, lr.y, spritey, corner );
|
|
spritex *= (lr.x - ul.x);
|
|
spritey *= (ul.y - lr.y);
|
|
|
|
Vector2D texul, texlr;
|
|
texul.x = m_TexUL.x;
|
|
texul.y = m_bInvert ? m_TexLR.y : m_TexUL.y;
|
|
texlr.x = m_TexLR.x;
|
|
texlr.y = m_bInvert ? m_TexUL.y : m_TexLR.y;
|
|
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRender->BindTexture( m_pMaterial );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, m_MaterialPrimitiveType, 4 );
|
|
|
|
meshBuilder.Position3fv(corner.Base());
|
|
meshBuilder.TexCoord2f(0, texul.x, texul.y);
|
|
meshBuilder.Color3ub( color[0], color[1], color[2] );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
corner += spritey;
|
|
meshBuilder.Position3fv(corner.Base());
|
|
meshBuilder.TexCoord2f(0, texul.x, texlr.y);
|
|
meshBuilder.Color3ub( color[0], color[1], color[2] );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
corner += spritex;
|
|
meshBuilder.Position3fv(corner.Base());
|
|
meshBuilder.TexCoord2f(0, texlr.x, texlr.y);
|
|
meshBuilder.Color3ub( color[0], color[1], color[2] );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
corner -= spritey;
|
|
meshBuilder.Position3fv(corner.Base());
|
|
meshBuilder.TexCoord2f(0, texlr.x, texul.y);
|
|
meshBuilder.Color3ub( color[0], color[1], color[2] );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Binds a sprite
|
|
//-----------------------------------------------------------------------------
|
|
void CSpriteModel::Bind( CRender* pRender, int frame )
|
|
{
|
|
if (m_pMaterial && m_pFrameVar)
|
|
{
|
|
m_pFrameVar->SetIntValue( frame );
|
|
pRender->BindTexture( m_pMaterial );
|
|
}
|
|
}
|
|
|
|
|
|
CSpriteDataCache* LookupSpriteDataCache( const char *pSpritePath )
|
|
{
|
|
char filename[MAX_PATH];
|
|
V_strncpy( filename, pSpritePath, sizeof( filename ) );
|
|
V_FixSlashes( filename );
|
|
|
|
CSpriteDataCache *pData;
|
|
int i = g_SpriteDataCache.Find( filename );
|
|
if ( i == g_SpriteDataCache.InvalidIndex() )
|
|
{
|
|
pData = new CSpriteDataCache;
|
|
memset( pData, 0, sizeof( *pData ) );
|
|
g_SpriteDataCache.Insert( filename, pData );
|
|
|
|
pData->m_pMaterial = CMaterial::CreateMaterial( filename, true );
|
|
if ( pData->m_pMaterial && pData->m_pMaterial->GetMaterial() )
|
|
{
|
|
pData->m_Width = pData->m_pMaterial->GetWidth();
|
|
pData->m_Height = pData->m_pMaterial->GetHeight();
|
|
pData->m_pFrameVar = pData->m_pMaterial->GetMaterial()->FindVar( "$spriteFrame", 0 );
|
|
pData->m_pRenderModeVar = pData->m_pMaterial->GetMaterial()->FindVar( "$spriterendermode", 0 );
|
|
|
|
pData->m_pOrientationVar = pData->m_pMaterial->GetMaterial()->FindVar( "$spriteOrientation", &pData->m_bOrientationVarFound, false );
|
|
pData->m_pOriginVar = pData->m_pMaterial->GetMaterial()->FindVar( "$spriteorigin", &pData->m_bOriginVarFound );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pData = g_SpriteDataCache[i];
|
|
}
|
|
|
|
return pData;
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Loads a sprite material.
|
|
// Input : pszSpritePath -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSpriteModel::LoadSprite(const char *pszSpritePath)
|
|
{
|
|
CSpriteDataCache *pCache = LookupSpriteDataCache( pszSpritePath );
|
|
|
|
m_pMaterial = pCache->m_pMaterial;
|
|
if( m_pMaterial && m_pMaterial->GetMaterial() )
|
|
{
|
|
m_Width = pCache->m_Width;
|
|
m_Height = pCache->m_Height;
|
|
// FIXME: m_NumFrames = m_pMaterial->GetMaterial()->GetNumAnimationFrames();
|
|
m_pFrameVar = pCache->m_pFrameVar;
|
|
m_pRenderModeVar = pCache->m_pRenderModeVar;
|
|
|
|
IMaterialVar *orientationVar = pCache->m_pOrientationVar;
|
|
bool found = pCache->m_bOrientationVarFound;
|
|
if( found )
|
|
{
|
|
m_Type = orientationVar->GetIntValue();
|
|
}
|
|
else
|
|
{
|
|
m_Type = SPR_VP_PARALLEL_UPRIGHT;
|
|
}
|
|
|
|
IMaterialVar *pOriginVar = pCache->m_pOriginVar;
|
|
Vector origin;
|
|
found = pCache->m_bOriginVarFound;
|
|
if( !found || ( pOriginVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) )
|
|
{
|
|
origin[0] = -m_Width * 0.5f;
|
|
origin[1] = m_Height * 0.5f;
|
|
}
|
|
else
|
|
{
|
|
Vector originVarValue;
|
|
pOriginVar->GetVecValue( originVarValue.Base(), 3);
|
|
origin[0] = -m_Width * originVarValue[0];
|
|
origin[1] = m_Height * originVarValue[1];
|
|
}
|
|
|
|
m_UL.y = origin[1];
|
|
m_LR.y = origin[1] - m_Height;
|
|
m_UL.x = origin[0];
|
|
m_LR.x = m_Width + origin[0];
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Kind of a hack...
|
|
//-----------------------------------------------------------------------------
|
|
int CSpriteModel::GetFrameCount()
|
|
{
|
|
// FIXME: Figure out the correct time to cache in this info
|
|
if ((m_NumFrames < 0) && m_pMaterial)
|
|
{
|
|
m_NumFrames = m_pMaterial->GetMaterial()->GetNumAnimationFrames();
|
|
}
|
|
return (m_NumFrames < 0) ? 0 : m_NumFrames;
|
|
} |