mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2024-12-23 01:59:43 +08:00
1734 lines
50 KiB
C++
1734 lines
50 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
|
|
#include "cbase.h"
|
|
#include "beamdraw.h"
|
|
#include "enginesprite.h"
|
|
#include "IViewRender_Beams.h"
|
|
#include "view.h"
|
|
#include "iviewrender.h"
|
|
#include "engine/ivmodelinfo.h"
|
|
#include "fx_line.h"
|
|
#include "materialsystem/imaterialvar.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
extern ConVar r_drawsprites;
|
|
extern ConVar r_DrawBeams;
|
|
|
|
static IMaterial *g_pBeamWireframeMaterial;
|
|
|
|
// ------------------------------------------------------------------------------------------ //
|
|
// CBeamSegDraw implementation.
|
|
// ------------------------------------------------------------------------------------------ //
|
|
void CBeamSegDraw::Start( int nSegs, IMaterial *pMaterial, CMeshBuilder *pMeshBuilder, int nMeshVertCount )
|
|
{
|
|
Assert( nSegs >= 2 );
|
|
|
|
m_nSegsDrawn = 0;
|
|
m_nTotalSegs = nSegs;
|
|
|
|
if ( pMeshBuilder )
|
|
{
|
|
m_pMeshBuilder = pMeshBuilder;
|
|
m_nMeshVertCount = nMeshVertCount;
|
|
}
|
|
else
|
|
{
|
|
m_pMeshBuilder = NULL;
|
|
m_nMeshVertCount = 0;
|
|
|
|
if ( ShouldDrawInWireFrameMode() || r_DrawBeams.GetInt() == 2 )
|
|
{
|
|
if ( !g_pBeamWireframeMaterial )
|
|
g_pBeamWireframeMaterial = materials->FindMaterial("shadertest/wireframevertexcolor", TEXTURE_GROUP_OTHER);
|
|
pMaterial = g_pBeamWireframeMaterial;
|
|
}
|
|
|
|
IMesh *pMesh = materials->GetDynamicMesh( true, NULL, NULL, pMaterial );
|
|
m_Mesh.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, (nSegs-1) * 2 );
|
|
}
|
|
}
|
|
|
|
inline void CBeamSegDraw::ComputeNormal( const Vector &vStartPos, const Vector &vNextPos, Vector *pNormal )
|
|
{
|
|
// vTangentY = line vector for beam
|
|
Vector vTangentY;
|
|
VectorSubtract( vStartPos, vNextPos, vTangentY );
|
|
|
|
// vDirToBeam = vector from viewer origin to beam
|
|
Vector vDirToBeam;
|
|
VectorSubtract( vStartPos, CurrentViewOrigin(), vDirToBeam );
|
|
|
|
// Get a vector that is perpendicular to us and perpendicular to the beam.
|
|
// This is used to fatten the beam.
|
|
CrossProduct( vTangentY, vDirToBeam, *pNormal );
|
|
VectorNormalizeFast( *pNormal );
|
|
}
|
|
|
|
inline void CBeamSegDraw::SpecifySeg( const Vector &vNormal )
|
|
{
|
|
// SUCKY: Need to do a fair amount more work to get the tangent owing to the averaged normal
|
|
Vector vDirToBeam, vTangentY;
|
|
VectorSubtract( m_Seg.m_vPos, CurrentViewOrigin(), vDirToBeam );
|
|
CrossProduct( vDirToBeam, vNormal, vTangentY );
|
|
VectorNormalizeFast( vTangentY );
|
|
|
|
// Build the endpoints.
|
|
Vector vPoint1, vPoint2;
|
|
VectorMA( m_Seg.m_vPos, m_Seg.m_flWidth*0.5f, vNormal, vPoint1 );
|
|
VectorMA( m_Seg.m_vPos, -m_Seg.m_flWidth*0.5f, vNormal, vPoint2 );
|
|
|
|
if ( m_pMeshBuilder )
|
|
{
|
|
// Specify the points.
|
|
m_pMeshBuilder->Position3fv( vPoint1.Base() );
|
|
m_pMeshBuilder->Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_pMeshBuilder->TexCoord2f( 0, 0, m_Seg.m_flTexCoord );
|
|
m_pMeshBuilder->TexCoord2f( 1, 0, m_Seg.m_flTexCoord );
|
|
m_pMeshBuilder->TangentS3fv( vNormal.Base() );
|
|
m_pMeshBuilder->TangentT3fv( vTangentY.Base() );
|
|
m_pMeshBuilder->AdvanceVertex();
|
|
|
|
m_pMeshBuilder->Position3fv( vPoint2.Base() );
|
|
m_pMeshBuilder->Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_pMeshBuilder->TexCoord2f( 0, 1, m_Seg.m_flTexCoord );
|
|
m_pMeshBuilder->TexCoord2f( 1, 1, m_Seg.m_flTexCoord );
|
|
m_pMeshBuilder->TangentS3fv( vNormal.Base() );
|
|
m_pMeshBuilder->TangentT3fv( vTangentY.Base() );
|
|
m_pMeshBuilder->AdvanceVertex();
|
|
|
|
if ( m_nSegsDrawn > 1 )
|
|
{
|
|
int nBase = ( ( m_nSegsDrawn - 2 ) * 2 ) + m_nMeshVertCount;
|
|
|
|
m_pMeshBuilder->FastIndex( nBase );
|
|
m_pMeshBuilder->FastIndex( nBase + 1 );
|
|
m_pMeshBuilder->FastIndex( nBase + 2 );
|
|
m_pMeshBuilder->FastIndex( nBase + 1 );
|
|
m_pMeshBuilder->FastIndex( nBase + 3 );
|
|
m_pMeshBuilder->FastIndex( nBase + 2 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Specify the points.
|
|
m_Mesh.Position3fv( vPoint1.Base() );
|
|
m_Mesh.Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_Mesh.TexCoord2f( 0, 0, m_Seg.m_flTexCoord );
|
|
m_Mesh.TexCoord2f( 1, 0, m_Seg.m_flTexCoord );
|
|
m_Mesh.TangentS3fv( vNormal.Base() );
|
|
m_Mesh.TangentT3fv( vTangentY.Base() );
|
|
m_Mesh.AdvanceVertex();
|
|
|
|
m_Mesh.Position3fv( vPoint2.Base() );
|
|
m_Mesh.Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_Mesh.TexCoord2f( 0, 1, m_Seg.m_flTexCoord );
|
|
m_Mesh.TexCoord2f( 1, 1, m_Seg.m_flTexCoord );
|
|
m_Mesh.TangentS3fv( vNormal.Base() );
|
|
m_Mesh.TangentT3fv( vTangentY.Base() );
|
|
m_Mesh.AdvanceVertex();
|
|
}
|
|
}
|
|
|
|
void CBeamSegDraw::NextSeg( CBeamSeg *pSeg )
|
|
{
|
|
if ( m_nSegsDrawn > 0 )
|
|
{
|
|
// Get a vector that is perpendicular to us and perpendicular to the beam.
|
|
// This is used to fatten the beam.
|
|
Vector vNormal, vAveNormal;
|
|
ComputeNormal( m_Seg.m_vPos, pSeg->m_vPos, &vNormal );
|
|
|
|
if ( m_nSegsDrawn > 1 )
|
|
{
|
|
// Average this with the previous normal
|
|
VectorAdd( vNormal, m_vNormalLast, vAveNormal );
|
|
vAveNormal *= 0.5f;
|
|
VectorNormalizeFast( vAveNormal );
|
|
}
|
|
else
|
|
{
|
|
vAveNormal = vNormal;
|
|
}
|
|
|
|
m_vNormalLast = vNormal;
|
|
SpecifySeg( vAveNormal );
|
|
}
|
|
|
|
m_Seg = *pSeg;
|
|
++m_nSegsDrawn;
|
|
|
|
if( m_nSegsDrawn == m_nTotalSegs )
|
|
{
|
|
SpecifySeg( m_vNormalLast );
|
|
}
|
|
}
|
|
|
|
void CBeamSegDraw::End()
|
|
{
|
|
if ( m_pMeshBuilder )
|
|
{
|
|
m_pMeshBuilder = NULL;
|
|
return;
|
|
}
|
|
|
|
m_Mesh.End( false, true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &normal -
|
|
//-----------------------------------------------------------------------------
|
|
void CBeamSegDrawArbitrary::SetNormal( const Vector &normal )
|
|
{
|
|
m_vNormalLast = normal;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pSeg -
|
|
//-----------------------------------------------------------------------------
|
|
void CBeamSegDrawArbitrary::NextSeg( CBeamSeg *pSeg )
|
|
{
|
|
if ( m_nSegsDrawn > 0 )
|
|
{
|
|
Vector segDir = ( m_PrevSeg.m_vPos - pSeg->m_vPos );
|
|
VectorNormalize( segDir );
|
|
|
|
Vector normal = CrossProduct( segDir, m_vNormalLast );
|
|
SpecifySeg( normal );
|
|
}
|
|
|
|
m_PrevSeg = m_Seg;
|
|
m_Seg = *pSeg;
|
|
++m_nSegsDrawn;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &vNextPos -
|
|
//-----------------------------------------------------------------------------
|
|
void CBeamSegDrawArbitrary::SpecifySeg( const Vector &vNormal )
|
|
{
|
|
// Build the endpoints.
|
|
Vector vPoint1, vPoint2;
|
|
VectorMA( m_Seg.m_vPos, m_Seg.m_flWidth*0.5f, vNormal, vPoint1 );
|
|
VectorMA( m_Seg.m_vPos, -m_Seg.m_flWidth*0.5f, vNormal, vPoint2 );
|
|
|
|
// Specify the points.
|
|
m_Mesh.Position3fv( vPoint1.Base() );
|
|
m_Mesh.Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_Mesh.TexCoord2f( 0, 0, m_Seg.m_flTexCoord );
|
|
m_Mesh.TexCoord2f( 1, 0, m_Seg.m_flTexCoord );
|
|
m_Mesh.AdvanceVertex();
|
|
|
|
m_Mesh.Position3fv( vPoint2.Base() );
|
|
m_Mesh.Color4f( VectorExpand( m_Seg.m_vColor ), m_Seg.m_flAlpha );
|
|
m_Mesh.TexCoord2f( 0, 1, m_Seg.m_flTexCoord );
|
|
m_Mesh.TexCoord2f( 1, 1, m_Seg.m_flTexCoord );
|
|
m_Mesh.AdvanceVertex();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieve sprite object and set it up for rendering
|
|
// Input : *pSpriteModel -
|
|
// frame -
|
|
// rendermode -
|
|
// Output : CEngineSprite
|
|
//-----------------------------------------------------------------------------
|
|
CEngineSprite *Draw_SetSpriteTexture( const model_t *pSpriteModel, int frame, int rendermode )
|
|
{
|
|
CEngineSprite *psprite;
|
|
IMaterial *material;
|
|
|
|
psprite = ( CEngineSprite * )modelinfo->GetModelExtraData( pSpriteModel );
|
|
Assert( psprite );
|
|
|
|
material = psprite->GetMaterial();
|
|
if( !material )
|
|
return NULL;
|
|
|
|
if ( ShouldDrawInWireFrameMode() || r_DrawBeams.GetInt() == 2 )
|
|
{
|
|
if ( !g_pBeamWireframeMaterial )
|
|
g_pBeamWireframeMaterial = materials->FindMaterial( "shadertest/wireframevertexcolor", TEXTURE_GROUP_OTHER );
|
|
materials->Bind( g_pBeamWireframeMaterial, NULL );
|
|
return psprite;
|
|
}
|
|
|
|
psprite->SetFrame( frame );
|
|
psprite->SetRenderMode( rendermode );
|
|
|
|
materials->Bind( material );
|
|
return psprite;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pMaterial -
|
|
// source -
|
|
// color -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawHalo(IMaterial* pMaterial, const Vector& source, float scale, float const* color, float flHDRColorScale )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
Vector point, screen;
|
|
|
|
if( pMaterial )
|
|
{
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
|
|
|
|
// Transform source into screen space
|
|
ScreenTransform( source, screen );
|
|
|
|
meshBuilder.Color3fv (color);
|
|
meshBuilder.TexCoord2f (0, 0, 1);
|
|
VectorMA (source, -scale, CurrentViewUp(), point);
|
|
VectorMA (point, -scale, CurrentViewRight(), point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3fv (color);
|
|
meshBuilder.TexCoord2f (0, 0, 0);
|
|
VectorMA (source, scale, CurrentViewUp(), point);
|
|
VectorMA (point, -scale, CurrentViewRight(), point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3fv (color);
|
|
meshBuilder.TexCoord2f (0, 1, 0);
|
|
VectorMA (source, scale, CurrentViewUp(), point);
|
|
VectorMA (point, scale, CurrentViewRight(), point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3fv (color);
|
|
meshBuilder.TexCoord2f (0, 1, 1);
|
|
VectorMA (source, -scale, CurrentViewUp(), point);
|
|
VectorMA (point, scale, CurrentViewRight(), point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Assumes the material has already been bound
|
|
//-----------------------------------------------------------------------------
|
|
void DrawSprite( const Vector &vecOrigin, float flWidth, float flHeight, color32 color )
|
|
{
|
|
unsigned char pColor[4] = { color.r, color.g, color.b, color.a };
|
|
|
|
// Generate half-widths
|
|
flWidth *= 0.5f;
|
|
flHeight *= 0.5f;
|
|
|
|
// Compute direction vectors for the sprite
|
|
Vector fwd, right( 1, 0, 0 ), up( 0, 1, 0 );
|
|
VectorSubtract( CurrentViewOrigin(), vecOrigin, fwd );
|
|
float flDist = VectorNormalize( fwd );
|
|
if (flDist >= 1e-3)
|
|
{
|
|
CrossProduct( CurrentViewUp(), fwd, right );
|
|
flDist = VectorNormalize( right );
|
|
if (flDist >= 1e-3)
|
|
{
|
|
CrossProduct( fwd, right, up );
|
|
}
|
|
else
|
|
{
|
|
// In this case, fwd == g_vecVUp, it's right above or
|
|
// below us in screen space
|
|
CrossProduct( fwd, CurrentViewRight(), up );
|
|
VectorNormalize( up );
|
|
CrossProduct( up, fwd, right );
|
|
}
|
|
}
|
|
|
|
CMeshBuilder meshBuilder;
|
|
Vector point;
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
|
|
|
|
meshBuilder.Color4ubv (pColor);
|
|
meshBuilder.TexCoord2f (0, 0, 1);
|
|
VectorMA (vecOrigin, -flHeight, up, point);
|
|
VectorMA (point, -flWidth, right, point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color4ubv (pColor);
|
|
meshBuilder.TexCoord2f (0, 0, 0);
|
|
VectorMA (vecOrigin, flHeight, up, point);
|
|
VectorMA (point, -flWidth, right, point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color4ubv (pColor);
|
|
meshBuilder.TexCoord2f (0, 1, 0);
|
|
VectorMA (vecOrigin, flHeight, up, point);
|
|
VectorMA (point, flWidth, right, point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color4ubv (pColor);
|
|
meshBuilder.TexCoord2f (0, 1, 1);
|
|
VectorMA (vecOrigin, -flHeight, up, point);
|
|
VectorMA (point, flWidth, right, point);
|
|
meshBuilder.Position3fv (point.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute vectors perpendicular to the beam
|
|
//-----------------------------------------------------------------------------
|
|
static void ComputeBeamPerpendicular( const Vector &vecBeamDelta, Vector *pPerp )
|
|
{
|
|
// Direction in worldspace of the center of the beam
|
|
Vector vecBeamCenter = vecBeamDelta;
|
|
VectorNormalize( vecBeamCenter );
|
|
|
|
CrossProduct( CurrentViewForward(), vecBeamCenter, *pPerp );
|
|
VectorNormalize( *pPerp );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// *spritemodel -
|
|
// frame -
|
|
// rendermode -
|
|
// source -
|
|
// delta -
|
|
// flags -
|
|
// *color -
|
|
// fadescale -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawSegs( int noise_divisions, float *prgNoise, const model_t* spritemodel,
|
|
float frame, int rendermode, const Vector& source, const Vector& delta,
|
|
float startWidth, float endWidth, float scale, float freq, float speed, int segments,
|
|
int flags, float* color, float fadeLength, float flHDRColorScale )
|
|
{
|
|
int i, noiseIndex, noiseStep;
|
|
float div, length, fraction, factor, vLast, vStep, brightness;
|
|
|
|
Assert( fadeLength >= 0.0f );
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
length = VectorLength( delta );
|
|
float flMaxWidth = MAX(startWidth, endWidth) * 0.5f;
|
|
div = 1.0 / (segments-1);
|
|
|
|
if ( length*div < flMaxWidth * 1.414 )
|
|
{
|
|
// Here, we have too many segments; we could get overlap... so lets have less segments
|
|
segments = (int)(length / (flMaxWidth * 1.414)) + 1;
|
|
if ( segments < 2 )
|
|
{
|
|
segments = 2;
|
|
}
|
|
}
|
|
|
|
if ( segments > noise_divisions ) // UNDONE: Allow more segments?
|
|
{
|
|
segments = noise_divisions;
|
|
}
|
|
|
|
div = 1.0 / (segments-1);
|
|
length *= 0.01;
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
|
|
if ( flags & FBEAM_NOTILE )
|
|
{
|
|
// Don't tile
|
|
vStep = div;
|
|
}
|
|
else
|
|
{
|
|
// Texture length texels per space pixel
|
|
vStep = length*div;
|
|
}
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
if ( segments < 16 )
|
|
{
|
|
segments = 16;
|
|
div = 1.0 / (segments-1);
|
|
}
|
|
scale *= 100;
|
|
length = segments * (1.0/10);
|
|
}
|
|
else
|
|
{
|
|
scale *= length;
|
|
}
|
|
|
|
// Iterator to resample noise waveform (it needs to be generated in powers of 2)
|
|
noiseStep = (int)((float)(noise_divisions-1) * div * 65536.0f);
|
|
noiseIndex = 0;
|
|
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
noiseIndex = 0;
|
|
}
|
|
|
|
brightness = 1.0;
|
|
if ( flags & FBEAM_SHADEIN )
|
|
{
|
|
brightness = 0;
|
|
}
|
|
|
|
// What fraction of beam should be faded
|
|
Assert( fadeLength >= 0.0f );
|
|
float fadeFraction = fadeLength/ delta.Length();
|
|
|
|
// BUGBUG: This code generates NANs when fadeFraction is zero! REVIST!
|
|
fadeFraction = clamp(fadeFraction,1e-6,1);
|
|
|
|
// Choose two vectors that are perpendicular to the beam
|
|
Vector perp1;
|
|
ComputeBeamPerpendicular( delta, &perp1 );
|
|
|
|
// Specify all the segments.
|
|
CBeamSegDraw segDraw;
|
|
segDraw.Start( segments, NULL );
|
|
|
|
for ( i = 0; i < segments; i++ )
|
|
{
|
|
Assert( noiseIndex < (noise_divisions<<16) );
|
|
CBeamSeg curSeg;
|
|
curSeg.m_flAlpha = 1;
|
|
|
|
fraction = i * div;
|
|
|
|
// Fade in our out beam to fadeLength
|
|
|
|
if ( (flags & FBEAM_SHADEIN) && (flags & FBEAM_SHADEOUT) )
|
|
{
|
|
if (fraction < 0.5)
|
|
{
|
|
brightness = 2*(fraction/fadeFraction);
|
|
}
|
|
else
|
|
{
|
|
brightness = 2*(1.0 - (fraction/fadeFraction));
|
|
}
|
|
}
|
|
else if ( flags & FBEAM_SHADEIN )
|
|
{
|
|
brightness = fraction/fadeFraction;
|
|
}
|
|
else if ( flags & FBEAM_SHADEOUT )
|
|
{
|
|
brightness = 1.0 - (fraction/fadeFraction);
|
|
}
|
|
|
|
// clamps
|
|
if (brightness < 0 )
|
|
{
|
|
brightness = 0;
|
|
}
|
|
else if (brightness > 1)
|
|
{
|
|
brightness = 1;
|
|
}
|
|
|
|
VectorScale( *((Vector*)color), brightness, curSeg.m_vColor );
|
|
|
|
// UNDONE: Make this a spline instead of just a line?
|
|
VectorMA( source, fraction, delta, curSeg.m_vPos );
|
|
|
|
// Distort using noise
|
|
if ( scale != 0 )
|
|
{
|
|
factor = prgNoise[noiseIndex>>16] * scale;
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
float s, c;
|
|
SinCos( fraction*M_PI*length + freq, &s, &c );
|
|
VectorMA( curSeg.m_vPos, factor * s, CurrentViewUp(), curSeg.m_vPos );
|
|
// Rotate the noise along the perpendicluar axis a bit to keep the bolt from looking diagonal
|
|
VectorMA( curSeg.m_vPos, factor * c, CurrentViewRight(), curSeg.m_vPos );
|
|
}
|
|
else
|
|
{
|
|
VectorMA( curSeg.m_vPos, factor, perp1, curSeg.m_vPos );
|
|
}
|
|
}
|
|
|
|
// Specify the next segment.
|
|
if( endWidth == startWidth )
|
|
{
|
|
curSeg.m_flWidth = startWidth * 2;
|
|
}
|
|
else
|
|
{
|
|
curSeg.m_flWidth = ((fraction*(endWidth-startWidth))+startWidth) * 2;
|
|
}
|
|
|
|
curSeg.m_flTexCoord = vLast;
|
|
segDraw.NextSeg( &curSeg );
|
|
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
noiseIndex += noiseStep;
|
|
}
|
|
|
|
segDraw.End();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CalcSegOrigin( Vector *vecOut, int iPoint, int noise_divisions, float *prgNoise,
|
|
const Vector &source, const Vector& delta, const Vector &perp, int segments,
|
|
float freq, float scale, float fraction, int flags )
|
|
{
|
|
Assert( segments > 1 );
|
|
|
|
float factor;
|
|
float length = VectorLength( delta ) * 0.01;
|
|
float div = 1.0 / (segments-1);
|
|
|
|
// Iterator to resample noise waveform (it needs to be generated in powers of 2)
|
|
int noiseStep = (int)((float)(noise_divisions-1) * div * 65536.0f);
|
|
int noiseIndex = (iPoint) * noiseStep;
|
|
|
|
// Sine noise beams have different length calculations
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
length = segments * (1.0/10);
|
|
noiseIndex = 0;
|
|
}
|
|
|
|
// UNDONE: Make this a spline instead of just a line?
|
|
VectorMA( source, fraction, delta, *vecOut );
|
|
|
|
// Distort using noise
|
|
if ( scale != 0 )
|
|
{
|
|
factor = prgNoise[noiseIndex>>16] * scale;
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
float s, c;
|
|
SinCos( fraction*M_PI*length + freq, &s, &c );
|
|
VectorMA( *vecOut, factor * s, MainViewUp(), *vecOut );
|
|
// Rotate the noise along the perpendicular axis a bit to keep the bolt from looking diagonal
|
|
VectorMA( *vecOut, factor * c, MainViewRight(), *vecOut );
|
|
}
|
|
else
|
|
{
|
|
VectorMA( *vecOut, factor, perp, *vecOut );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// *spritemodel -
|
|
// frame -
|
|
// rendermode -
|
|
// source -
|
|
// delta -
|
|
// flags -
|
|
// *color -
|
|
// fadescale -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawTeslaSegs( int noise_divisions, float *prgNoise, const model_t* spritemodel,
|
|
float frame, int rendermode, const Vector& source, const Vector& delta,
|
|
float startWidth, float endWidth, float scale, float freq, float speed, int segments,
|
|
int flags, float* color, float fadeLength, float flHDRColorScale )
|
|
{
|
|
int i;
|
|
float div, length, fraction, vLast, vStep, brightness;
|
|
|
|
Assert( fadeLength >= 0.0f );
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
if ( segments > noise_divisions ) // UNDONE: Allow more segments?
|
|
segments = noise_divisions;
|
|
|
|
length = VectorLength( delta ) * 0.01;
|
|
div = 1.0 / (segments-1);
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
vStep = length*div; // Texture length texels per space pixel
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
|
|
brightness = 1.0;
|
|
if ( flags & FBEAM_SHADEIN )
|
|
brightness = 0;
|
|
|
|
// What fraction of beam should be faded
|
|
Assert( fadeLength >= 0.0f );
|
|
float fadeFraction = fadeLength/ delta.Length();
|
|
|
|
// BUGBUG: This code generates NANs when fadeFraction is zero! REVIST!
|
|
fadeFraction = clamp(fadeFraction,1e-6,1);
|
|
|
|
Vector perp;
|
|
ComputeBeamPerpendicular( delta, &perp );
|
|
|
|
// Specify all the segments.
|
|
CBeamSegDraw segDraw;
|
|
segDraw.Start( segments, NULL );
|
|
|
|
// Keep track of how many times we've branched
|
|
int iBranches = 0;
|
|
|
|
Vector vecStart, vecEnd;
|
|
float flWidth = 0;
|
|
float flEndWidth = 0;
|
|
|
|
for ( i = 0; i < segments; i++ )
|
|
{
|
|
CBeamSeg curSeg;
|
|
curSeg.m_flAlpha = 1;
|
|
|
|
fraction = i * div;
|
|
|
|
// Fade in our out beam to fadeLength
|
|
|
|
if ( (flags & FBEAM_SHADEIN) && (flags & FBEAM_SHADEOUT) )
|
|
{
|
|
if (fraction < 0.5)
|
|
{
|
|
brightness = 2*(fraction/fadeFraction);
|
|
}
|
|
else
|
|
{
|
|
brightness = 2*(1.0 - (fraction/fadeFraction));
|
|
}
|
|
}
|
|
else if ( flags & FBEAM_SHADEIN )
|
|
{
|
|
brightness = fraction/fadeFraction;
|
|
}
|
|
else if ( flags & FBEAM_SHADEOUT )
|
|
{
|
|
brightness = 1.0 - (fraction/fadeFraction);
|
|
}
|
|
|
|
// clamps
|
|
if (brightness < 0 )
|
|
{
|
|
brightness = 0;
|
|
}
|
|
else if (brightness > 1)
|
|
{
|
|
brightness = 1;
|
|
}
|
|
|
|
VectorScale( *((Vector*)color), brightness, curSeg.m_vColor );
|
|
|
|
CalcSegOrigin( &curSeg.m_vPos, i, noise_divisions, prgNoise, source, delta, perp, segments, freq, scale, fraction, flags );
|
|
|
|
// Specify the next segment.
|
|
if( endWidth == startWidth )
|
|
curSeg.m_flWidth = startWidth * 2;
|
|
else
|
|
curSeg.m_flWidth = ((fraction*(endWidth-startWidth))+startWidth) * 2;
|
|
|
|
// Reduce the width by the current number of branches we've had
|
|
for ( int j = 0; i < iBranches; j++ )
|
|
{
|
|
curSeg.m_flWidth *= 0.5;
|
|
}
|
|
|
|
curSeg.m_flTexCoord = vLast;
|
|
|
|
segDraw.NextSeg( &curSeg );
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
|
|
// Now see if we'd like to branch here
|
|
// For now, always branch at the midpoint.
|
|
// We could branch randomly, and multiple times per beam
|
|
if ( i == (segments * 0.5) )
|
|
{
|
|
// Figure out what the new width would be
|
|
// Halve the width because the beam is breaking in two, and halve it again because width is doubled above
|
|
flWidth = curSeg.m_flWidth * 0.25;
|
|
if ( flWidth > 1 )
|
|
{
|
|
iBranches++;
|
|
|
|
// Get an endpoint for the new branch
|
|
vecStart = curSeg.m_vPos;
|
|
vecEnd = source + delta + (MainViewUp() * 32) + (MainViewRight() * 32);
|
|
vecEnd -= vecStart;
|
|
|
|
// Reduce the end width by the current number of branches we've had
|
|
flEndWidth = endWidth;
|
|
for ( int j = 0; i < iBranches; j++ )
|
|
{
|
|
flEndWidth *= 0.5;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
segDraw.End();
|
|
|
|
// If we branched, draw the new beam too
|
|
if ( iBranches )
|
|
{
|
|
DrawTeslaSegs( noise_divisions, prgNoise, spritemodel, frame, rendermode,
|
|
vecStart, vecEnd, flWidth, flEndWidth, scale, freq, speed, segments,
|
|
flags, color, fadeLength, flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// *beammodel -
|
|
// *halomodel -
|
|
// flHaloScale -
|
|
// startWidth -
|
|
// endWidth -
|
|
// scale -
|
|
// freq -
|
|
// speed -
|
|
// segments -
|
|
// * -
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void DrawSplineSegs( int noise_divisions, float *prgNoise,
|
|
const model_t* beammodel, const model_t* halomodel, float flHaloScale,
|
|
float frame, int rendermode, int numAttachments, Vector* attachment,
|
|
float startWidth, float endWidth, float scale, float freq, float speed, int segments,
|
|
int flags, float* color, float fadeLength, float flHDRColorScale )
|
|
{
|
|
int noiseIndex, noiseStep;
|
|
float div, length, fraction, factor, vLast, vStep, brightness;
|
|
float scaledColor[3];
|
|
|
|
model_t *beamsprite = ( model_t *)beammodel;
|
|
model_t *halosprite = ( model_t *)halomodel;
|
|
|
|
CEngineSprite *pBeamSprite = Draw_SetSpriteTexture( beamsprite, frame, rendermode );
|
|
if ( !pBeamSprite )
|
|
return;
|
|
|
|
// Figure out the number of segments.
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pBeamSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
if ( segments > noise_divisions ) // UNDONE: Allow more segments?
|
|
segments = noise_divisions;
|
|
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
if ( segments < 16 )
|
|
segments = 16;
|
|
}
|
|
|
|
|
|
IMaterial *pBeamMaterial = pBeamSprite->GetMaterial();
|
|
CBeamSegDraw segDraw;
|
|
segDraw.Start( (segments-1)*(numAttachments-1), pBeamMaterial );
|
|
|
|
CEngineSprite *pHaloSprite = (CEngineSprite *)modelinfo->GetModelExtraData( halosprite );
|
|
IMaterial *pHaloMaterial = NULL;
|
|
if ( pHaloSprite )
|
|
{
|
|
pHaloSprite->SetRenderMode( kRenderGlow );
|
|
pHaloMaterial = pHaloSprite->GetMaterial();
|
|
}
|
|
|
|
//-----------------------------------------------------------
|
|
// Calculate widthStep if start and end width are different
|
|
//-----------------------------------------------------------
|
|
float widthStep;
|
|
if (startWidth != endWidth)
|
|
{
|
|
widthStep = (endWidth - startWidth)/numAttachments;
|
|
}
|
|
else
|
|
{
|
|
widthStep = 0;
|
|
}
|
|
|
|
// Calculate total length of beam
|
|
float flBeamLength = (attachment[0]-attachment[numAttachments-1]).Length();
|
|
|
|
// What fraction of beam should be faded
|
|
float fadeFraction = fadeLength/flBeamLength;
|
|
if (fadeFraction > 1)
|
|
{
|
|
fadeFraction = 1;
|
|
}
|
|
//---------------------------------------------------------------
|
|
// Go through each attachment drawing spline beams between them
|
|
//---------------------------------------------------------------
|
|
Vector vLastPoint(0,0,0);
|
|
Vector pPre; // attachment point before the current beam
|
|
Vector pStart; // start of current beam
|
|
Vector pEnd; // end of current beam
|
|
Vector pNext; // attachment point after the current beam
|
|
|
|
|
|
|
|
for (int j=0;j<numAttachments-1;j++)
|
|
{
|
|
if (j==0)
|
|
{
|
|
VectorCopy(attachment[0],pPre);
|
|
VectorCopy(pPre,vLastPoint);
|
|
}
|
|
else
|
|
{
|
|
VectorCopy(attachment[j-1],pPre);
|
|
}
|
|
|
|
VectorCopy(attachment[j], pStart);
|
|
VectorCopy(attachment[j+1], pEnd);
|
|
|
|
if (j+2 >= numAttachments-1)
|
|
{
|
|
VectorCopy(attachment[j+1],pNext);
|
|
}
|
|
else
|
|
{
|
|
VectorCopy(attachment[j+2],pNext);
|
|
}
|
|
|
|
Vector vDelta;
|
|
VectorSubtract(pEnd,pStart,vDelta);
|
|
length = VectorLength( vDelta ) * 0.01;
|
|
if ( length < 0.5 ) // Don't lose all of the noise/texture on short beams
|
|
length = 0.5;
|
|
div = 1.0 / (segments-1);
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
vStep = length*div; // Texture length texels per space pixel
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
scale = scale * 100;
|
|
length = segments * (1.0/10);
|
|
}
|
|
else
|
|
scale = scale * length;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Iterator to resample noise waveform (it needs to be generated in powers of 2)
|
|
// -----------------------------------------------------------------------------
|
|
noiseStep = (int)((float)(noise_divisions-1) * div * 65536.0f);
|
|
noiseIndex = noiseStep;
|
|
|
|
if ( flags & FBEAM_SINENOISE )
|
|
noiseIndex = 0;
|
|
|
|
brightness = 1.0;
|
|
if ( flags & FBEAM_SHADEIN )
|
|
brightness = 0;
|
|
|
|
CBeamSeg seg;
|
|
seg.m_flAlpha = 1;
|
|
|
|
VectorScale( color, brightness, scaledColor );
|
|
seg.m_vColor.Init( scaledColor[0], scaledColor[1], scaledColor[2] );
|
|
|
|
|
|
// -------------------------------------------------
|
|
// Calc start and end widths for this segment
|
|
// -------------------------------------------------
|
|
float startSegWidth = startWidth + (widthStep*j);
|
|
float endSegWidth = startWidth + (widthStep*(j+1));
|
|
|
|
// -------------------------------------------------
|
|
// Now draw each segment
|
|
// -------------------------------------------------
|
|
float fBestFraction = -1;
|
|
float bestDot = 0;
|
|
for (int i = 1; i < segments; i++ )
|
|
{
|
|
fraction = i * div;
|
|
|
|
// Fade in our out beam to fadeLength
|
|
// BUG BUG: should be based on total lengh of beam not this particular fraction
|
|
if ( flags & FBEAM_SHADEIN )
|
|
{
|
|
brightness = fraction/fadeFraction;
|
|
if (brightness > 1)
|
|
{
|
|
brightness = 1;
|
|
}
|
|
}
|
|
else if ( flags & FBEAM_SHADEOUT )
|
|
{
|
|
float fadeFraction = fadeLength/length;
|
|
brightness = 1.0 - (fraction/fadeFraction);
|
|
if (brightness < 0)
|
|
{
|
|
brightness = 0;
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------
|
|
// Calculate spline position
|
|
// -----------------------------------------------------------
|
|
Vector vTarget(0,0,0);
|
|
|
|
Catmull_Rom_Spline(pPre, pStart, pEnd, pNext, fraction, vTarget );
|
|
|
|
seg.m_vPos[0] = vTarget.x;
|
|
seg.m_vPos[1] = vTarget.y;
|
|
seg.m_vPos[2] = vTarget.z;
|
|
|
|
// --------------------------------------------------------------
|
|
// Keep track of segment most facing the player for halo effect
|
|
// --------------------------------------------------------------
|
|
if (pHaloMaterial)
|
|
{
|
|
Vector vBeamDir1;
|
|
VectorSubtract(seg.m_vPos,vLastPoint,vBeamDir1);
|
|
VectorNormalize(vBeamDir1);
|
|
|
|
Vector vLookDir;
|
|
VectorSubtract(CurrentViewOrigin(),seg.m_vPos,vLookDir);
|
|
VectorNormalize(vLookDir);
|
|
|
|
float dotpr = fabs(DotProduct(vBeamDir1,vLookDir));
|
|
static float thresh = 0.85;
|
|
if (dotpr > thresh && dotpr > bestDot)
|
|
{
|
|
bestDot = dotpr;
|
|
fBestFraction = fraction;
|
|
}
|
|
VectorCopy(seg.m_vPos,vLastPoint);
|
|
}
|
|
|
|
|
|
// ----------------------
|
|
// Distort using noise
|
|
// ----------------------
|
|
if ( scale != 0 )
|
|
{
|
|
factor = prgNoise[noiseIndex>>16] * scale;
|
|
if ( flags & FBEAM_SINENOISE )
|
|
{
|
|
float s, c;
|
|
SinCos( fraction*M_PI*length + freq, &s, &c );
|
|
VectorMA( seg.m_vPos, factor * s, CurrentViewUp(), seg.m_vPos );
|
|
// Rotate the noise along the perpendicluar axis a bit to keep the bolt from looking diagonal
|
|
VectorMA( seg.m_vPos, factor * c, CurrentViewRight(), seg.m_vPos );
|
|
}
|
|
else
|
|
{
|
|
VectorMA( seg.m_vPos, factor, CurrentViewUp(), seg.m_vPos );
|
|
// Rotate the noise along the perpendicluar axis a bit to keep the bolt from looking diagonal
|
|
factor = prgNoise[noiseIndex>>16] * scale * cos(fraction*M_PI*3+freq);
|
|
VectorMA( seg.m_vPos, factor, CurrentViewRight(), seg.m_vPos );
|
|
}
|
|
}
|
|
|
|
|
|
// Scale width if non-zero spread
|
|
if (startWidth != endWidth)
|
|
seg.m_flWidth = ((fraction*(endSegWidth-startSegWidth))+startSegWidth)*2;
|
|
else
|
|
seg.m_flWidth = startWidth*2;
|
|
|
|
seg.m_flTexCoord = vLast;
|
|
segDraw.NextSeg( &seg );
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
noiseIndex += noiseStep;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------
|
|
// Draw halo on segment most facing the player
|
|
// --------------------------------------------------------------
|
|
if (false&&pHaloMaterial)
|
|
{
|
|
Vector vHaloPos(0,0,0);
|
|
if (bestDot != 0)
|
|
{
|
|
Catmull_Rom_Spline(pPre, pStart, pEnd, pNext, fBestFraction, vHaloPos);
|
|
}
|
|
else
|
|
{
|
|
Vector vBeamDir1;
|
|
VectorSubtract(pStart,pEnd,vBeamDir1);
|
|
VectorNormalize(vBeamDir1);
|
|
|
|
Vector vLookDir;
|
|
VectorSubtract(CurrentViewOrigin(),pStart,vLookDir);
|
|
VectorNormalize(vLookDir);
|
|
|
|
bestDot = fabs(DotProduct(vBeamDir1,vLookDir));
|
|
static float thresh = 0.85;
|
|
if (bestDot > thresh)
|
|
{
|
|
fBestFraction = 0.5;
|
|
VectorAdd(pStart,pEnd,vHaloPos);
|
|
VectorScale(vHaloPos,0.5,vHaloPos);
|
|
}
|
|
}
|
|
if (fBestFraction > 0)
|
|
{
|
|
float fade = pow(bestDot,60);
|
|
if (fade > 1.0) fade = 1.0;
|
|
float haloColor[3];
|
|
VectorScale( color, fade, haloColor );
|
|
materials->Bind(pHaloMaterial);
|
|
float curWidth = (fBestFraction*(endSegWidth-startSegWidth))+startSegWidth;
|
|
DrawHalo(pHaloMaterial,vHaloPos,flHaloScale*curWidth/endWidth,haloColor, flHDRColorScale);
|
|
}
|
|
}
|
|
}
|
|
|
|
segDraw.End();
|
|
|
|
// ------------------------
|
|
// Draw halo at end of beam
|
|
// ------------------------
|
|
if (pHaloMaterial)
|
|
{
|
|
materials->Bind(pHaloMaterial);
|
|
DrawHalo(pHaloMaterial,pEnd,flHaloScale,scaledColor, flHDRColorScale);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *spritemodel -
|
|
// frame -
|
|
// rendermode -
|
|
// source -
|
|
// scale -
|
|
// *color -
|
|
//-----------------------------------------------------------------------------
|
|
void BeamDrawHalo( const model_t* spritemodel, float frame, int rendermode,
|
|
const Vector& source, float scale, float* color, float flHDRColorScale )
|
|
{
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
DrawHalo( pSprite->GetMaterial(), source, scale, color, flHDRColorScale );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// *spritemodel -
|
|
// frame -
|
|
// rendermode -
|
|
// source -
|
|
// delta -
|
|
// width -
|
|
// scale -
|
|
// freq -
|
|
// speed -
|
|
// segments -
|
|
// *color -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawDisk( int noise_divisions, float *prgNoise, const model_t* spritemodel,
|
|
float frame, int rendermode, const Vector& source, const Vector& delta,
|
|
float width, float scale, float freq, float speed, int segments, float* color, float flHDRColorScale )
|
|
{
|
|
int i;
|
|
float div, length, fraction, vLast, vStep;
|
|
Vector point;
|
|
float w;
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
if ( segments > noise_divisions ) // UNDONE: Allow more segments?
|
|
segments = noise_divisions;
|
|
|
|
length = VectorLength( delta ) * 0.01;
|
|
if ( length < 0.5 ) // Don't lose all of the noise/texture on short beams
|
|
length = 0.5;
|
|
div = 1.0 / (segments-1);
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
vStep = length*div; // Texture length texels per space pixel
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
scale = scale * length;
|
|
|
|
w = freq * delta[2];
|
|
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, (segments - 1) * 2 );
|
|
|
|
// NOTE: We must force the degenerate triangles to be on the edge
|
|
for ( i = 0; i < segments; i++ )
|
|
{
|
|
float s, c;
|
|
fraction = i * div;
|
|
|
|
point[0] = source[0];
|
|
point[1] = source[1];
|
|
point[2] = source[2];
|
|
|
|
meshBuilder.Color3fv( color );
|
|
meshBuilder.TexCoord2f( 0, 1.0, vLast );
|
|
meshBuilder.Position3fv( point.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
SinCos( fraction * 2 * M_PI, &s, &c );
|
|
point[0] = s * w + source[0];
|
|
point[1] = c * w + source[1];
|
|
point[2] = source[2];
|
|
|
|
meshBuilder.Color3fv( color );
|
|
meshBuilder.TexCoord2f( 0, 0.0, vLast );
|
|
meshBuilder.Position3fv( point.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
}
|
|
|
|
meshBuilder.End( );
|
|
pMesh->Draw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// *spritemodel -
|
|
// frame -
|
|
// rendermode -
|
|
// source -
|
|
// delta -
|
|
// width -
|
|
// scale -
|
|
// freq -
|
|
// speed -
|
|
// segments -
|
|
// *color -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawCylinder( int noise_divisions, float *prgNoise, const model_t* spritemodel,
|
|
float frame, int rendermode, const Vector& source, const Vector& delta,
|
|
float width, float scale, float freq, float speed, int segments,
|
|
float* color, float flHDRColorScale )
|
|
{
|
|
int i;
|
|
float div, length, fraction, vLast, vStep;
|
|
Vector point;
|
|
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
if ( segments > noise_divisions ) // UNDONE: Allow more segments?
|
|
segments = noise_divisions;
|
|
|
|
length = VectorLength( delta ) * 0.01;
|
|
if ( length < 0.5 ) // Don't lose all of the noise/texture on short beams
|
|
length = 0.5;
|
|
div = 1.0 / (segments-1);
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
vStep = length*div; // Texture length texels per space pixel
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
scale = scale * length;
|
|
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, (segments - 1) * 2 );
|
|
|
|
float radius = delta[2];
|
|
for ( i = 0; i < segments; i++ )
|
|
{
|
|
float s, c;
|
|
fraction = i * div;
|
|
SinCos( fraction * 2 * M_PI, &s, &c );
|
|
|
|
point[0] = s * freq * radius + source[0];
|
|
point[1] = c * freq * radius + source[1];
|
|
point[2] = source[2] + width;
|
|
|
|
meshBuilder.Color3f( 0.0f, 0.0f, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, vLast );
|
|
meshBuilder.Position3fv( point.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
point[0] = s * freq * (radius + width) + source[0];
|
|
point[1] = c * freq * (radius + width) + source[1];
|
|
point[2] = source[2] - width;
|
|
|
|
meshBuilder.Color3fv( color );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, vLast );
|
|
meshBuilder.Position3fv( point.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : noise_divisions -
|
|
// *prgNoise -
|
|
// (*pfnNoise -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawRing( int noise_divisions, float *prgNoise, void (*pfnNoise)( float *noise, int divs, float scale ),
|
|
const model_t* spritemodel, float frame, int rendermode,
|
|
const Vector& source, const Vector& delta, float width,
|
|
float amplitude, float freq, float speed, int segments, float *color, float flHDRColorScale )
|
|
{
|
|
int i, j, noiseIndex, noiseStep;
|
|
float div, length, fraction, factor, vLast, vStep;
|
|
Vector last1, last2, point, screen, screenLast(0,0,0), tmp, normal;
|
|
Vector center, xaxis, yaxis, zaxis;
|
|
float radius, x, y, scale;
|
|
Vector d;
|
|
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
VectorCopy( delta, d );
|
|
|
|
if ( segments < 2 )
|
|
return;
|
|
|
|
segments = segments * M_PI;
|
|
|
|
if ( segments > noise_divisions * 8 ) // UNDONE: Allow more segments?
|
|
segments = noise_divisions * 8;
|
|
|
|
length = VectorLength( d ) * 0.01 * M_PI;
|
|
if ( length < 0.5 ) // Don't lose all of the noise/texture on short beams
|
|
length = 0.5;
|
|
div = 1.0 / (segments-1);
|
|
|
|
// UNDONE: Expose texture length scale factor to control "fuzziness"
|
|
vStep = length*div/8.0; // Texture length texels per space pixel
|
|
|
|
// UNDONE: Expose this paramter as well(3.5)? Texture scroll rate along beam
|
|
vLast = fmod(freq*speed,1); // Scroll speed 3.5 -- initial texture position, scrolls 3.5/sec (1.0 is entire texture)
|
|
scale = amplitude * length / 8.0;
|
|
|
|
// Iterator to resample noise waveform (it needs to be generated in powers of 2)
|
|
noiseStep = (int)((noise_divisions-1) * div * 65536.0) * 8;
|
|
noiseIndex = 0;
|
|
|
|
VectorScale( d, 0.5, d );
|
|
VectorAdd( source, d, center );
|
|
zaxis[0] = 0; zaxis[1] = 0; zaxis[2] = 1;
|
|
|
|
VectorCopy( d, xaxis );
|
|
radius = VectorLength( xaxis );
|
|
|
|
// cull beamring
|
|
// --------------------------------
|
|
// Compute box center +/- radius
|
|
last1[0] = radius;
|
|
last1[1] = radius;
|
|
last1[2] = scale;
|
|
VectorAdd( center, last1, tmp ); // maxs
|
|
VectorSubtract( center, last1, screen ); // mins
|
|
|
|
// Is that box in PVS && frustum?
|
|
if ( !engine->IsBoxVisible( screen, tmp ) || engine->CullBox( screen, tmp ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
yaxis[0] = xaxis[1]; yaxis[1] = -xaxis[0]; yaxis[2] = 0;
|
|
VectorNormalize( yaxis );
|
|
VectorScale( yaxis, radius, yaxis );
|
|
|
|
j = segments / 8;
|
|
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, (segments) * 2 );
|
|
|
|
for ( i = 0; i < segments + 1; i++ )
|
|
{
|
|
fraction = i * div;
|
|
SinCos( fraction * 2 * M_PI, &x, &y );
|
|
|
|
point[0] = xaxis[0] * x + yaxis[0] * y + center[0];
|
|
point[1] = xaxis[1] * x + yaxis[1] * y + center[1];
|
|
point[2] = xaxis[2] * x + yaxis[2] * y + center[2];
|
|
|
|
// Distort using noise
|
|
if ( scale != 0.0f )
|
|
{
|
|
factor = prgNoise[(noiseIndex>>16) & 0x7F] * scale;
|
|
VectorMA( point, factor, CurrentViewUp(), point );
|
|
|
|
// Rotate the noise along the perpendicluar axis a bit to keep the bolt from looking diagonal
|
|
factor = prgNoise[(noiseIndex>>16) & 0x7F] * scale * cos(fraction*M_PI*3*8+freq);
|
|
VectorMA( point, factor, CurrentViewRight(), point );
|
|
}
|
|
|
|
// Transform point into screen space
|
|
ScreenTransform( point, screen );
|
|
|
|
if (i != 0)
|
|
{
|
|
// Build world-space normal to screen-space direction vector
|
|
VectorSubtract( screen, screenLast, tmp );
|
|
// We don't need Z, we're in screen space
|
|
tmp[2] = 0;
|
|
VectorNormalize( tmp );
|
|
VectorScale( CurrentViewUp(), tmp[0], normal ); // Build point along noraml line (normal is -y, x)
|
|
VectorMA( normal, -tmp[1], CurrentViewRight(), normal );
|
|
|
|
// Make a wide line
|
|
VectorMA( point, width, normal, last1 );
|
|
VectorMA( point, -width, normal, last2 );
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
meshBuilder.Color3fv( color );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, vLast );
|
|
meshBuilder.Position3fv( last2.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3fv( color );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, vLast );
|
|
meshBuilder.Position3fv( last1.Base() );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
VectorCopy( screen, screenLast );
|
|
noiseIndex += noiseStep;
|
|
|
|
j--;
|
|
if (j == 0 && amplitude != 0 )
|
|
{
|
|
j = segments / 8;
|
|
(*pfnNoise)( prgNoise, noise_divisions, 1.0f );
|
|
}
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : spritemodel -
|
|
// *pHead -
|
|
// delta -
|
|
// *screen -
|
|
// *screenLast -
|
|
// die -
|
|
// source -
|
|
// flags -
|
|
// width -
|
|
// amplitude -
|
|
// freq -
|
|
// *color -
|
|
//-----------------------------------------------------------------------------
|
|
void DrawBeamFollow( const model_t* spritemodel, BeamTrail_t* pHead, int frame, int rendermode,
|
|
Vector& delta, Vector& screen, Vector& screenLast, float die,
|
|
const Vector& source, int flags, float width, float amplitude,
|
|
float freq, float* color, float flHDRColorScale )
|
|
{
|
|
float fraction;
|
|
float div;
|
|
float vLast = 0.0;
|
|
float vStep = 1.0;
|
|
Vector last1, last2, tmp, normal;
|
|
float scaledColor[3];
|
|
|
|
CEngineSprite *pSprite = Draw_SetSpriteTexture( spritemodel, frame, rendermode );
|
|
if ( !pSprite )
|
|
return;
|
|
|
|
IMaterial *pMaterial = pSprite->GetMaterial();
|
|
if( pMaterial )
|
|
{
|
|
static unsigned int nHDRColorScaleCache = 0;
|
|
IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
|
|
if( pHDRColorScaleVar )
|
|
{
|
|
pHDRColorScaleVar->SetFloatValue( flHDRColorScale );
|
|
}
|
|
}
|
|
|
|
// UNDONE: This won't work, screen and screenLast must be extrapolated here to fix the
|
|
// first beam segment for this trail
|
|
|
|
// Build world-space normal to screen-space direction vector
|
|
VectorSubtract( screen, screenLast, tmp );
|
|
// We don't need Z, we're in screen space
|
|
tmp[2] = 0;
|
|
VectorNormalize( tmp );
|
|
VectorScale( CurrentViewUp(), tmp[0], normal ); // Build point along noraml line (normal is -y, x)
|
|
VectorMA( normal, -tmp[1], CurrentViewRight(), normal );
|
|
|
|
// Make a wide line
|
|
VectorMA( delta, width, normal, last1 );
|
|
VectorMA( delta, -width, normal, last2 );
|
|
|
|
div = 1.0 / amplitude;
|
|
fraction = ( die - gpGlobals->curtime ) * div;
|
|
unsigned char nColor[3];
|
|
|
|
VectorScale( color, fraction, scaledColor );
|
|
nColor[0] = (unsigned char)clamp( (int)(scaledColor[0] * 255.0f), 0, 255 );
|
|
nColor[1] = (unsigned char)clamp( (int)(scaledColor[1] * 255.0f), 0, 255 );
|
|
nColor[2] = (unsigned char)clamp( (int)(scaledColor[2] * 255.0f), 0, 255 );
|
|
|
|
// need to count the segments
|
|
int count = 0;
|
|
BeamTrail_t* pTraverse = pHead;
|
|
while ( pTraverse )
|
|
{
|
|
++count;
|
|
pTraverse = pTraverse->next;
|
|
}
|
|
|
|
IMesh* pMesh = materials->GetDynamicMesh( );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, count );
|
|
|
|
while (pHead)
|
|
{
|
|
// Msg("%.2f ", fraction );
|
|
meshBuilder.Position3fv( last1.Base() );
|
|
meshBuilder.Color3ubv( nColor );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( last2.Base() );
|
|
meshBuilder.Color3ubv( nColor );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
// Transform point into screen space
|
|
ScreenTransform( pHead->org, screen );
|
|
// Build world-space normal to screen-space direction vector
|
|
VectorSubtract( screen, screenLast, tmp );
|
|
// We don't need Z, we're in screen space
|
|
tmp[2] = 0;
|
|
VectorNormalize( tmp );
|
|
VectorScale( CurrentViewUp(), tmp[0], normal ); // Build point along noraml line (normal is -y, x)
|
|
VectorMA( normal, -tmp[1], CurrentViewRight(), normal );
|
|
|
|
// Make a wide line
|
|
VectorMA( pHead->org, width, normal, last1 );
|
|
VectorMA( pHead->org, -width, normal, last2 );
|
|
|
|
vLast += vStep; // Advance texture scroll (v axis only)
|
|
|
|
if (pHead->next != NULL)
|
|
{
|
|
fraction = (pHead->die - gpGlobals->curtime) * div;
|
|
VectorScale( color, fraction, scaledColor );
|
|
nColor[0] = (unsigned char)clamp( (int)(scaledColor[0] * 255.0f), 0, 255 );
|
|
nColor[1] = (unsigned char)clamp( (int)(scaledColor[1] * 255.0f), 0, 255 );
|
|
nColor[2] = (unsigned char)clamp( (int)(scaledColor[2] * 255.0f), 0, 255 );
|
|
}
|
|
else
|
|
{
|
|
fraction = 0.0;
|
|
nColor[0] = nColor[1] = nColor[2] = 0;
|
|
}
|
|
|
|
meshBuilder.Position3fv( last2.Base() );
|
|
meshBuilder.Color3ubv( nColor );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( last1.Base() );
|
|
meshBuilder.Color3ubv( nColor );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
VectorCopy( screen, screenLast );
|
|
|
|
pHead = pHead->next;
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
|
|
/*
|
|
P0 = start
|
|
P1 = control
|
|
P2 = end
|
|
P(t) = (1-t)^2 * P0 + 2t(1-t)*P1 + t^2 * P2
|
|
*/
|
|
void DrawBeamQuadratic( const Vector &start, const Vector &control, const Vector &end, float width, const Vector &color, float scrollOffset, float flHDRColorScale )
|
|
{
|
|
int subdivisions = 16;
|
|
|
|
CBeamSegDraw beamDraw;
|
|
beamDraw.Start( subdivisions+1, NULL );
|
|
|
|
CBeamSeg seg;
|
|
seg.m_flAlpha = 1.0;
|
|
seg.m_flWidth = width;
|
|
|
|
float t = 0;
|
|
float u = fmod( scrollOffset, 1 );
|
|
float dt = 1.0 / (float)subdivisions;
|
|
for( int i = 0; i <= subdivisions; i++, t += dt )
|
|
{
|
|
float omt = (1-t);
|
|
float p0 = omt*omt;
|
|
float p1 = 2*t*omt;
|
|
float p2 = t*t;
|
|
|
|
seg.m_vPos = p0 * start + p1 * control + p2 * end;
|
|
seg.m_flTexCoord = u - t;
|
|
if ( i == 0 || i == subdivisions )
|
|
{
|
|
// HACK: fade out the ends a bit
|
|
seg.m_vColor = vec3_origin;
|
|
}
|
|
else
|
|
{
|
|
seg.m_vColor = color;
|
|
}
|
|
beamDraw.NextSeg( &seg );
|
|
}
|
|
|
|
beamDraw.End();
|
|
}
|