929 lines
29 KiB
C++
929 lines
29 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "studio.h"
|
|
#include "studiorendercontext.h"
|
|
#include "bitmap/imageformat.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "materialsystem/imaterialvar.h"
|
|
#include "materialsystem/itexture.h"
|
|
#include "materialsystem/imesh.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "studiorender.h"
|
|
#include "pixelwriter.h"
|
|
#include "vtf/vtf.h"
|
|
#include "tier1/convar.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "tier0/vprof.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define sign( a ) (((a) < 0) ? -1 : (((a) > 0) ? 1 : 0 ))
|
|
|
|
void CStudioRender::R_StudioEyeballPosition( const mstudioeyeball_t *peyeball, eyeballstate_t *pstate )
|
|
{
|
|
// Vector forward;
|
|
// Vector org, right, up;
|
|
|
|
pstate->peyeball = peyeball;
|
|
|
|
Vector tmp;
|
|
// move eyeball into worldspace
|
|
{
|
|
// ConDMsg("%.2f %.2f %.2f\n", peyeball->org[0], peyeball->org[1], peyeball->org[2] );
|
|
|
|
VectorCopy( peyeball->org, tmp );
|
|
|
|
tmp[0] += m_pRC->m_Config.fEyeShiftX * sign( tmp[0] );
|
|
tmp[1] += m_pRC->m_Config.fEyeShiftY * sign( tmp[1] );
|
|
tmp[2] += m_pRC->m_Config.fEyeShiftZ * sign( tmp[2] );
|
|
}
|
|
VectorTransform( tmp, m_pBoneToWorld[peyeball->bone], pstate->org );
|
|
VectorRotate( peyeball->up, m_pBoneToWorld[peyeball->bone], pstate->up );
|
|
|
|
// look directly at target
|
|
VectorSubtract( m_pRC->m_ViewTarget, pstate->org, pstate->forward );
|
|
VectorNormalize( pstate->forward );
|
|
|
|
if ( !m_pRC->m_Config.bEyeMove )
|
|
{
|
|
VectorRotate( peyeball->forward, m_pBoneToWorld[peyeball->bone], pstate->forward );
|
|
VectorScale( pstate->forward, -1 ,pstate->forward ); // ???
|
|
}
|
|
|
|
CrossProduct( pstate->forward, pstate->up, pstate->right );
|
|
VectorNormalize( pstate->right );
|
|
|
|
// shift N degrees off of the target
|
|
float dz;
|
|
dz = peyeball->zoffset;
|
|
|
|
VectorMA( pstate->forward, peyeball->zoffset + dz, pstate->right, pstate->forward );
|
|
|
|
#if 0
|
|
// add random jitter
|
|
VectorMA( forward, RandomFloat( -0.02, 0.02 ), right, forward );
|
|
VectorMA( forward, RandomFloat( -0.02, 0.02 ), up, forward );
|
|
#endif
|
|
|
|
VectorNormalize( pstate->forward );
|
|
// re-aim eyes
|
|
CrossProduct( pstate->forward, pstate->up, pstate->right );
|
|
VectorNormalize( pstate->right );
|
|
|
|
CrossProduct( pstate->right, pstate->forward, pstate->up );
|
|
VectorNormalize( pstate->up );
|
|
|
|
float scale = (1.0 / peyeball->iris_scale) + m_pRC->m_Config.fEyeSize;
|
|
|
|
if (scale > 0)
|
|
scale = 1.0 / scale;
|
|
|
|
VectorScale( &pstate->right[0], -scale, pstate->mat[0] );
|
|
VectorScale( &pstate->up[0], -scale, pstate->mat[1] );
|
|
|
|
pstate->mat[0][3] = -DotProduct( &pstate->org[0], pstate->mat[0] ) + 0.5f;
|
|
pstate->mat[1][3] = -DotProduct( &pstate->org[0], pstate->mat[1] ) + 0.5f;
|
|
|
|
// FIXME: push out vertices for cornea
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CStudioRender::R_StudioEyelidFACS( const mstudioeyeball_t *peyeball, const eyeballstate_t *pstate )
|
|
{
|
|
if ( peyeball->m_bNonFACS )
|
|
return;
|
|
|
|
Vector headup;
|
|
Vector headforward;
|
|
Vector pos;
|
|
|
|
float upperlid = DEG2RAD( 9.5 );
|
|
float lowerlid = DEG2RAD( -26.4 );
|
|
|
|
// FIXME: Crash workaround
|
|
Vector vecNormTarget;
|
|
vecNormTarget.Init( peyeball->uppertarget[0], peyeball->uppertarget[1], peyeball->uppertarget[2] );
|
|
vecNormTarget /= peyeball->radius;
|
|
vecNormTarget.x = clamp( vecNormTarget.x, -1.0f, 1.0f );
|
|
vecNormTarget.y = clamp( vecNormTarget.y, -1.0f, 1.0f );
|
|
vecNormTarget.z = clamp( vecNormTarget.z, -1.0f, 1.0f );
|
|
|
|
// get weighted position of eyeball angles based on the "raiser", "neutral", and "lowerer" controls
|
|
upperlid = m_pFlexWeights[peyeball->upperflexdesc[0]] * asin( vecNormTarget.x );
|
|
upperlid += m_pFlexWeights[peyeball->upperflexdesc[1]] * asin( vecNormTarget.y );
|
|
upperlid += m_pFlexWeights[peyeball->upperflexdesc[2]] * asin( vecNormTarget.z );
|
|
|
|
vecNormTarget.Init( peyeball->lowertarget[0], peyeball->lowertarget[1], peyeball->lowertarget[2] );
|
|
vecNormTarget /= peyeball->radius;
|
|
vecNormTarget.x = clamp( vecNormTarget.x, -1.0f, 1.0f );
|
|
vecNormTarget.y = clamp( vecNormTarget.y, -1.0f, 1.0f );
|
|
vecNormTarget.z = clamp( vecNormTarget.z, -1.0f, 1.0f );
|
|
|
|
lowerlid = m_pFlexWeights[peyeball->lowerflexdesc[0]] * asin( vecNormTarget.x );
|
|
lowerlid += m_pFlexWeights[peyeball->lowerflexdesc[1]] * asin( vecNormTarget.y );
|
|
lowerlid += m_pFlexWeights[peyeball->lowerflexdesc[2]] * asin( vecNormTarget.z );
|
|
|
|
// ConDMsg("%.1f %.1f\n", RAD2DEG( upperlid ), RAD2DEG( lowerlid ) );
|
|
|
|
float sinupper, cosupper, sinlower, coslower;
|
|
SinCos( upperlid, &sinupper, &cosupper );
|
|
SinCos( lowerlid, &sinlower, &coslower );
|
|
|
|
// convert to head relative space
|
|
VectorIRotate( pstate->up, m_pBoneToWorld[peyeball->bone], headup );
|
|
VectorIRotate( pstate->forward, m_pBoneToWorld[peyeball->bone], headforward );
|
|
|
|
// upper lid
|
|
VectorScale( headup, sinupper * peyeball->radius, pos );
|
|
VectorMA( pos, cosupper * peyeball->radius, headforward, pos );
|
|
m_pFlexWeights[peyeball->upperlidflexdesc] = DotProduct( pos, peyeball->up );
|
|
|
|
// lower lid
|
|
VectorScale( headup, sinlower * peyeball->radius, pos );
|
|
VectorMA( pos, coslower * peyeball->radius, headforward, pos );
|
|
m_pFlexWeights[peyeball->lowerlidflexdesc] = DotProduct( pos, peyeball->up );
|
|
// ConDMsg("%.4f %.4f\n", m_pRC->m_FlexWeights[peyeball->upperlidflex], m_pRC->m_FlexWeights[peyeball->lowerlidflex] );
|
|
}
|
|
|
|
|
|
void CStudioRender::MaterialPlanerProjection( const matrix3x4_t& mat, int count, const Vector *psrcverts, Vector2D *pdesttexcoords )
|
|
{
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
pdesttexcoords[i][0] = DotProduct( &psrcverts[i].x, mat[0] ) + mat[0][3];
|
|
pdesttexcoords[i][1] = DotProduct( &psrcverts[i].x, mat[1] ) + mat[1][3];
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Ramp and clamp the flex weight
|
|
//-----------------------------------------------------------------------------
|
|
float CStudioRender::RampFlexWeight( mstudioflex_t &flex, float w )
|
|
{
|
|
if (w <= flex.target0 || w >= flex.target3)
|
|
{
|
|
// value outside of range
|
|
w = 0.0;
|
|
}
|
|
else if (w < flex.target1)
|
|
{
|
|
// 0 to 1 ramp
|
|
w = (w - flex.target0) / (flex.target1 - flex.target0);
|
|
}
|
|
else if (w > flex.target2)
|
|
{
|
|
// 1 to 0 ramp
|
|
w = (flex.target3 - w) / (flex.target3 - flex.target2);
|
|
}
|
|
else
|
|
{
|
|
// plat
|
|
w = 1.0;
|
|
}
|
|
return w;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Setup the flex verts for this rendering
|
|
//-----------------------------------------------------------------------------
|
|
void CStudioRender::R_StudioFlexVerts( mstudiomesh_t *pmesh, int lod )
|
|
{
|
|
VPROF_BUDGET( "CStudioRender::R_StudioFlexVerts", VPROF_BUDGETGROUP_MODEL_RENDERING );
|
|
|
|
Assert( pmesh );
|
|
|
|
const float flVertAnimFixedPointScale = m_pStudioHdr->VertAnimFixedPointScale();
|
|
|
|
// There's a chance we can actually do the flex twice on a single mesh
|
|
// since there's flexed HW + SW portions of the mesh.
|
|
if (m_VertexCache.IsFlexComputationDone())
|
|
return;
|
|
|
|
// get pointers to geometry
|
|
if ( !pmesh->pModel()->CacheVertexData( m_pStudioHdr ) )
|
|
{
|
|
// not available yet
|
|
return;
|
|
}
|
|
const mstudio_meshvertexdata_t *vertData = pmesh->GetVertexData( m_pStudioHdr );
|
|
Assert( vertData );
|
|
if ( !vertData )
|
|
{
|
|
static unsigned int warnCount = 0;
|
|
if ( warnCount++ < 20 )
|
|
Warning( "ERROR: R_StudioFlexVerts, model verts have been compressed, cannot render! (use \"-no_compressed_vvds\")" );
|
|
return;
|
|
}
|
|
|
|
// The flex data should have been converted to the new (fixed-point) format on load:
|
|
Assert( m_pStudioHdr->flags & STUDIOHDR_FLAGS_FLEXES_CONVERTED );
|
|
if ( ( m_pStudioHdr->flags & STUDIOHDR_FLAGS_FLEXES_CONVERTED ) == 0 )
|
|
{
|
|
static unsigned int flexConversionTimesWarned = 0;
|
|
if ( flexConversionTimesWarned++ < 6 )
|
|
Warning( "ERROR: flex verts have not been converted (queued loader refcount bug?) - expect to see 'exploded' faces" );
|
|
}
|
|
|
|
|
|
mstudiovertex_t *pVertices = vertData->Vertex( 0 );
|
|
Vector4D *pStudioTangentS;
|
|
if ( vertData->HasTangentData() )
|
|
{
|
|
pStudioTangentS = vertData->TangentS( 0 );
|
|
}
|
|
else
|
|
{
|
|
pStudioTangentS = NULL;
|
|
}
|
|
|
|
mstudioflex_t *pflex = pmesh->pFlex( 0 );
|
|
|
|
m_VertexCache.SetupComputation( pmesh, true );
|
|
|
|
// apply flex weights
|
|
int i, j, n;
|
|
|
|
for (i = 0; i < pmesh->numflexes; i++)
|
|
{
|
|
float w1 = RampFlexWeight( pflex[i], m_pFlexWeights[ pflex[i].flexdesc ] );
|
|
float w2 = RampFlexWeight( pflex[i], m_pFlexDelayedWeights[ pflex[i].flexdesc ] );
|
|
|
|
float w3, w4;
|
|
if ( pflex[i].flexpair != 0)
|
|
{
|
|
w3 = RampFlexWeight( pflex[i], m_pFlexWeights[ pflex[i].flexpair ] );
|
|
w4 = RampFlexWeight( pflex[i], m_pFlexDelayedWeights[ pflex[i].flexpair ] );
|
|
}
|
|
else
|
|
{
|
|
w3 = w1;
|
|
w4 = w2;
|
|
}
|
|
|
|
if ( w1 > -0.001 && w1 < 0.001 && w2 > -0.001 && w2 < 0.001 )
|
|
{
|
|
if ( w3 > -0.001 && w3 < 0.001 && w4 > -0.001 && w4 < 0.001 )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// We may have wrinkle information for this flex, but if we're software skinning
|
|
// we're going to ignore it.
|
|
byte *pvanim = pflex[i].pBaseVertanim();
|
|
int nVAnimSizeBytes = pflex[i].VertAnimSizeBytes();
|
|
|
|
for (j = 0; j < pflex[i].numverts; j++)
|
|
{
|
|
mstudiovertanim_t *pAnim = (mstudiovertanim_t*)( pvanim + j * nVAnimSizeBytes );
|
|
n = pAnim->index;
|
|
|
|
// Only flex the indices that are (still) part of this mesh
|
|
// need lod restriction here
|
|
if (n < pmesh->vertexdata.numLODVertexes[lod])
|
|
{
|
|
mstudiovertex_t &vert = pVertices[n];
|
|
|
|
CachedPosNormTan_t* pFlexedVertex;
|
|
if (!m_VertexCache.IsVertexFlexed(n))
|
|
{
|
|
// Add a new flexed vert to the flexed vertex list
|
|
pFlexedVertex = m_VertexCache.CreateFlexVertex(n);
|
|
// skip processing if no more flexed verts can be allocated
|
|
if (pFlexedVertex == NULL)
|
|
continue;
|
|
|
|
VectorCopy( vert.m_vecPosition, pFlexedVertex->m_Position );
|
|
VectorCopy( vert.m_vecNormal, pFlexedVertex->m_Normal );
|
|
|
|
if (pStudioTangentS)
|
|
{
|
|
Vector4DCopy( pStudioTangentS[n], pFlexedVertex->m_TangentS );
|
|
Assert( pFlexedVertex->m_TangentS.w == -1.0f || pFlexedVertex->m_TangentS.w == 1.0f );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pFlexedVertex = m_VertexCache.GetFlexVertex(n);
|
|
}
|
|
|
|
float s = pAnim->speed * (1.0F/255.0F);
|
|
float b = pAnim->side * (1.0F/255.0F);
|
|
|
|
float w = (w1 * s + (1.0f - s) * w2) * (1.0f - b) + b * (w3 * s + (1.0f - s) * w4);
|
|
|
|
// Accumulate weighted deltas
|
|
pFlexedVertex->m_Position += pAnim->GetDeltaFixed( flVertAnimFixedPointScale ) * w;
|
|
pFlexedVertex->m_Normal += pAnim->GetNDeltaFixed( flVertAnimFixedPointScale ) * w;
|
|
|
|
if ( pStudioTangentS )
|
|
{
|
|
pFlexedVertex->m_TangentS.AsVector3D() += pAnim->GetNDeltaFixed( flVertAnimFixedPointScale ) * w;
|
|
Assert( pFlexedVertex->m_TangentS.w == -1.0f || pFlexedVertex->m_TangentS.w == 1.0f );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_VertexCache.RenormalizeFlexVertices( vertData->HasTangentData() );
|
|
}
|
|
|
|
// REMOVED!! Look in version 32 if you need it.
|
|
//static void R_StudioEyeballNormals( const mstudioeyeball_t *peyeball, int count, const Vector *psrcverts, Vector *pdestnorms )
|
|
|
|
#define KERNEL_DIAMETER 2
|
|
#define KERNEL_TEXELS (KERNEL_DIAMETER)
|
|
#define KERNEL_TEXEL_RADIUS (KERNEL_TEXELS / 2)
|
|
|
|
inline float GlintGaussSpotCoefficient( float dx, float dy /*, float *table */ )
|
|
{
|
|
const float radius = KERNEL_DIAMETER / 2;
|
|
const float rsq = 1.0f / (radius * radius);
|
|
float r2 = (dx * dx + dy * dy) * rsq;
|
|
if (r2 <= 1.0f)
|
|
{
|
|
return exp( -25.0 * r2 );
|
|
// NOTE: This optimization doesn't make much of a difference
|
|
//int index = r2 * (GLINT_TABLE_ENTRIES-1);
|
|
//return table[index];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CStudioRender::AddGlint( CPixelWriter &pixelWriter, float x, float y, const Vector& color )
|
|
{
|
|
x = (x + 0.5f) * m_GlintWidth;
|
|
y = (y + 0.5f) * m_GlintHeight;
|
|
const float texelRadius = KERNEL_DIAMETER / 2;
|
|
|
|
int x0 = (int)x;
|
|
int y0 = (int)y;
|
|
int x1 = x0 + texelRadius;
|
|
int y1 = y0 + texelRadius;
|
|
x0 -= texelRadius;
|
|
y0 -= texelRadius;
|
|
|
|
// clip light to texture
|
|
if ( (x0 >= m_GlintWidth) || (x1 < 0) || (y0 >= m_GlintHeight) || (y1 < 0) )
|
|
return;
|
|
|
|
// clamp coordinates
|
|
if ( x0 < 0 )
|
|
{
|
|
x0 = 0;
|
|
}
|
|
if ( y0 < 0 )
|
|
{
|
|
y0 = 0;
|
|
}
|
|
if ( x1 >= m_GlintWidth )
|
|
{
|
|
x1 = m_GlintWidth-1;
|
|
}
|
|
if ( y1 >= m_GlintHeight )
|
|
{
|
|
y1 = m_GlintHeight-1;
|
|
}
|
|
|
|
for (int v = y0; v <= y1; ++v )
|
|
{
|
|
pixelWriter.Seek( x0, v );
|
|
|
|
for (int u = x0; u <= x1; ++u )
|
|
{
|
|
float fu = ((float)u) - x;
|
|
float fv = ((float)v) - y;
|
|
const float offset = 0.25;
|
|
float intensity = GlintGaussSpotCoefficient( fu-offset, fv-offset ) +
|
|
GlintGaussSpotCoefficient( fu+offset, fv-offset ) +
|
|
5 * GlintGaussSpotCoefficient( fu, fv ) +
|
|
GlintGaussSpotCoefficient( fu-offset, fv+offset ) +
|
|
GlintGaussSpotCoefficient( fu+offset, fv+offset );
|
|
|
|
// NOTE: Old filter code multiplies the signal by 8X, so we will too
|
|
intensity *= (4.0f/9.0f);
|
|
|
|
// NOTE: It's much faster to do the work in the dest texture than to touch the memory more
|
|
// or make more buffers
|
|
Vector outColor = intensity * color;
|
|
int r, g, b, a;
|
|
pixelWriter.ReadPixelNoAdvance( r, g, b, a );
|
|
outColor.x += TextureToLinear(r);
|
|
outColor.y += TextureToLinear(g);
|
|
outColor.z += TextureToLinear(b);
|
|
pixelWriter.WritePixel( LinearToTexture(outColor.x), LinearToTexture(outColor.y), LinearToTexture(outColor.z) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// glint
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// test/stub code
|
|
#if 0
|
|
class CEmptyTextureRegen : public ITextureRegenerator
|
|
{
|
|
public:
|
|
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
|
|
{
|
|
// get the texture
|
|
unsigned char *pTextureData = pVTFTexture->ImageData( 0, 0, 0 );
|
|
int nImageSize = pVTFTexture->ComputeMipSize( 0 );
|
|
memset( pTextureData, 0, nImageSize );
|
|
}
|
|
|
|
// We've got a global instance, no need to delete it
|
|
virtual void Release() {}
|
|
};
|
|
static CEmptyTextureRegen s_GlintTextureRegen;
|
|
#endif
|
|
|
|
class CGlintTextureRegenerator : public ITextureRegenerator
|
|
{
|
|
public:
|
|
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
|
|
{
|
|
// We don't need to reconstitute the bits after a task switch
|
|
// since we reconstitute them every frame they are used anyways
|
|
if ( !m_pStudioRender )
|
|
return;
|
|
|
|
if ( ( m_pStudioRender->m_GlintWidth != pVTFTexture->Width() ) ||
|
|
( m_pStudioRender->m_GlintHeight != pVTFTexture->Height() ) )
|
|
{
|
|
m_pStudioRender->m_GlintWidth = pVTFTexture->Width();
|
|
m_pStudioRender->m_GlintHeight = pVTFTexture->Height();
|
|
}
|
|
|
|
CStudioRender::GlintRenderData_t pRenderData[16];
|
|
int nGlintCount = m_pStudioRender->BuildGlintRenderData( pRenderData,
|
|
ARRAYSIZE(pRenderData), m_pState, *m_pVRight, *m_pVUp, *m_pROrigin );
|
|
|
|
// setup glint texture
|
|
unsigned char *pTextureData = pVTFTexture->ImageData( 0, 0, 0 );
|
|
CPixelWriter pixelWriter;
|
|
pixelWriter.SetPixelMemory( pVTFTexture->Format(), pTextureData, pVTFTexture->RowSizeInBytes( 0 ) );
|
|
int nImageSize = pVTFTexture->ComputeMipSize( 0 );
|
|
memset( pTextureData, 0, nImageSize );
|
|
|
|
// Put in glints due to the lights in the scene
|
|
for ( int i = 0; i < nGlintCount; ++i )
|
|
{
|
|
// NOTE: AddGlint is a more expensive solution but it looks better close-up
|
|
m_pStudioRender->AddGlint( pixelWriter, pRenderData[i].m_vecPosition[0],
|
|
pRenderData[i].m_vecPosition[1], pRenderData[i].m_vecIntensity );
|
|
}
|
|
}
|
|
|
|
// We've got a global instance, no need to delete it
|
|
virtual void Release() {}
|
|
|
|
const eyeballstate_t *m_pState;
|
|
const Vector *m_pVRight;
|
|
const Vector *m_pVUp;
|
|
const Vector *m_pROrigin;
|
|
CStudioRender *m_pStudioRender;
|
|
};
|
|
|
|
static CGlintTextureRegenerator s_GlintTextureRegen;
|
|
|
|
static ITexture *s_pProcGlint = NULL;
|
|
void CStudioRender::PrecacheGlint()
|
|
{
|
|
if ( !m_pGlintTexture )
|
|
{
|
|
// Begin block in which all render targets should be allocated
|
|
g_pMaterialSystem->BeginRenderTargetAllocation();
|
|
|
|
// Get the texture that we are going to be updating procedurally.
|
|
m_pGlintTexture = g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
|
|
"_rt_eyeglint", 32, 32, RT_SIZE_NO_CHANGE, IMAGE_FORMAT_BGRA8888, MATERIAL_RT_DEPTH_NONE );
|
|
m_pGlintTexture->IncrementReferenceCount();
|
|
|
|
// Begin block in which all render targets should be allocated
|
|
g_pMaterialSystem->EndRenderTargetAllocation();
|
|
|
|
if ( !IsX360() )
|
|
{
|
|
// Get the texture that we are going to be updating procedurally.
|
|
s_pProcGlint = g_pMaterialSystem->CreateProceduralTexture(
|
|
"proc_eyeglint", TEXTURE_GROUP_MODEL, 32, 32, IMAGE_FORMAT_BGRA8888, TEXTUREFLAGS_NOMIP|TEXTUREFLAGS_NOLOD );
|
|
s_pProcGlint->SetTextureRegenerator( &s_GlintTextureRegen );
|
|
}
|
|
|
|
// JAY: I don't see this pattern in the code often. It looks like the material system
|
|
// would rather than I deal exclusively with IMaterials instead.
|
|
// So maybe we should bake the LOD texture into the eyes shader.
|
|
// For now, just hardcode one
|
|
// UNDONE: Add a $lodtexture to the eyes shader. Maybe add a $lodsize too.
|
|
// UNDONE: Make eyes texture load $lodtexture and switch to that here instead of black
|
|
m_pGlintLODTexture = g_pMaterialSystem->FindTexture( IsX360() ? "black" : "vgui/black", NULL, false );
|
|
m_pGlintLODTexture->IncrementReferenceCount();
|
|
}
|
|
}
|
|
|
|
void CStudioRender::UncacheGlint()
|
|
{
|
|
if ( m_pGlintTexture )
|
|
{
|
|
if ( s_pProcGlint )
|
|
{
|
|
s_pProcGlint->SetTextureRegenerator( NULL );
|
|
s_pProcGlint->DecrementReferenceCount();
|
|
s_pProcGlint = NULL;
|
|
}
|
|
m_pGlintTexture->DecrementReferenceCount();
|
|
m_pGlintTexture = NULL;
|
|
m_pGlintLODTexture->DecrementReferenceCount();
|
|
m_pGlintLODTexture = NULL;
|
|
}
|
|
}
|
|
|
|
int CStudioRender::BuildGlintRenderData( GlintRenderData_t *pData, int nMaxGlints,
|
|
const eyeballstate_t *pState, const Vector& vright, const Vector& vup, const Vector& r_origin )
|
|
{
|
|
// NOTE: See version 25 for lots of #if 0ed out stuff I removed
|
|
Vector viewdelta;
|
|
VectorSubtract( r_origin, pState->org, viewdelta );
|
|
VectorNormalize( viewdelta );
|
|
|
|
// hack cornea position
|
|
float iris_radius = pState->peyeball->radius * (6.0 / 12.0);
|
|
float cornea_radius = pState->peyeball->radius * (8.0 / 12.0);
|
|
|
|
Vector cornea;
|
|
// position on eyeball that matches iris radius
|
|
float er = ( iris_radius / pState->peyeball->radius );
|
|
er = FastSqrt( 1 - er * er );
|
|
|
|
// position on cornea sphere that matches iris radius
|
|
float cr = ( iris_radius / cornea_radius );
|
|
cr = FastSqrt( 1 - cr * cr );
|
|
|
|
float r = ( er * pState->peyeball->radius - cr * cornea_radius );
|
|
VectorScale( pState->forward, r, cornea );
|
|
|
|
// get offset for center of cornea
|
|
float dx, dy;
|
|
dx = DotProduct( vright, cornea );
|
|
dy = DotProduct( vup, cornea );
|
|
|
|
// move cornea to world space
|
|
VectorAdd( cornea, pState->org, cornea );
|
|
|
|
Vector delta, intensity;
|
|
Vector reflection, coord;
|
|
|
|
// Put in glints due to the lights in the scene
|
|
int nGlintCount = 0;
|
|
for ( int i = 0; R_LightGlintPosition( i, cornea, delta, intensity ); ++i )
|
|
{
|
|
VectorNormalize( delta );
|
|
if ( DotProduct( delta, pState->forward ) <= 0 )
|
|
continue;
|
|
|
|
VectorAdd( delta, viewdelta, reflection );
|
|
VectorNormalize( reflection );
|
|
|
|
pData[nGlintCount].m_vecPosition[0] = dx + cornea_radius * DotProduct( vright, reflection );
|
|
pData[nGlintCount].m_vecPosition[1] = dy + cornea_radius * DotProduct( vup, reflection );
|
|
pData[nGlintCount].m_vecIntensity = intensity;
|
|
if ( ++nGlintCount >= nMaxGlints )
|
|
return nMaxGlints;
|
|
|
|
if ( !R_LightGlintPosition( i, pState->org, delta, intensity ) )
|
|
continue;
|
|
|
|
VectorNormalize( delta );
|
|
if ( DotProduct( delta, pState->forward ) >= er )
|
|
continue;
|
|
|
|
pData[nGlintCount].m_vecPosition[0] = pState->peyeball->radius * DotProduct( vright, reflection );
|
|
pData[nGlintCount].m_vecPosition[1] = pState->peyeball->radius * DotProduct( vup, reflection );
|
|
pData[nGlintCount].m_vecIntensity = intensity;
|
|
if ( ++nGlintCount >= nMaxGlints )
|
|
return nMaxGlints;
|
|
}
|
|
return nGlintCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders a glint texture procedurally
|
|
//-----------------------------------------------------------------------------
|
|
ITexture* CStudioRender::RenderGlintTexture( const eyeballstate_t *pState,
|
|
const Vector& vright, const Vector& vup, const Vector& r_origin )
|
|
{
|
|
GlintRenderData_t pRenderData[16];
|
|
int nGlintCount = BuildGlintRenderData( pRenderData, ARRAYSIZE(pRenderData),
|
|
pState, vright, vup, r_origin );
|
|
|
|
if ( nGlintCount == 0 )
|
|
return m_pGlintLODTexture;
|
|
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
pRenderContext->PushRenderTargetAndViewport( m_pGlintTexture );
|
|
|
|
IMaterial *pPrevMaterial = pRenderContext->GetCurrentMaterial();
|
|
void *pPrevProxy = pRenderContext->GetCurrentProxy();
|
|
int nPrevBoneCount = pRenderContext->GetCurrentNumBones();
|
|
MaterialHeightClipMode_t nPrevClipMode = pRenderContext->GetHeightClipMode( );
|
|
bool bPrevClippingEnabled = pRenderContext->EnableClipping( false );
|
|
bool bInFlashlightMode = pRenderContext->GetFlashlightMode();
|
|
|
|
if ( bInFlashlightMode )
|
|
{
|
|
DisableScissor();
|
|
}
|
|
pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
|
|
pRenderContext->ClearBuffers( true, false, false );
|
|
|
|
pRenderContext->SetFlashlightMode( false );
|
|
pRenderContext->SetHeightClipMode( MATERIAL_HEIGHTCLIPMODE_DISABLE );
|
|
pRenderContext->SetNumBoneWeights( 0 );
|
|
pRenderContext->Bind( m_pGlintBuildMaterial );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
CMeshBuilder meshBuilder;
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nGlintCount * 4, nGlintCount * 6 );
|
|
|
|
const float epsilon = 0.5f / 32.0f;
|
|
int nIndex = 0;
|
|
for ( int i = 0; i < nGlintCount; ++i )
|
|
{
|
|
const GlintRenderData_t &glint = pRenderData[i];
|
|
|
|
// Position of glint 0..31 range
|
|
float x = (glint.m_vecPosition.x + 0.5f) * m_GlintWidth;
|
|
float y = (glint.m_vecPosition.y + 0.5f) * m_GlintHeight;
|
|
Vector vGlintCenter = Vector( x, y, 0.0f );
|
|
float ooWidth = 1.0f / (float)m_GlintWidth;
|
|
float ooHeight = 1.0f / (float)m_GlintHeight;
|
|
|
|
int x0 = floor(x);
|
|
int y0 = floor(y);
|
|
int x1 = x0 + 1.0f;
|
|
int y1 = y0 + 1.0f;
|
|
x0 -= 2.0f; // Fill rules make us pad this out more than the procedural version
|
|
y0 -= 2.0f;
|
|
|
|
float screenX0 = x0 * 2 * ooWidth + epsilon - 1;
|
|
float screenX1 = x1 * 2 * ooWidth + epsilon - 1;
|
|
float screenY0 = -(y0 * 2 * ooHeight + epsilon - 1);
|
|
float screenY1 = -(y1 * 2 * ooHeight + epsilon - 1);
|
|
|
|
meshBuilder.Position3f( screenX0, screenY0, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, x0, y0 );
|
|
meshBuilder.TexCoord2fv( 1, vGlintCenter.Base() );
|
|
meshBuilder.TexCoord3fv( 2, glint.m_vecIntensity.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( screenX1, screenY0, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, x1, y0 );
|
|
meshBuilder.TexCoord2fv( 1, vGlintCenter.Base() );
|
|
meshBuilder.TexCoord3fv( 2, glint.m_vecIntensity.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( screenX1, screenY1, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, x1, y1 );
|
|
meshBuilder.TexCoord2fv( 1, vGlintCenter.Base() );
|
|
meshBuilder.TexCoord3fv( 2, glint.m_vecIntensity.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( screenX0, screenY1, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, x0, y1 );
|
|
meshBuilder.TexCoord2fv( 1, vGlintCenter.Base() );
|
|
meshBuilder.TexCoord3fv( 2, glint.m_vecIntensity.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.FastIndex( nIndex );
|
|
meshBuilder.FastIndex( nIndex+1 );
|
|
meshBuilder.FastIndex( nIndex+2 );
|
|
meshBuilder.FastIndex( nIndex );
|
|
meshBuilder.FastIndex( nIndex+2 );
|
|
meshBuilder.FastIndex( nIndex+3 );
|
|
nIndex += 4;
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PopMatrix();
|
|
|
|
if ( IsX360() )
|
|
{
|
|
pRenderContext->CopyRenderTargetToTextureEx( m_pGlintTexture, 0, NULL, NULL );
|
|
}
|
|
|
|
pRenderContext->PopRenderTargetAndViewport( );
|
|
|
|
pRenderContext->Bind( pPrevMaterial, pPrevProxy );
|
|
pRenderContext->SetNumBoneWeights( nPrevBoneCount );
|
|
pRenderContext->SetHeightClipMode( nPrevClipMode );
|
|
pRenderContext->EnableClipping( bPrevClippingEnabled );
|
|
pRenderContext->SetFlashlightMode( bInFlashlightMode );
|
|
|
|
return m_pGlintTexture;
|
|
}
|
|
|
|
static ConVar r_glint_procedural( "r_glint_procedural", "0" );
|
|
static ConVar r_glint_alwaysdraw( "r_glint_alwaysdraw", "0" );
|
|
|
|
void CStudioRender::R_StudioEyeballGlint( const eyeballstate_t *pstate, IMaterialVar *pGlintVar,
|
|
const Vector& vright, const Vector& vup, const Vector& r_origin )
|
|
{
|
|
// Kick off a PIX event, since this process encompasses a bunch of locks etc...
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
PIXEVENT( pRenderContext, "GenerateEyeballGlint" );
|
|
|
|
// Don't do a procedural glint texture if there are enough pixels covered by the eyeball onscreen,
|
|
// and the eye isn't backfaced.
|
|
if ( m_pGlintLODTexture && r_glint_alwaysdraw.GetInt() == 0 )
|
|
{
|
|
// backfaced or too small to bother?
|
|
float pixelArea = pRenderContext->ComputePixelWidthOfSphere( pstate->org, pstate->peyeball->radius );
|
|
if(
|
|
// FIXME: this backface doesn't work for something that isn't a plane.
|
|
// DotProduct( pstate->forward, m_ViewPlaneNormal ) > 0.0f ||
|
|
pixelArea < m_pRC->m_Config.fEyeGlintPixelWidthLODThreshold )
|
|
{
|
|
// use black glint texture
|
|
pGlintVar->SetTextureValue( m_pGlintLODTexture );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Legacy method for DX8
|
|
if ( !IsX360() && ( r_glint_procedural.GetInt() || g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 ) )
|
|
{
|
|
// Set up the texture regenerator
|
|
s_GlintTextureRegen.m_pVRight = &vright;
|
|
s_GlintTextureRegen.m_pVUp = &vup;
|
|
s_GlintTextureRegen.m_pROrigin = &r_origin;
|
|
s_GlintTextureRegen.m_pState = pstate;
|
|
s_GlintTextureRegen.m_pStudioRender = this;
|
|
|
|
// This will cause the glint texture to be re-generated and then downloaded
|
|
s_pProcGlint->Download( );
|
|
|
|
// This is necessary to make sure we don't reconstitute the bits
|
|
// after coming back from a task switch
|
|
s_GlintTextureRegen.m_pStudioRender = NULL;
|
|
|
|
// Use the normal glint instead of the black glint
|
|
pGlintVar->SetTextureValue( s_pProcGlint );
|
|
}
|
|
else // Queued hardware version
|
|
{
|
|
// Make sure we know the correct size of the glint texture
|
|
m_GlintWidth = m_pGlintTexture->GetActualWidth();
|
|
m_GlintHeight = m_pGlintTexture->GetActualHeight();
|
|
|
|
// Render glint render target
|
|
ITexture *pUseGlintTexture = RenderGlintTexture( pstate, vright, vup, r_origin );
|
|
|
|
// Use the normal glint instead of the black glint
|
|
pGlintVar->SetTextureValue( pUseGlintTexture );
|
|
}
|
|
}
|
|
|
|
void CStudioRender::ComputeGlintTextureProjection( eyeballstate_t const* pState,
|
|
const Vector& vright, const Vector& vup, matrix3x4_t& mat )
|
|
{
|
|
// project eyeball into screenspace texture
|
|
float scale = 1.0 / (pState->peyeball->radius * 2);
|
|
VectorScale( &vright.x, scale, mat[0] );
|
|
VectorScale( &vup.x, scale, mat[1] );
|
|
|
|
mat[0][3] = -DotProduct( pState->org.Base(), mat[0] ) + 0.5;
|
|
mat[1][3] = -DotProduct( pState->org.Base(), mat[1] ) + 0.5;
|
|
}
|
|
|
|
|
|
/*
|
|
void R_MouthLighting( int count, const Vector *psrcverts, const Vector *psrcnorms, Vector4D *pdestlightvalues )
|
|
{
|
|
Vector forward;
|
|
|
|
if (m_pStudioHdr->nummouths < 1) return;
|
|
|
|
mstudiomouth_t *pMouth = r_pstudiohdr->pMouth( 0 ); // FIXME: this needs to get the mouth index from the shader
|
|
|
|
float fIllum = m_FlexWeights[pMouth->flexdesc];
|
|
if (fIllum < 0) fIllum = 0;
|
|
if (fIllum > 1) fIllum = 1;
|
|
fIllum = LinearToTexture( fIllum ) / 255.0;
|
|
|
|
|
|
VectorRotate( pMouth->forward, g_StudioInternalState.boneToWorld[ pMouth->bone ], forward );
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
float dot = -DotProduct( psrcnorms[i], forward );
|
|
if (dot > 0)
|
|
{
|
|
dot = LinearToTexture( dot ) / 255.0; // FIXME: this isn't robust
|
|
VectorScale( pdestlightvalues[i], dot, pdestlightvalues[i] );
|
|
}
|
|
else
|
|
VectorFill( pdestlightvalues[i], 0 );
|
|
|
|
VectorScale( pdestlightvalues[i], fIllum, pdestlightvalues[i] );
|
|
}
|
|
}
|
|
*/
|
|
|
|
void CStudioRender::R_MouthComputeLightingValues( float& fIllum, Vector& forward )
|
|
{
|
|
// FIXME: this needs to get the mouth index from the shader
|
|
mstudiomouth_t *pMouth = m_pStudioHdr->pMouth( 0 );
|
|
|
|
fIllum = m_pFlexWeights[pMouth->flexdesc];
|
|
if (fIllum < 0) fIllum = 0;
|
|
if (fIllum > 1) fIllum = 1;
|
|
fIllum = LinearToTexture( fIllum ) / 255.0;
|
|
|
|
VectorRotate( pMouth->forward, m_pBoneToWorld[ pMouth->bone ], forward );
|
|
}
|
|
|
|
void CStudioRender::R_MouthLighting( float fIllum, const Vector& normal, const Vector& forward, Vector &light )
|
|
{
|
|
float dot = -DotProduct( normal, forward );
|
|
if (dot > 0)
|
|
{
|
|
VectorScale( light, dot * fIllum, light );
|
|
}
|
|
else
|
|
{
|
|
VectorFill( light, 0 );
|
|
}
|
|
}
|
|
|
|
static unsigned int illumVarCache = 0;
|
|
static unsigned int forwardVarCache = 0;
|
|
void CStudioRender::R_MouthSetupVertexShader( IMaterial* pMaterial )
|
|
{
|
|
if (!pMaterial)
|
|
return;
|
|
|
|
// FIXME: this needs to get the mouth index from the shader
|
|
mstudiomouth_t *pMouth = m_pStudioHdr->pMouth( 0 );
|
|
|
|
// Don't deal with illum gamma, we apply it at a different point
|
|
// for vertex shaders
|
|
float fIllum = m_pFlexWeights[pMouth->flexdesc];
|
|
if (fIllum < 0) fIllum = 0;
|
|
if (fIllum > 1) fIllum = 1;
|
|
|
|
Vector forward;
|
|
VectorRotate( pMouth->forward, m_pBoneToWorld[ pMouth->bone ], forward );
|
|
forward *= -1;
|
|
|
|
IMaterialVar* pIllumVar = pMaterial->FindVarFast( "$illumfactor", &illumVarCache );
|
|
if (pIllumVar)
|
|
{
|
|
pIllumVar->SetFloatValue( fIllum );
|
|
}
|
|
|
|
IMaterialVar* pFowardVar = pMaterial->FindVarFast( "$forward", &forwardVarCache );
|
|
if (pFowardVar)
|
|
{
|
|
pFowardVar->SetVecValue( forward.Base(), 3 );
|
|
}
|
|
}
|