mirror of
https://github.com/Gigaslav/HL2Overcharged.git
synced 2026-09-15 20:12:37 +03:00
420 lines
10 KiB
C++
420 lines
10 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "model_types.h"
|
|
#include "clienteffectprecachesystem.h"
|
|
#include "fx.h"
|
|
#include "c_te_effect_dispatch.h"
|
|
#include "beamdraw.h"
|
|
|
|
CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectCrossbow )
|
|
CLIENTEFFECT_MATERIAL( "effects/muzzleflash1" )
|
|
CLIENTEFFECT_REGISTER_END()
|
|
|
|
//
|
|
// Crossbow bolt
|
|
//
|
|
|
|
class C_CrossbowBolt : public C_BaseCombatCharacter
|
|
{
|
|
DECLARE_CLASS( C_CrossbowBolt, C_BaseCombatCharacter );
|
|
DECLARE_CLIENTCLASS();
|
|
public:
|
|
|
|
C_CrossbowBolt( void );
|
|
|
|
virtual RenderGroup_t GetRenderGroup( void )
|
|
{
|
|
// We want to draw translucent bits as well as our main model
|
|
return RENDER_GROUP_TWOPASS;
|
|
}
|
|
|
|
virtual void ClientThink( void );
|
|
|
|
virtual void OnDataChanged( DataUpdateType_t updateType );
|
|
virtual int DrawModel( int flags );
|
|
|
|
//IMaterial* m_pWireframe;
|
|
private:
|
|
|
|
C_CrossbowBolt( const C_CrossbowBolt & ); // not defined, not accessible
|
|
|
|
Vector m_vecLastOrigin;
|
|
bool m_bUpdated;
|
|
};
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT( C_CrossbowBolt, DT_CrossbowBolt, CCrossbowBolt )
|
|
END_RECV_TABLE()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
C_CrossbowBolt::C_CrossbowBolt( void )
|
|
{
|
|
//m_pWireframe = materials->FindMaterial("shadertest/wireframevertexcolor", TEXTURE_GROUP_OTHER);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : updateType -
|
|
//-----------------------------------------------------------------------------
|
|
void C_CrossbowBolt::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
m_bUpdated = false;
|
|
m_vecLastOrigin = GetAbsOrigin();
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : flags -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int C_CrossbowBolt::DrawModel( int flags )
|
|
{
|
|
// See if we're drawing the motion blur
|
|
/*if ( flags & STUDIO_TRANSPARENCY )
|
|
{
|
|
float color[3];
|
|
IMaterial *pBlurMaterial = materials->FindMaterial( "effects/muzzleflash1", NULL, false );
|
|
|
|
Vector vecDir = GetAbsOrigin() - m_vecLastOrigin;
|
|
float speed = VectorNormalize( vecDir );
|
|
|
|
speed = clamp( speed, 0, 32 );
|
|
|
|
if ( speed > 0 )
|
|
{
|
|
float stepSize = MIN( ( speed * 0.5f ), 4.0f );
|
|
|
|
Vector spawnPos = GetAbsOrigin() + ( vecDir * 24.0f );
|
|
Vector spawnStep = -vecDir * stepSize;
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
pRenderContext->Bind( pBlurMaterial );
|
|
|
|
float alpha;
|
|
|
|
// Draw the motion blurred trail
|
|
for ( int i = 0; i < 20; i++ )
|
|
{
|
|
spawnPos += spawnStep;
|
|
|
|
alpha = RemapValClamped( i, 5, 11, 0.25f, 0.05f );
|
|
|
|
color[0] = color[1] = color[2] = alpha;
|
|
|
|
DrawHalo( pBlurMaterial, spawnPos, 3.0f, color );
|
|
}
|
|
}
|
|
|
|
if ( gpGlobals->frametime > 0.0f && !m_bUpdated)
|
|
{
|
|
m_bUpdated = true;
|
|
m_vecLastOrigin = GetAbsOrigin();
|
|
}
|
|
|
|
return 1;
|
|
}*/
|
|
|
|
// Draw the normal portion
|
|
return BaseClass::DrawModel( flags );
|
|
|
|
|
|
}
|
|
|
|
/*double noise2(double arg)
|
|
{
|
|
return (arg + random->RandomFloat(-1.5f, 1.5f));
|
|
}
|
|
static void RandomizeNormal1(Vector &vec)
|
|
{
|
|
vec.x = 2.0f * (noise2(vec.x) - 0.5f);
|
|
vec.y = 2.0f * (noise2(vec.y) - 0.5f);
|
|
vec.z = 2.0f * (noise2(vec.z) - 0.5f);
|
|
}*/
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_CrossbowBolt::ClientThink( void )
|
|
{
|
|
m_bUpdated = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &data -
|
|
//-----------------------------------------------------------------------------
|
|
void CrosshairLoadCallback( const CEffectData &data )
|
|
{
|
|
IClientRenderable *pRenderable = data.GetRenderable( );
|
|
if ( !pRenderable )
|
|
return;
|
|
|
|
Vector position;
|
|
QAngle angles;
|
|
|
|
// If we found the attachment, emit sparks there
|
|
if ( pRenderable->GetAttachment( data.m_nAttachmentIndex, position, angles ) )
|
|
{
|
|
FX_ElectricSpark( position, 1.0f, 1.0f, NULL );
|
|
}
|
|
|
|
|
|
/*
|
|
Vector origin = position;
|
|
int stacks = 200;
|
|
int slices = 200;
|
|
float radius = 5000.0f;
|
|
// this sucks and stuff
|
|
float x = origin.x;
|
|
float y = origin.y;
|
|
float z = origin.z;
|
|
float stackAngle, sliceAngle;
|
|
int stack, slice;
|
|
Vector v[4];
|
|
float sliced, stacked, sliced1, stacked1, stacks1;
|
|
float slicedsin, slicedcos, stackedsin, stackedcos;
|
|
float sliced1sin, sliced1cos, stacked1sin, stacked1cos;
|
|
float stacks1sin, stacks1cos;
|
|
float stacksin, stackcos;
|
|
|
|
IMaterial *pMaterial = materials->FindMaterial("effects/splashwake4", 0);
|
|
CMatRenderContextPtr pRenderContext(materials);
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh(true, NULL, NULL, pMaterial);
|
|
CMeshBuilder meshBuilder;
|
|
|
|
stackAngle = M_PI / (float)stacks;
|
|
sliceAngle = 2.0 * M_PI / (float)slices;
|
|
|
|
for (stack = 1; stack < stacks - 1; stack++)
|
|
{
|
|
for (slice = 0; slice < slices; slice++)
|
|
{
|
|
int i, j;
|
|
|
|
sliced = sliceAngle * slice;
|
|
stacked = stackAngle * stack;
|
|
sliced1 = sliceAngle * (slice + 1);
|
|
stacked1 = stackAngle * (stack + 1);
|
|
|
|
SinCos(sliced, &slicedsin, &slicedcos);
|
|
SinCos(stacked, &stackedsin, &stackedcos);
|
|
SinCos(sliced1, &sliced1sin, &sliced1cos);
|
|
SinCos(stacked1, &stacked1sin, &stacked1cos);
|
|
|
|
v[0][0] = -slicedsin * stackedsin;
|
|
v[0][1] = slicedcos * stackedsin;
|
|
v[0][2] = stackedcos;
|
|
|
|
v[1][0] = -sliced1sin * stackedsin;
|
|
v[1][1] = sliced1cos * stackedsin;
|
|
v[1][2] = stackedcos;
|
|
|
|
v[2][0] = -sliced1sin * stacked1sin;
|
|
v[2][1] = sliced1cos * stacked1sin;
|
|
v[2][2] = stacked1cos;
|
|
|
|
v[3][0] = -slicedsin * stacked1sin;
|
|
v[3][1] = slicedcos * stacked1sin;
|
|
v[3][2] = stacked1cos;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
v[i][j] *= radius;
|
|
}
|
|
v[i][0] += x;
|
|
v[i][1] += y;
|
|
v[i][2] += z;
|
|
}
|
|
|
|
#if 1
|
|
// if( drawWireframe.value )
|
|
if (1)
|
|
{
|
|
meshBuilder.Begin(pMesh, MATERIAL_QUADS, 1);
|
|
|
|
meshBuilder.Position3fv(v[0].Base());
|
|
Vector normal;
|
|
normal = v[0] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[1].Base());
|
|
normal = v[1] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[2].Base());
|
|
normal = v[2] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[3].Base());
|
|
normal = v[3] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
else
|
|
{
|
|
// DrawIndexedQuad( v, 0, 1, 2, 3 );
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// do the caps
|
|
for (slice = 0; slice < slices; slice++)
|
|
{
|
|
int i, j;
|
|
|
|
sliced = sliceAngle * slice;
|
|
stacked = stackAngle * stack;
|
|
sliced1 = sliceAngle * (slice + 1);
|
|
stacked1 = stackAngle * (stack + 1);
|
|
stacks1 = stackAngle * (stacks - 1);
|
|
|
|
SinCos(sliced, &slicedsin, &slicedcos);
|
|
SinCos(stacked, &stackedsin, &stackedcos);
|
|
SinCos(sliced1, &sliced1sin, &sliced1cos);
|
|
SinCos(stacked1, &stacked1sin, &stacked1cos);
|
|
SinCos(stackAngle, &stacksin, &stackcos);
|
|
SinCos(stacks1, &stacks1sin, &stacks1cos);
|
|
|
|
v[0][0] = 0.0f;
|
|
v[0][1] = 0.0f;
|
|
v[0][2] = 1.0f;
|
|
|
|
v[1][0] = -sliced1sin * stacksin;
|
|
v[1][1] = sliced1cos * stacksin;
|
|
v[1][2] = stackcos;
|
|
|
|
v[2][0] = -slicedsin * stacksin;
|
|
v[2][1] = slicedcos * stacksin;
|
|
v[2][2] = stackcos;
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
v[i][j] *= radius;
|
|
}
|
|
v[i][0] += x;
|
|
v[i][1] += y;
|
|
v[i][2] += z;
|
|
}
|
|
|
|
meshBuilder.Begin(pMesh, MATERIAL_TRIANGLES, 1);
|
|
|
|
meshBuilder.Position3fv(v[0].Base());
|
|
Vector normal;
|
|
normal = v[0] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[1].Base());
|
|
normal = v[1] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[2].Base());
|
|
normal = v[2] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
v[0][0] = 0.0f;
|
|
v[0][1] = 0.0f;
|
|
v[0][2] = -1.0f;
|
|
|
|
v[1][0] = -sliced1sin * stacks1sin;
|
|
v[1][1] = sliced1cos * stacks1sin;
|
|
v[1][2] = stacks1cos;
|
|
|
|
v[2][0] = -slicedsin * stacks1sin;
|
|
v[2][1] = slicedcos * stacks1sin;
|
|
v[2][2] = stacks1cos;
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
v[i][j] *= radius;
|
|
}
|
|
v[i][0] += x;
|
|
v[i][1] += y;
|
|
v[i][2] += z;
|
|
}
|
|
|
|
meshBuilder.Begin(pMesh, MATERIAL_TRIANGLES, 1);
|
|
|
|
meshBuilder.Position3fv(v[0].Base());
|
|
normal = v[0] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[2].Base());
|
|
normal = v[2] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv(v[1].Base());
|
|
normal = v[1] - origin;
|
|
VectorNormalize(normal);
|
|
RandomizeNormal1(normal);
|
|
VectorNormalize(normal);
|
|
meshBuilder.Normal3fv(normal.Base());
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}*/
|
|
}
|
|
|
|
DECLARE_CLIENT_EFFECT( "CrossbowLoad", CrosshairLoadCallback );
|