Пример #1
0
void CE_CBeam::RelinkBeam( void )
{
	// FIXME: Why doesn't this just define the absbox too?
	// It seems that we don't need to recompute the absbox
	// in CBaseEntity::SetObjectCollisionBox, in fact the absbox
	// computed there seems way too big
	Vector startPos = GetAbsStartPos(), endPos = GetAbsEndPos();

	Vector vecAbsExtra1, vecAbsExtra2;
	bool bUseExtraPoints = false;

	// UNDONE: Should we do this to make the boxes smaller?
	//SetAbsOrigin( startPos );

	Vector vecBeamMin, vecBeamMax;
	VectorMin( startPos, endPos, vecBeamMin );
	VectorMax( startPos, endPos, vecBeamMax );

	if ( bUseExtraPoints )
	{
		VectorMin( vecBeamMin, vecAbsExtra1, vecBeamMin );
		VectorMin( vecBeamMin, vecAbsExtra2, vecBeamMin );
		VectorMax( vecBeamMax, vecAbsExtra1, vecBeamMax );
		VectorMax( vecBeamMax, vecAbsExtra2, vecBeamMax );
	}

	SetCollisionBounds( vecBeamMin - GetAbsOrigin(), vecBeamMax - GetAbsOrigin() );
}
Пример #2
0
void CDispInfo::GetIntersectingSurfaces( GetIntersectingSurfaces_Struct *pStruct )
{
    if ( !m_Verts.Count() || !m_nIndices )
        return;

    // Walk through all of our triangles and add them one by one.
    unsigned short *pEnd = m_Indices.Base() + m_nIndices;
    SurfInfo *pOut = &pStruct->m_pInfos[ pStruct->m_nSetInfos ];
    for ( unsigned short *pTri = m_Indices.Base(); pTri < pEnd; pTri += 3 )
    {
        // Is the list going to overflow?
        if ( pStruct->m_nSetInfos >= pStruct->m_nMaxInfos )
            return;

        Vector const &a = m_Verts[pTri[0]].m_vPos;
        Vector const &b = m_Verts[pTri[1]].m_vPos;
        Vector const &c = m_Verts[pTri[2]].m_vPos;

        // Get the boundaries.
        Vector vMin;
        VectorMin( a, b, vMin );
        VectorMin( c, vMin, vMin );

        Vector vMax;
        VectorMax( a, b, vMax );
        VectorMax( c, vMax, vMax );

        // See if it touches the sphere.
        int iDim;
        for ( iDim=0; iDim < 3; iDim++ )
        {
            if ( ((*pStruct->m_pCenter)[iDim]+pStruct->m_Radius) < vMin[iDim] ||
                    ((*pStruct->m_pCenter)[iDim]-pStruct->m_Radius) > vMax[iDim] )
            {
                break;
            }
        }

        if ( iDim == 3 )
        {
            // Couldn't reject the sphere in the loop above, so add this surface.
            pOut->m_nVerts = 3;
            pOut->m_Verts[0] = a;
            pOut->m_Verts[1] = b;
            pOut->m_Verts[2] = c;
            pOut->m_Plane.m_Normal = ( c - a ).Cross( b - a );
            VectorNormalize( pOut->m_Plane.m_Normal );
            pOut->m_Plane.m_Dist = pOut->m_Plane.m_Normal.Dot( a );

            ++pStruct->m_nSetInfos;
            ++pOut;
        }
    }
}
void C_BaseAnimatingOverlay::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
	BaseClass::GetRenderBounds( theMins, theMaxs );

	if ( !IsRagdoll() )
	{
		CStudioHdr *pStudioHdr = GetModelPtr();
		if ( !pStudioHdr || !pStudioHdr->SequencesAvailable() )
			return;

		int nSequences = pStudioHdr->GetNumSeq();

		int i;
		for (i = 0; i < m_AnimOverlay.Count(); i++)
		{
			if (m_AnimOverlay[i].m_flWeight > 0.0)
			{
				if ( m_AnimOverlay[i].m_nSequence >= nSequences )
				{
					continue;
				}

				mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( m_AnimOverlay[i].m_nSequence );
				VectorMin( seqdesc.bbmin, theMins, theMins );
				VectorMax( seqdesc.bbmax, theMaxs, theMaxs );
			}
		}
	}
}
Пример #4
0
void SetupDispBoxes( const CCoreDispInfo *pListBase, int listSize, CUtlVector<CDispBox> &out )
{
	out.SetSize( listSize );
	for ( int i=0; i < listSize; i++ )
	{
		const CCoreDispInfo *pDisp = &pListBase[i];

		// Calculate the bbox for this displacement.
		Vector vMin(  1e24,  1e24,  1e24 );
		Vector vMax( -1e24, -1e24, -1e24 );

		for ( int iVert=0; iVert < 4; iVert++ )
		{
			const Vector &vTest = pDisp->GetSurface()->GetPoint( iVert );
			VectorMin( vTest, vMin, vMin );
			VectorMax( vTest, vMax, vMax );
		}		

		// Puff the box out a little.
		static float flPuff = 0.1f;
		vMin -= Vector( flPuff, flPuff, flPuff );
		vMax += Vector( flPuff, flPuff, flPuff );

		out[i].m_Min = vMin;
		out[i].m_Max = vMax;
	}
}
Пример #5
0
//-----------------------------------------------------------------------------
// Computes the surrounding collision bounds from the current sequence box
//-----------------------------------------------------------------------------
void CCollisionProperty::ComputeRotationExpandedSequenceBounds( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
	CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
	if ( !pAnim )
	{
		ComputeOBBBounds( pVecWorldMins, pVecWorldMaxs );
		return;
	}

	Vector mins, maxs;
	pAnim->ExtractBbox( pAnim->GetSequence(), mins, maxs );

	float flRadius = MAX( MAX( FloatMakePositive( mins.x ), FloatMakePositive( maxs.x ) ),
					      MAX( FloatMakePositive( mins.y ), FloatMakePositive( maxs.y ) ) );
	mins.x = mins.y = -flRadius;
	maxs.x = maxs.y = flRadius;

	// Add bloat to account for gesture sequences
	Vector vecBloat( 6, 6, 0 );
	mins -= vecBloat;
	maxs += vecBloat;

	// NOTE: This is necessary because the server doesn't know how to blend
	// animations together. Therefore, we have to just pick a box that can
	// surround all of our potential sequences. This should be something we
	// should be able to compute @ tool time instead, however.
	VectorMin( mins, m_vecSurroundingMins, mins );
	VectorMax( maxs, m_vecSurroundingMaxs, maxs );

	VectorAdd( mins, GetCollisionOrigin(), *pVecWorldMins );
	VectorAdd( maxs, GetCollisionOrigin(), *pVecWorldMaxs );
}
Пример #6
0
//-----------------------------------------------------------------------------
// Compute position	+ bounding box
//-----------------------------------------------------------------------------
void CSpriteTrail::UpdateBoundingBox( void )
{
	Vector vecRenderOrigin = GetRenderOrigin();
	m_vecRenderMins = vecRenderOrigin;
	m_vecRenderMaxs = vecRenderOrigin;

	float flMaxWidth = m_flStartWidth;
	if (( m_flEndWidth >= 0.0f ) && ( m_flEndWidth > m_flStartWidth ))
	{
		flMaxWidth = m_flEndWidth;
	}

	Vector mins, maxs;
	for ( int i = 0; i < m_nStepCount; ++i )
	{
		TrailPoint_t *pPoint = GetTrailPoint(i);

		float flActualWidth = (flMaxWidth + pPoint->m_flWidthVariance) * 0.5f;
		Vector size( flActualWidth, flActualWidth, flActualWidth );
		VectorSubtract( pPoint->m_vecScreenPos, size, mins );
		VectorAdd( pPoint->m_vecScreenPos, size, maxs );
		
		VectorMin( m_vecRenderMins, mins, m_vecRenderMins ); 
		VectorMax( m_vecRenderMaxs, maxs, m_vecRenderMaxs ); 
	}
	
	m_vecRenderMins -= vecRenderOrigin; 
	m_vecRenderMaxs -= vecRenderOrigin;
}
Пример #7
0
void CRopeKeyframe::UpdateBBox( bool bForceRelink )
{
	Vector v1, v2;
	Vector vMin, vMax;
	if ( GetEndPointPos( 0, v1 ) )
	{
		if ( GetEndPointPos( 1, v2 ) )
		{
			VectorMin( v1, v2, vMin );
			VectorMax( v1, v2, vMax );

			// Set our bounds to enclose both endpoints and relink.
			vMin -= GetAbsOrigin();
			vMax -= GetAbsOrigin();
		}
		else
		{
			vMin = vMax = v1 - GetAbsOrigin();
		}
	}
	else
	{
		vMin = vMax = Vector( 0, 0, 0 );
	}

	if ( WorldAlignMins() != vMin || WorldAlignMaxs() != vMax )
	{
		UTIL_SetSize( this, vMin, vMax );
	}
}
Пример #8
0
void CBeam::RelinkBeam( void )
{
	// FIXME: Why doesn't this just define the absbox too?
	// It seems that we don't need to recompute the absbox
	// in CBaseEntity::SetObjectCollisionBox, in fact the absbox
	// computed there seems way too big
	Vector startPos = GetAbsStartPos(), endPos = GetAbsEndPos();

	Vector vecAbsExtra1, vecAbsExtra2;
	bool bUseExtraPoints = false;

#ifdef PORTAL
	CBaseEntity *pStartEntity = GetStartEntityPtr();
	
	CTraceFilterSkipClassname traceFilter( pStartEntity, "prop_energy_ball", COLLISION_GROUP_NONE );
	
	ITraceFilter *pEntityBeamTraceFilter = NULL;
	if ( pStartEntity )
		pEntityBeamTraceFilter = pStartEntity->GetBeamTraceFilter();

	CTraceFilterChain traceFilterChain( &traceFilter, pEntityBeamTraceFilter );

	bUseExtraPoints = UTIL_Portal_Trace_Beam( this, startPos, endPos, vecAbsExtra1, vecAbsExtra2, &traceFilterChain );
#endif

	// UNDONE: Should we do this to make the boxes smaller?
	//SetAbsOrigin( startPos );

	Vector vecBeamMin, vecBeamMax;
	VectorMin( startPos, endPos, vecBeamMin );
	VectorMax( startPos, endPos, vecBeamMax );

	if ( bUseExtraPoints )
	{
		VectorMin( vecBeamMin, vecAbsExtra1, vecBeamMin );
		VectorMin( vecBeamMin, vecAbsExtra2, vecBeamMin );
		VectorMax( vecBeamMax, vecAbsExtra1, vecBeamMax );
		VectorMax( vecBeamMax, vecAbsExtra2, vecBeamMax );
	}

	SetCollisionBounds( vecBeamMin - GetAbsOrigin(), vecBeamMax - GetAbsOrigin() );
}
Пример #9
0
TEST(DSPSingle, TestVectorMax)
{
    float signal[10] = {0.0, -1.0, -0.5, -0.3, 0.0, 1.0, 0.5, 0.3, 0.2, 0.1};
    float max = VectorMax(signal, 10);
    ASSERT_FLOAT_EQ(1.0, max);
    
    max = 0.0;
    unsigned index = 0;
    VectorMaxVI(&max, &index, signal, 10);
    ASSERT_FLOAT_EQ(1.0, max);
    ASSERT_EQ(5, index);
}
Пример #10
0
void CModelInfo::GetModelRenderBounds( const model_t *model, int sequence, Vector& mins, Vector& maxs ) const
{
	if (!model)
	{
		mins.Init(0,0,0);
		maxs.Init(0,0,0);
		return;
	}

	switch( model->type )
	{
	case mod_studio:
		{
			studiohdr_t *pStudioHdr = ( studiohdr_t * )modelloader->GetExtraData( (model_t*)model );
			Assert( pStudioHdr );

			// NOTE: We're not looking at the sequence box here, although we could
			if (!VectorCompare( vec3_origin, pStudioHdr->view_bbmin ))
			{
				// clipping bounding box
				VectorCopy ( pStudioHdr->view_bbmin, mins);
				VectorCopy ( pStudioHdr->view_bbmin, maxs);
			}
			else
			{
				// movement bounding box
				VectorCopy ( pStudioHdr->hull_min, mins);
				VectorCopy ( pStudioHdr->hull_max, maxs);
			}

			// construct the base bounding box for this frame
			if ( sequence >= pStudioHdr->numseq) 
			{
				sequence = 0;
			}

			mstudioseqdesc_t *pseqdesc = pStudioHdr->pSeqdesc( sequence );
			VectorMin( pseqdesc->bbmin, mins, mins );
			VectorMax( pseqdesc->bbmax, maxs, maxs );
		}
		break;

	case mod_brush:
		VectorCopy( model->mins, mins );
		VectorCopy( model->maxs, maxs );
		break;

	default:
		mins.Init( 0, 0, 0 );
		maxs.Init( 0, 0, 0 );
		break;
	}
}
Пример #11
0
//-----------------------------------------------------------------------------
// Purpose: Performs the actual partial rebuilds of the mesh, merging multiple
//			updates in one.
//-----------------------------------------------------------------------------
void CRecastMgr::UpdateRebuildPartial()
{
	if( !m_pendingPartialMeshUpdates.Count() )
		return;

	PartialMeshUpdate_t &curUpdate = m_pendingPartialMeshUpdates.Head();

	bool bDidMerge;
	int nTests = 0, nMerges = 0;
	do {
		bDidMerge = false;
		for( int i = m_pendingPartialMeshUpdates.Count() - 1; i >= 1; i-- )
		{
			if( IsBoxIntersectingBox( curUpdate.vMins, curUpdate.vMaxs,
				m_pendingPartialMeshUpdates[i].vMins, m_pendingPartialMeshUpdates[i].vMaxs ) )
			{
				curUpdate.vMins = VectorMin( curUpdate.vMins, m_pendingPartialMeshUpdates[i].vMins );
				curUpdate.vMaxs = VectorMax( curUpdate.vMaxs, m_pendingPartialMeshUpdates[i].vMaxs );
				m_pendingPartialMeshUpdates.Remove( i );
				bDidMerge = true;
				nMerges++;
			}
		}
		nTests++;
	} while( bDidMerge && nTests < 100 );

	if( recast_build_partial_debug.GetBool() && nMerges > 0 )
	{
		DevMsg( "CRecastMgr::UpdateRebuildPartial: Merged multiple updates (%d) into one\n", nMerges+1 );
	}

	// Load map mesh
	if( !LoadMapMesh( recast_build_partial_debug.GetBool(), true, curUpdate.vMins, curUpdate.vMaxs ) )
	{
		Warning( "CRecastMgr::UpdateRebuildPartial: failed to load map data!\n" );
		return;
	}

	// Perform the update
	CUtlVector<CRecastMesh *> meshesToBuild;
	for ( int i = m_Meshes.First(); i != m_Meshes.InvalidIndex(); i = m_Meshes.Next(i ) )
	{
		if( IsMeshBuildDisabled( m_Meshes[i]->GetName() ) )
			continue;
		meshesToBuild.AddToTail( m_Meshes[i] );
	}

	CParallelProcessor<CRecastMesh *, CFuncJobItemProcessor<CRecastMesh *>, 2 > processor;
	processor.m_ItemProcessor.Init( &ThreadedRebuildPartialMesh, &PreThreadedBuildMesh, &PostThreadedBuildMesh );
	processor.Run( meshesToBuild.Base(), meshesToBuild.Count(), 1, recast_build_numthreads.GetInt(), g_pThreadPool );

	m_pendingPartialMeshUpdates.Remove( 0 );
}
Пример #12
0
void CSheetSimulator::ComputeBounds( Vector& mins, Vector& maxs )
{
	VectorCopy( m_Particle[0].m_Position, mins );
	VectorCopy( m_Particle[0].m_Position, maxs );

	for (int i = 1; i < NumParticles(); ++i)
	{
		VectorMin( mins, m_Particle[i].m_Position, mins );
		VectorMax( maxs, m_Particle[i].m_Position, maxs );
	}
	mins -= m_Origin;
	maxs -= m_Origin;
}
Пример #13
0
int main(void)
{
	int i = 0;
	fractional *p_real = &sigCmpx[0].real ;
	fractcomplex *p_cmpx = &sigCmpx[0] ;


#ifndef FFTTWIDCOEFFS_IN_PROGMEM					/* Generate TwiddleFactor Coefficients */
	TwidFactorInit (LOG2_BLOCK_LENGTH, &twiddleFactors[0], 0);	/* We need to do this only once at start-up */
#endif

	for ( i = 0; i < FFT_BLOCK_LENGTH; i++ )/* The FFT function requires input data */
	{					/* to be in the fractional fixed-point range [-0.5, +0.5]*/
		*p_real = *p_real >>1 ;		/* So, we shift all data samples by 1 bit to the right. */
		*p_real++;			/* Should you desire to optimize this process, perform */
	}					/* data scaling when first obtaining the time samples */
						/* Or within the BitReverseComplex function source code */

	p_real = &sigCmpx[(FFT_BLOCK_LENGTH/2)-1].real ;	/* Set up pointers to convert real array */
	p_cmpx = &sigCmpx[FFT_BLOCK_LENGTH-1] ; /* to a complex array. The input array initially has all */
						/* the real input samples followed by a series of zeros */


	for ( i = FFT_BLOCK_LENGTH; i > 0; i-- ) /* Convert the Real input sample array */
	{					/* to a Complex input sample array  */
		(*p_cmpx).real = (*p_real--);	/* We will simpy zero out the imaginary  */
		(*p_cmpx--).imag = 0x0000;	/* part of each data sample */
	}

	/* Perform FFT operation */
#ifndef FFTTWIDCOEFFS_IN_PROGMEM
	FFTComplexIP (LOG2_BLOCK_LENGTH, &sigCmpx[0], &twiddleFactors[0], COEFFS_IN_DATA);
#else
	FFTComplexIP (LOG2_BLOCK_LENGTH, &sigCmpx[0], (fractcomplex *) __builtin_psvoffset(&twiddleFactors[0]), (int) __builtin_psvpage(&twiddleFactors[0]));
#endif

	/* Store output samples in bit-reversed order of their addresses */
	BitReverseComplex (LOG2_BLOCK_LENGTH, &sigCmpx[0]);

	/* Compute the square magnitude of the complex FFT output array so we have a Real output vetor */
	SquareMagnitudeCplx(FFT_BLOCK_LENGTH, &sigCmpx[0], &sigCmpx[0].real);

	/* Find the frequency Bin ( = index into the SigCmpx[] array) that has the largest energy*/
	/* i.e., the largest spectral component */
	VectorMax(FFT_BLOCK_LENGTH/2, &sigCmpx[0].real, &peakFrequencyBin);

	/* Compute the frequency (in Hz) of the largest spectral component */
	peakFrequency = peakFrequencyBin*(SAMPLING_RATE/FFT_BLOCK_LENGTH);

        while (1);	/* Place a breakpoint here and observe the watch window variables */
}
Пример #14
0
void CMapzoneEdit::Build(Vector *aimpos, int type, int forcestage)
{
    if (mom_zone_grid.GetInt() > 0)
        VectorSnapToGrid(aimpos, (float) mom_zone_grid.GetInt());


    switch ((forcestage != BUILDSTAGE_NONE) ? forcestage : ++m_nBuildStage)
    {
    case BUILDSTAGE_START:
        m_vecBuildStart = *aimpos;
        break;

    case BUILDSTAGE_END:
        m_vecBuildEnd = *aimpos;
        break;

    case BUILDSTAGE_HEIGHT:
    {
        char szClass[64];
        if (ZoneTypeToClass(type, szClass))
        {
            CBaseEntity *pEnt = CreateEntityByName(szClass);
            Vector vecOrigin, vecSize, vecMinsRel;
            int i;

            VectorMin(m_vecBuildStart, m_vecBuildEnd, vecMinsRel);
            VectorMax(m_vecBuildStart, m_vecBuildEnd, vecSize);

            for (i = 0; i < 3; i++)
                vecSize[i] = (vecSize[i] - vecMinsRel[i]) / 2.0f;

            for (i = 0; i < 3; i++)
                vecOrigin[i] = vecMinsRel[i] + vecSize[i];

            pEnt->Spawn();

            pEnt->SetAbsOrigin(vecOrigin);
            pEnt->SetSize(Vector(-vecSize.x, -vecSize.y, -vecSize.z), vecSize);
            pEnt->SetEffects(EF_NODRAW);
            pEnt->SetSolid(SOLID_BBOX);

            pEnt->Activate();

            SetZoneProps(pEnt);
        }
    }
    default:
        m_nBuildStage = BUILDSTAGE_NONE;
    }
}
Пример #15
0
//-----------------------------------------------------------------------------
// bounding box for collision
//-----------------------------------------------------------------------------
void CShieldEffect::ComputeBounds( Vector& mins, Vector& maxs )
{
	VectorCopy( m_pControlPoint[0], mins );
	VectorCopy( m_pControlPoint[0], maxs );

	for (int i = 1; i < SHIELD_NUM_CONTROL_POINTS; ++i)
	{
		VectorMin( mins, m_pControlPoint[i], mins );
		VectorMax( maxs, m_pControlPoint[i], maxs );
	}

	// Bounds are in local coords
	mins -= m_Position;
	maxs -= m_Position;
}
Пример #16
0
        inline bool IntersectWithLine( const Vector3& rayOrigin, Vector3 rayDirection, float &distanceToFrontCollisionOfCube , float &distanceToBackCollisionOfCube ) const
        {
            rayDirection.x = ( rayDirection.x == 0.f ) ? 0.0000001f : rayDirection.x;
            rayDirection.y = ( rayDirection.y == 0.f ) ? 0.0000001f : rayDirection.y;
            rayDirection.z = ( rayDirection.z == 0.f ) ? 0.0000001f : rayDirection.z;
        	Vector3 divisor = 1.f / rayDirection;
        	Vector3 oMin = (m_Min - rayOrigin) * divisor;
        	Vector3 oMax = (m_Max - rayOrigin) * divisor;
        	Vector3 bMax = VectorMax(oMax, oMin);
        	Vector3 bMin = VectorMin(oMax, oMin);
        	distanceToBackCollisionOfCube   = getMinimum(bMax.x, bMax.y, bMax.z);
        	distanceToBackCollisionOfCube   = getMinimum(bMax.x, bMax.y, bMax.z);
        	distanceToFrontCollisionOfCube = getMaximum(bMin.x, 0.0f, bMin.y, bMin.z );

        	return distanceToBackCollisionOfCube > distanceToFrontCollisionOfCube;
        }
Пример #17
0
void CBeam::RelinkBeam( void )
{
	// FIXME: Why doesn't this just define the absbox too?
	// It seems that we don't need to recompute the absbox
	// in CBaseEntity::SetObjectCollisionBox, in fact the absbox
	// computed there seems way too big
	const Vector &startPos = GetAbsStartPos(), &endPos = GetAbsEndPos();

	// UNDONE: Should we do this to make the boxes smaller?
	//SetAbsOrigin( startPos );

	Vector vecBeamMin, vecBeamMax;
	VectorMin( startPos, endPos, vecBeamMin );
	VectorMax( startPos, endPos, vecBeamMax );

	SetCollisionBounds( vecBeamMin - GetAbsOrigin(), vecBeamMax - GetAbsOrigin() );
}
Пример #18
0
void CDispInfo::ApplyTerrainMod( ITerrainMod *pMod )
{
    // New bbox.
    Vector bbMin(  1e24,  1e24,  1e24 );
    Vector bbMax( -1e24, -1e24, -1e24 );

    int nVerts, nIndices;
    CalcMaxNumVertsAndIndices( m_Power, &nVerts, &nIndices );

    // Ok, it probably touches us. Lock our buffer and change the verts.
    CMeshBuilder mb;
    mb.BeginModify( m_pMesh->m_pMesh, m_iVertOffset, nVerts );

    for( int iVert=0; iVert < nVerts; iVert++ )
    {
        if( m_AllowedVerts.Get( iVert ) )
        {
            Vector &vPos = m_Verts[iVert].m_vPos;
            Vector &vOriginalPos = m_Verts[iVert].m_vOriginalPos;

            if( pMod->ApplyMod( vPos, vOriginalPos ) )
                mb.Position3f( VectorExpand( vPos ) );

            VectorMin( vPos, bbMin, bbMin );
            VectorMax( vPos, bbMax, bbMax );
        }

        mb.AdvanceVertex();
    }

    mb.EndModify();

    // Set our new bounding box.
    m_BBoxMin = bbMin;
    m_BBoxMax = bbMax;
    UpdateCenterAndRadius();

    // Next time this displacement is seen, force it to rebuild and retesselate.
    m_bForceRebuild = true;
}
Пример #19
0
//-----------------------------------------------------------------------------
// compute rest positions of the springs
//-----------------------------------------------------------------------------
void CShieldEffect::ComputeRestPositions()
{
	int i;

	m_vecRenderMins.Init( FLT_MAX, FLT_MAX, FLT_MAX );
	m_vecRenderMaxs.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );

	// Set the initial directions and distances (in shield space)...
	for	( i = 0; i < SHIELD_NUM_VERTICAL_POINTS; ++i)
	{
		// Choose phi centered at pi/2
		float phi = (M_PI - m_ShieldPhi) * 0.5f + m_ShieldPhi * 
			(float)i / (float)(SHIELD_NUM_VERTICAL_POINTS - 1);

		for (int j = 0; j < SHIELD_NUM_HORIZONTAL_POINTS; ++j)
		{
			// Choose theta centered at pi/2 also (y, or forward axis)
			float theta = (M_PI - m_ShieldTheta) * 0.5f + m_ShieldTheta * 
				(float)j / (float)(SHIELD_NUM_HORIZONTAL_POINTS - 1);

			int idx = i * SHIELD_NUM_HORIZONTAL_POINTS + j;

			m_pFixedDirection[idx].x = cos(theta) * sin(phi);
			m_pFixedDirection[idx].y = sin(theta) * sin(phi);
			m_pFixedDirection[idx].z = cos(phi);

			m_pFixedDirection[idx] *= m_RestLength;

			VectorMin( m_vecRenderMins, m_pFixedDirection[idx], m_vecRenderMins );
			VectorMax( m_vecRenderMaxs, m_pFixedDirection[idx], m_vecRenderMaxs );
		}
	}

	// Compute box for fake volume testing
	Vector dist = m_pFixedDirection[0] - m_pFixedDirection[1];
	float l = dist.Length(); // * m_RestLength;
	SetShieldPanelSize( Vector( -l * 0.25f, -l * 0.25f, -l * 0.25f), 
		Vector( l * 0.25f, l * 0.25f, l * 0.25f) );
}
Пример #20
0
void C_NPC_Surface::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
	// BaseClass::GetRenderBounds( theMins, theMaxs );
	if(sv_surface_testshape.GetBool())
	{
		theMins.Init(-300.0f, 0.0f, 100.0f);
		theMaxs.Init(0.0f, 100.0f, 200.0f);
	}
	else
	{
		theMins = m_vecSurfacePos[0];
		theMaxs = m_vecSurfacePos[0];
		float surfaceRadius = m_flRadius * 3.0f;
		for (int i = 0; i < m_nActiveParticles; i++)
		{
			VectorMin( m_vecSurfacePos[i] - Vector( surfaceRadius, surfaceRadius, surfaceRadius ), theMins, theMins );
			VectorMax( m_vecSurfacePos[i] + Vector( surfaceRadius, surfaceRadius, surfaceRadius ), theMaxs, theMaxs );
		}
	}
	theMins -= GetRenderOrigin();
	theMaxs -= GetRenderOrigin();

	#if 0
	Vector avg = (theMins + theMaxs) * 0.5f;
	theMins = theMins - ((theMins - avg) * 0.75f);
	theMaxs = theMaxs - ((theMaxs - avg) * 0.75f);
	#endif

	#if 0
	Vector fountainOrigin(-1980, -1792, 1);
	theMins = fountainOrigin + Vector(-10, -10, -20);
	theMaxs = fountainOrigin + Vector(10, 10, 50);
	#endif

	// Msg( "origin  %.2f %.2f %.2f : mins %.2f %.2f %.2f  : maxs %.2f %.2f %.2f\n", GetRenderOrigin().x, GetRenderOrigin().y, GetRenderOrigin().z, theMins.x, theMins.y, theMins.z, theMaxs.x, theMaxs.y, theMaxs.z );

	//debugoverlay->AddBoxOverlay( GetRenderOrigin(), theMins, theMaxs, QAngle( 0, 0, 0 ), 0, 255, 0, 0, 0 );
}
Пример #21
0
//-----------------------------------------------------------------------------
// Returns the bounding box for the model
//-----------------------------------------------------------------------------
void CDmeMDL::GetBoundingBox( Vector *pMins, Vector *pMaxs ) const
{
	if ( !g_pMaterialSystem || !g_pMDLCache || !g_pStudioRender )
	{
		pMins->Init();
		pMaxs->Init();
		return;
	}

	if ( m_MDLHandle == MDLHANDLE_INVALID )
	{
		pMins->Init();
		pMaxs->Init();
		return;
	}

	pMins->Init( FLT_MAX, FLT_MAX );
	pMaxs->Init( -FLT_MAX, -FLT_MAX );

	studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( m_MDLHandle );
	if ( !VectorCompare( vec3_origin, pStudioHdr->view_bbmin ) || !VectorCompare( vec3_origin, pStudioHdr->view_bbmax ))
	{
		// look for view clip
		*pMins = pStudioHdr->view_bbmin;
		*pMaxs = pStudioHdr->view_bbmax;
	}
	else if ( !VectorCompare( vec3_origin, pStudioHdr->hull_min ) || !VectorCompare( vec3_origin, pStudioHdr->hull_max ))
	{
		// look for hull
		*pMins = pStudioHdr->hull_min;
		*pMaxs = pStudioHdr->hull_max;
	}

	// Else use the sequence box
	mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( m_nSequence );
	VectorMin( seqdesc.bbmin, *pMins, *pMins );
	VectorMax( seqdesc.bbmax, *pMaxs, *pMaxs );
}
Пример #22
0
//-----------------------------------------------------------------------------
// Expand trigger bounds..
//-----------------------------------------------------------------------------
void CCollisionProperty::ComputeVPhysicsSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
	bool bSetBounds = false;
	IPhysicsObject *pPhysicsObject = GetOuter()->VPhysicsGetObject();
	if ( pPhysicsObject )
	{
		if ( pPhysicsObject->GetCollide() )
		{
			physcollision->CollideGetAABB( pVecWorldMins, pVecWorldMaxs, 
				pPhysicsObject->GetCollide(), GetCollisionOrigin(), GetCollisionAngles() );
			bSetBounds = true;
		}
		else if ( pPhysicsObject->GetSphereRadius( ) )
		{
			float flRadius = pPhysicsObject->GetSphereRadius( );
			Vector vecExtents( flRadius, flRadius, flRadius );
			VectorSubtract( GetCollisionOrigin(), vecExtents, *pVecWorldMins );
			VectorAdd( GetCollisionOrigin(), vecExtents, *pVecWorldMaxs );
			bSetBounds = true;
		}
	}

	if ( !bSetBounds )
	{
		*pVecWorldMins = GetCollisionOrigin();
		*pVecWorldMaxs = *pVecWorldMins;
	}

	// Also, lets expand for the trigger bounds also
	if ( IsSolidFlagSet( FSOLID_USE_TRIGGER_BOUNDS ) )
	{
		Vector vecWorldTriggerMins, vecWorldTriggerMaxs;
		WorldSpaceTriggerBounds( &vecWorldTriggerMins, &vecWorldTriggerMaxs );
		VectorMin( vecWorldTriggerMins, *pVecWorldMins, *pVecWorldMins );
		VectorMax( vecWorldTriggerMaxs, *pVecWorldMaxs, *pVecWorldMaxs );
	}
}
Пример #23
0
bool CAnimating::ComputeHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
	// Note that this currently should not be called during Relink because of IK.
	// The code below recomputes bones so as to get at the hitboxes,
	// which causes IK to trigger, which causes raycasts against the other entities to occur,
	// which is illegal to do while in the Relink phase.

	CStudioHdr *pStudioHdr = GetModelPtr();
	if (!pStudioHdr)
		return false;

	mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( m_nHitboxSet );
	if ( !set || !set->numhitboxes )
		return false;

	CBoneCache *pCache = GetBoneCache();

	// Compute a box in world space that surrounds this entity
	pVecWorldMins->Init( FLT_MAX, FLT_MAX, FLT_MAX );
	pVecWorldMaxs->Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );

	Vector vecBoxAbsMins, vecBoxAbsMaxs;
	for ( int i = 0; i < set->numhitboxes; i++ )
	{
		mstudiobbox_t *pbox = set->pHitbox(i);
		matrix3x4_t *pMatrix = pCache->GetCachedBone(pbox->bone);

		if ( pMatrix )
		{
			TransformAABB( *pMatrix, pbox->bbmin, pbox->bbmax, vecBoxAbsMins, vecBoxAbsMaxs );
			VectorMin( *pVecWorldMins, vecBoxAbsMins, *pVecWorldMins );
			VectorMax( *pVecWorldMaxs, vecBoxAbsMaxs, *pVecWorldMaxs );
		}
	}
	return true;
}
Пример #24
0
bool CGutModel::LoadMesh_ASCII(void)
{
	char szBuffer[128];
	char sz_Tag[64];

	fgets(szBuffer, 128, m_pFile); // {
	fgets(szBuffer, 128, m_pFile); // meshes n
	sscanf(szBuffer, "%s %d", sz_Tag, &m_iNumMeshes);

	m_iNumFaces = 0;
	m_iNumVertices = 0;

	m_pMeshArray = new sModelMesh[m_iNumMeshes];
	if ( m_pMeshArray==NULL )
		return false;

	m_vMin.Set(FLT_MAX);
	m_vMax.Set(-FLT_MAX);

	for ( int i=0; i<m_iNumMeshes; i++ )
	{
		printf("Loading mesh %d/%d\n", i+1, m_iNumMeshes);

		m_pMeshArray[i].Load_ASCII(m_pFile);

		m_iNumFaces += m_pMeshArray[i].m_iNumFaces;
		m_iNumVertices += m_pMeshArray[i].m_iNumVertices;

		m_vMin = VectorMin(m_vMin, m_pMeshArray[i].m_vMin);
		m_vMax = VectorMax(m_vMax, m_pMeshArray[i].m_vMax);
	}

	fgets(szBuffer, 128, m_pFile); // }

	return true;
}
Пример #25
0
float
vu_peak(float* signal, unsigned n_samples, MeterScale scale)
{
    float peak = VectorMax(signal, n_samples);
    return 20.0 * log10f(peak / ref[scale]);
}
Пример #26
0
FBox FBox::TransformBy(const FMatrix& M) const
{
	// if we are not valid, return another invalid box.
	if (!IsValid)
	{
		return FBox(0);
	}

	VectorRegister Vertices[8];

	VectorRegister m0 = VectorLoadAligned(M.M[0]);
	VectorRegister m1 = VectorLoadAligned(M.M[1]);
	VectorRegister m2 = VectorLoadAligned(M.M[2]);
	VectorRegister m3 = VectorLoadAligned(M.M[3]);

	Vertices[0] = VectorLoadFloat3(&Min);
	Vertices[1] = VectorSetFloat3(Min.X, Min.Y, Max.Z);
	Vertices[2] = VectorSetFloat3(Min.X, Max.Y, Min.Z);
	Vertices[3] = VectorSetFloat3(Max.X, Min.Y, Min.Z);
	Vertices[4] = VectorSetFloat3(Max.X, Max.Y, Min.Z);
	Vertices[5] = VectorSetFloat3(Max.X, Min.Y, Max.Z);
	Vertices[6] = VectorSetFloat3(Min.X, Max.Y, Max.Z);
	Vertices[7] = VectorLoadFloat3(&Max);

	VectorRegister r0 = VectorMultiply(VectorReplicate(Vertices[0],0), m0);
	VectorRegister r1 = VectorMultiply(VectorReplicate(Vertices[1],0), m0);
	VectorRegister r2 = VectorMultiply(VectorReplicate(Vertices[2],0), m0);
	VectorRegister r3 = VectorMultiply(VectorReplicate(Vertices[3],0), m0);
	VectorRegister r4 = VectorMultiply(VectorReplicate(Vertices[4],0), m0);
	VectorRegister r5 = VectorMultiply(VectorReplicate(Vertices[5],0), m0);
	VectorRegister r6 = VectorMultiply(VectorReplicate(Vertices[6],0), m0);
	VectorRegister r7 = VectorMultiply(VectorReplicate(Vertices[7],0), m0);

	r0 = VectorMultiplyAdd( VectorReplicate(Vertices[0],1), m1, r0);
	r1 = VectorMultiplyAdd( VectorReplicate(Vertices[1],1), m1, r1);
	r2 = VectorMultiplyAdd( VectorReplicate(Vertices[2],1), m1, r2);
	r3 = VectorMultiplyAdd( VectorReplicate(Vertices[3],1), m1, r3);
	r4 = VectorMultiplyAdd( VectorReplicate(Vertices[4],1), m1, r4);
	r5 = VectorMultiplyAdd( VectorReplicate(Vertices[5],1), m1, r5);
	r6 = VectorMultiplyAdd( VectorReplicate(Vertices[6],1), m1, r6);
	r7 = VectorMultiplyAdd( VectorReplicate(Vertices[7],1), m1, r7);

	r0 = VectorMultiplyAdd( VectorReplicate(Vertices[0],2), m2, r0);
	r1 = VectorMultiplyAdd( VectorReplicate(Vertices[1],2), m2, r1);
	r2 = VectorMultiplyAdd( VectorReplicate(Vertices[2],2), m2, r2);
	r3 = VectorMultiplyAdd( VectorReplicate(Vertices[3],2), m2, r3);
	r4 = VectorMultiplyAdd( VectorReplicate(Vertices[4],2), m2, r4);
	r5 = VectorMultiplyAdd( VectorReplicate(Vertices[5],2), m2, r5);
	r6 = VectorMultiplyAdd( VectorReplicate(Vertices[6],2), m2, r6);
	r7 = VectorMultiplyAdd( VectorReplicate(Vertices[7],2), m2, r7);

	r0 = VectorAdd(r0, m3);
	r1 = VectorAdd(r1, m3);
	r2 = VectorAdd(r2, m3);
	r3 = VectorAdd(r3, m3);
	r4 = VectorAdd(r4, m3);
	r5 = VectorAdd(r5, m3);
	r6 = VectorAdd(r6, m3);
	r7 = VectorAdd(r7, m3);

	FBox NewBox;
	
	VectorRegister min0 = VectorMin(r0, r1);
	VectorRegister min1 = VectorMin(r2, r3);
	VectorRegister min2 = VectorMin(r4, r5);
	VectorRegister min3 = VectorMin(r6, r7);
	VectorRegister max0 = VectorMax(r0, r1);
	VectorRegister max1 = VectorMax(r2, r3);
	VectorRegister max2 = VectorMax(r4, r5);
	VectorRegister max3 = VectorMax(r6, r7);
	
	min0 = VectorMin(min0, min1);
	min1 = VectorMin(min2, min3);
	max0 = VectorMax(max0, max1);
	max1 = VectorMax(max2, max3);
	min0 = VectorMin(min0, min1);
	max0 = VectorMax(max0, max1);

	VectorStoreFloat3(min0, &NewBox.Min);
	VectorStoreFloat3(max0, &NewBox.Max);

	NewBox.IsValid = 1;

	return NewBox;
}
Пример #27
0
void sModelMesh::Load_ASCII(FILE *pFile)
{
	const int BufferSize = 256;
	char szBuffer[BufferSize];
	char sz_Tag[BufferSize];
	char sz_Content[BufferSize];
	int i,j;
	fgets(szBuffer, BufferSize, pFile); // {

	fgets(szBuffer, BufferSize, pFile); // matrix
	fgets(szBuffer, BufferSize, pFile); // {
	for ( int r=0; r<4; r++ )
	{
		fgets(szBuffer, BufferSize, pFile); // x,y,z
		sscanf(szBuffer, "%f,%f,%f", &m_Matrix[r][0], &m_Matrix[r][1], &m_Matrix[r][2]);
	}
	fgets(szBuffer, BufferSize, pFile); // }

	fgets(szBuffer, BufferSize, pFile); // buffers n
	sscanf(szBuffer, "%s %d", sz_Tag, &m_iNumVertexChunks);

	m_iNumFaces = 0;
	m_iNumVertices = 0;

	m_vMin.Set(FLT_MAX);
	m_vMax.Set(-FLT_MAX);

	if ( m_iNumVertexChunks )
	{
		m_pVertexChunks = new sModelVertexChunk[m_iNumVertexChunks];
		for ( i=0; i<m_iNumVertexChunks; i++ )
		{
			fgets(szBuffer, BufferSize, pFile); // {

			sModelVertexChunk *pBuffer = m_pVertexChunks + i;
			fgets(szBuffer, BufferSize, pFile); // vertices n
			sscanf(szBuffer, "%s %d", sz_Tag, &pBuffer->m_iNumVertices);
			fgets(szBuffer, BufferSize, pFile); // format
			sscanf(szBuffer, "%s %s", sz_Tag, sz_Content);
			fgets(szBuffer, BufferSize, pFile); // {

			m_iNumVertices += pBuffer->m_iNumVertices;

			bool bVertex = false;
			bool bNormal = false;
			bool bColor = false;
			bool bTangentSpace = false;
			int  iNumUVs = 0;
			int  strLen = strlen(sz_Content);

			for ( int s=0; s<strLen; s++ )
			{
				switch(sz_Content[s])
				{
				case 'v':
					bVertex = true;
					break;
				case 'n':
					bNormal = true;
					break;
				case 'c':
					bColor = true;
					break;
				case 't':
					iNumUVs = sz_Content[++s] - '0';
					break;
				case '_':
					break;
				case 'p':
				case 'q':
					bTangentSpace = true;
					break;
				default:
					break;
				}
			}

			int vsize = 0;
			if ( bVertex )
			{
				pBuffer->m_VertexDecl.m_iPositionOffset = vsize;
				pBuffer->m_VertexDecl.m_iNumPositionElements = 3;
				vsize += 4*3;
			}

			if ( bNormal )
			{
				pBuffer->m_VertexDecl.m_iNormalOffset = vsize;
				pBuffer->m_VertexDecl.m_iNumNormalElements = 3;
				vsize += 4*3;
			}

			if ( bColor )
			{
				pBuffer->m_VertexDecl.m_iColorOffset = vsize;
				pBuffer->m_VertexDecl.m_iNumColorElements = 4;
				vsize += 4;
			}

			for ( j=0; j<iNumUVs; j++ )
			{
				pBuffer->m_VertexDecl.m_iTexcoordOffset[j] = vsize;
				pBuffer->m_VertexDecl.m_iNumTexcoordElements[j] = 2;
				vsize += 4*2;
			}

			if ( bTangentSpace )
			{
				pBuffer->m_VertexDecl.m_iTangentOffset = vsize;
				pBuffer->m_VertexDecl.m_iNumTangentElements = 3;
				vsize += 4 * 3;

				pBuffer->m_VertexDecl.m_iBiNormalOffset = vsize;
				pBuffer->m_VertexDecl.m_iBiNormalElements = 3;
				vsize += 4 * 3;
			}

			if ( vsize==0 )
			{
				int a=0;
			}

			pBuffer->m_VertexDecl.m_iVertexSize = vsize;

			if ( pBuffer->m_iNumVertices )
			{
				pBuffer->m_pVertexArray = new sModelVertex[pBuffer->m_iNumVertices];
			}

			printf(".");

			for ( j=0; j<pBuffer->m_iNumVertices; j++ )
			{
				sModelVertex *pVertex = pBuffer->m_pVertexArray + j;

				Vector4 &position = pVertex->m_Position;
				Vector4 &normal = pVertex->m_Normal;
				Vector4 &color = pVertex->m_Color;
				Vector4 *pUV = pVertex->m_Texcoord;
				Vector4 &tangent = pVertex->m_Tangent;
				Vector4 &binormal = pVertex->m_BiNormal;

				fgets(szBuffer, BufferSize, pFile);
				char *pLoc = szBuffer;

				if ( bVertex )
				{
					pLoc = strstr(pLoc, " ");
					sscanf(pLoc, "%f,%f,%f", &position[0], &position[1], &position[2]);
					position[3] = 1.0f;

					m_vMin = VectorMin(m_vMin, position);
					m_vMax = VectorMax(m_vMax, position);
				}

				if ( bNormal )
				{
					pLoc = strstr(pLoc+1, " ");
					pLoc = strstr(pLoc+1, " ");
					sscanf(pLoc, "%f,%f,%f", &normal[0], &normal[1], &normal[2]);
					normal[3] = 1.0f;
				}

				if ( bColor )
				{
					pLoc = strstr(pLoc+1, " ");
					pLoc = strstr(pLoc+1, " ");
					sscanf(pLoc, "%f,%f,%f,%f", &color[0], &color[1], &color[2], &color[3]);
				}

				for ( int t=0; t<iNumUVs && t<MAX_TEXCOORDS; t++ )
				{
					pLoc = strstr(pLoc+1, " ");
					pLoc = strstr(pLoc+1, " ");
					sscanf(pLoc, "%f,%f", &pUV[t][0], &pUV[t][1]);
				}

				if ( bTangentSpace )
				{
					pLoc = strstr(pLoc+1, " ");
					pLoc = strstr(pLoc+1, " ");
					sscanf(pLoc, "%f,%f,%f", &tangent[0], &tangent[1], &tangent[2]);

					pLoc = strstr(pLoc+1, " ");
					pLoc = strstr(pLoc+1, " ");
					sscanf(pLoc, "%f,%f,%f", &binormal[0], &binormal[1], &binormal[2]);
				}

				if ( (j & 0xff)==0 )
					printf(".");
			}

			fgets(szBuffer, BufferSize, pFile); // }

			fgets(szBuffer, BufferSize, pFile); // triangle_list_indices n
			sscanf(szBuffer, "%s %d", sz_Tag, &pBuffer->m_iNumIndices);
			if ( pBuffer->m_iNumIndices )
				pBuffer->m_pIndexArray = new unsigned short[pBuffer->m_iNumIndices];
			fgets(szBuffer, BufferSize, pFile); // {
			for ( j=0; j<pBuffer->m_iNumIndices/3; j++ )
			{
				int a,b,c;
				fgets(szBuffer, BufferSize, pFile);
				sscanf(szBuffer, "%d %d %d", &a, &b, &c);
				unsigned short *p = pBuffer->m_pIndexArray + j*3;
				p[0] = a; p[1] = b; p[2] = c;
			}
			fgets(szBuffer, BufferSize, pFile); // }

			fgets(szBuffer, BufferSize, pFile); // batches n
			sscanf(szBuffer, "%s %d", sz_Tag, &pBuffer->m_iNumBatches);
			if ( pBuffer->m_iNumBatches )
				pBuffer->m_pBatchArray = new sModelBatch[pBuffer->m_iNumBatches];
			fgets(szBuffer, BufferSize, pFile); // {
			for ( j=0; j<pBuffer->m_iNumBatches; j++ )
			{
				sModelBatch *pBatch = pBuffer->m_pBatchArray + j;

				fgets(szBuffer, BufferSize, pFile); // material n
				sscanf(szBuffer, "%s %d", sz_Tag, &pBatch->m_iMaterialID);
				fgets(szBuffer, BufferSize, pFile); // faces n
				sscanf(szBuffer, "%s %d", sz_Tag, &pBatch->m_iNumPrimitives);
				fgets(szBuffer, BufferSize, pFile); // index_begin n
				sscanf(szBuffer, "%s %d", sz_Tag, &pBatch->m_iIndexArrayBegin);

				pBatch->m_iNumIndices = pBatch->m_iNumPrimitives * 3;
				pBatch->m_iIndexArrayEnd = pBatch->m_iIndexArrayBegin + pBatch->m_iNumIndices;

				m_iNumFaces += pBatch->m_iNumPrimitives;
			}
			fgets(szBuffer, BufferSize, pFile); // }

			fgets(szBuffer, BufferSize, pFile); // }
		}
	}

	printf(".\n");
	fgets(szBuffer, BufferSize, pFile); // }
}
Пример #28
0
//-----------------------------------------------------------------------------
// Emits occluder brushes
//-----------------------------------------------------------------------------
static void EmitOccluderBrushes()
{
	char str[64];

	g_OccluderData.RemoveAll();
	g_OccluderPolyData.RemoveAll();
	g_OccluderVertexIndices.RemoveAll();

	tree_t *pOccluderTree = ClipOccluderBrushes();
	if (!pOccluderTree)
		return;

	CUtlVector<face_t*> faceList( 1024, 1024 );
	CUtlVector<side_t*> sideList( 1024, 1024 );
	GenerateOccluderFaceList( pOccluderTree->headnode, faceList );

#ifdef _DEBUG
	int *pEmitted = (int*)stackalloc( faceList.Count() * sizeof(int) );
	memset( pEmitted, 0, faceList.Count() * sizeof(int) );
#endif

	for ( entity_num=1; entity_num < num_entities; ++entity_num )
	{
		if (!IsFuncOccluder(entity_num))
			continue;

		// Output only those parts of the occluder tree which are a part of the brush
		int nOccluder = g_OccluderData.AddToTail();
		doccluderdata_t &occluderData = g_OccluderData[ nOccluder ];
		occluderData.firstpoly = g_OccluderPolyData.Count();
		occluderData.mins.Init( FLT_MAX, FLT_MAX, FLT_MAX );
		occluderData.maxs.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );
		occluderData.flags = 0;
		occluderData.area = -1;

		// NOTE: If you change the algorithm by which occluder numbers are allocated,
		// then you must also change FixupOnlyEntsOccluderEntities() below
		sprintf (str, "%i", nOccluder);
		SetKeyValue (&entities[entity_num], "occludernumber", str);

		int nIndex = g_OccluderInfo.AddToTail();
		g_OccluderInfo[nIndex].m_nOccluderEntityIndex = entity_num;
		
		sideList.RemoveAll();
		GenerateOccluderSideList( entity_num, sideList );
		for ( int i = faceList.Count(); --i >= 0; )
		{
			// Skip nodraw surfaces, but not triggers that have been marked as nodraw
			face_t *f = faceList[i];
			if ( ( texinfo[f->texinfo].flags & SURF_NODRAW ) &&
				 (( texinfo[f->texinfo].flags & SURF_TRIGGER ) == 0 ) )
				continue;

			// Only emit faces that appear in the side list of the occluder
			for ( int j = sideList.Count(); --j >= 0; )
			{
				if ( sideList[j] != f->originalface )
					continue;

				if ( f->numpoints < 3 )
					continue;

				// not a final face
				Assert ( !f->merged && !f->split[0] && !f->split[1] );

#ifdef _DEBUG
				Assert( !pEmitted[i] );
				pEmitted[i] = entity_num;
#endif

				int k = g_OccluderPolyData.AddToTail();
				doccluderpolydata_t *pOccluderPoly = &g_OccluderPolyData[k];

				pOccluderPoly->planenum = f->planenum;
				pOccluderPoly->vertexcount = f->numpoints;
				pOccluderPoly->firstvertexindex = g_OccluderVertexIndices.Count();
				for( k = 0; k < f->numpoints; ++k )
				{
					g_OccluderVertexIndices.AddToTail( f->vertexnums[k] );

					const Vector &p = dvertexes[f->vertexnums[k]].point; 
					VectorMin( occluderData.mins, p, occluderData.mins );
					VectorMax( occluderData.maxs, p, occluderData.maxs );
				}

				break;
			}
		}

		occluderData.polycount = g_OccluderPolyData.Count() - occluderData.firstpoly;

		// Mark this brush as not having brush geometry so it won't be re-emitted with a brush model
		entities[entity_num].numbrushes = 0;
	}

	FreeTree( pOccluderTree );
}
Пример #29
0
void C_EnvProjectedTexture::UpdateLight( void )
{
	VPROF("C_EnvProjectedTexture::UpdateLight");
	bool bVisible = true;

	Vector vLinearFloatLightColor( m_LightColor.r, m_LightColor.g, m_LightColor.b );
	float flLinearFloatLightAlpha = m_LightColor.a;

	if ( m_bAlwaysUpdate )
	{
		m_bForceUpdate = true;
	}

	if ( m_CurrentLinearFloatLightColor != vLinearFloatLightColor || m_flCurrentLinearFloatLightAlpha != flLinearFloatLightAlpha )
	{
		float flColorTransitionSpeed = gpGlobals->frametime * m_flColorTransitionTime * 255.0f;

		m_CurrentLinearFloatLightColor.x = Approach( vLinearFloatLightColor.x, m_CurrentLinearFloatLightColor.x, flColorTransitionSpeed );
		m_CurrentLinearFloatLightColor.y = Approach( vLinearFloatLightColor.y, m_CurrentLinearFloatLightColor.y, flColorTransitionSpeed );
		m_CurrentLinearFloatLightColor.z = Approach( vLinearFloatLightColor.z, m_CurrentLinearFloatLightColor.z, flColorTransitionSpeed );
		m_flCurrentLinearFloatLightAlpha = Approach( flLinearFloatLightAlpha, m_flCurrentLinearFloatLightAlpha, flColorTransitionSpeed );

		m_bForceUpdate = true;
	}
	
	if ( !m_bForceUpdate )
	{
		bVisible = IsBBoxVisible();		
	}

	if ( m_bState == false || !bVisible )
	{
		// Spotlight's extents aren't in view
		ShutDownLightHandle();

		return;
	}

	if ( m_LightHandle == CLIENTSHADOW_INVALID_HANDLE || m_hTargetEntity != NULL || m_bForceUpdate )
	{
		Vector vForward, vRight, vUp, vPos = GetAbsOrigin();
		FlashlightState_t state;

		if ( m_hTargetEntity != NULL )
		{
			if ( m_bCameraSpace )
			{
				const QAngle &angles = GetLocalAngles();

				C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
				if( pPlayer )
				{
					const QAngle playerAngles = pPlayer->GetAbsAngles();

					Vector vPlayerForward, vPlayerRight, vPlayerUp;
					AngleVectors( playerAngles, &vPlayerForward, &vPlayerRight, &vPlayerUp );

					matrix3x4_t	mRotMatrix;
					AngleMatrix( angles, mRotMatrix );

					VectorITransform( vPlayerForward, mRotMatrix, vForward );
					VectorITransform( vPlayerRight, mRotMatrix, vRight );
					VectorITransform( vPlayerUp, mRotMatrix, vUp );

					float dist = (m_hTargetEntity->GetAbsOrigin() - GetAbsOrigin()).Length();
					vPos = m_hTargetEntity->GetAbsOrigin() - vForward*dist;

					VectorNormalize( vForward );
					VectorNormalize( vRight );
					VectorNormalize( vUp );
				}
			}
			else
			{
				vForward = m_hTargetEntity->GetAbsOrigin() - GetAbsOrigin();
				VectorNormalize( vForward );

				// JasonM - unimplemented
				Assert (0);

				//Quaternion q = DirectionToOrientation( dir );


				//
				// JasonM - set up vRight, vUp
				//

				//			VectorNormalize( vRight );
				//			VectorNormalize( vUp );
			}
		}
		else
		{
			AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
		}

		state.m_fHorizontalFOVDegrees = m_flLightFOV;
		state.m_fVerticalFOVDegrees = m_flLightFOV;

		state.m_vecLightOrigin = vPos;
		BasisToQuaternion( vForward, vRight, vUp, state.m_quatOrientation );
		state.m_NearZ = m_flNearZ;
		state.m_FarZ = m_flFarZ;

		// quickly check the proposed light's bbox against the view frustum to determine whether we
		// should bother to create it, if it doesn't exist, or cull it, if it does.
		if ( m_bSimpleProjection == false )
		{
#pragma message("OPTIMIZATION: this should be made SIMD")
			// get the half-widths of the near and far planes, 
			// based on the FOV which is in degrees. Remember that
			// on planet Valve, x is forward, y left, and z up. 
			const float tanHalfAngle = tan( m_flLightFOV * ( M_PI/180.0f ) * 0.5f );
			const float halfWidthNear = tanHalfAngle * m_flNearZ;
			const float halfWidthFar = tanHalfAngle * m_flFarZ;
			// now we can build coordinates in local space: the near rectangle is eg 
			// (0, -halfWidthNear, -halfWidthNear), (0,  halfWidthNear, -halfWidthNear), 
			// (0,  halfWidthNear,  halfWidthNear), (0, -halfWidthNear,  halfWidthNear)

			VectorAligned vNearRect[4] = { 
				VectorAligned( m_flNearZ, -halfWidthNear, -halfWidthNear), VectorAligned( m_flNearZ,  halfWidthNear, -halfWidthNear),
				VectorAligned( m_flNearZ,  halfWidthNear,  halfWidthNear), VectorAligned( m_flNearZ, -halfWidthNear,  halfWidthNear) 
			};

			VectorAligned vFarRect[4] = { 
				VectorAligned( m_flFarZ, -halfWidthFar, -halfWidthFar), VectorAligned( m_flFarZ,  halfWidthFar, -halfWidthFar),
				VectorAligned( m_flFarZ,  halfWidthFar,  halfWidthFar), VectorAligned( m_flFarZ, -halfWidthFar,  halfWidthFar) 
			};

			matrix3x4_t matOrientation( vForward, -vRight, vUp, vPos );

			enum
			{
				kNEAR = 0,
				kFAR = 1,
			};
			VectorAligned vOutRects[2][4];

			for ( int i = 0 ; i < 4 ; ++i )
			{
				VectorTransform( vNearRect[i].Base(), matOrientation, vOutRects[0][i].Base() );
			}
			for ( int i = 0 ; i < 4 ; ++i )
			{
				VectorTransform( vFarRect[i].Base(), matOrientation, vOutRects[1][i].Base() );
			}

			// now take the MIN and MAX extents for the bbox, and see if it is visible.
			Vector mins = **vOutRects; 
			Vector maxs = **vOutRects; 
			for ( int i = 1; i < 8 ; ++i )
			{
				VectorMin( mins, *(*vOutRects+i), mins );
				VectorMax( maxs, *(*vOutRects+i), maxs );
			}

#if 0 //for debugging the visibility frustum we just calculated
			NDebugOverlay::Triangle( vOutRects[0][0], vOutRects[0][1], vOutRects[0][2], 255, 0, 0, 100, true, 0.0f ); //first tri
			NDebugOverlay::Triangle( vOutRects[0][2], vOutRects[0][1], vOutRects[0][0], 255, 0, 0, 100, true, 0.0f ); //make it double sided
			NDebugOverlay::Triangle( vOutRects[0][2], vOutRects[0][3], vOutRects[0][0], 255, 0, 0, 100, true, 0.0f ); //second tri
			NDebugOverlay::Triangle( vOutRects[0][0], vOutRects[0][3], vOutRects[0][2], 255, 0, 0, 100, true, 0.0f ); //make it double sided

			NDebugOverlay::Triangle( vOutRects[1][0], vOutRects[1][1], vOutRects[1][2], 0, 0, 255, 100, true, 0.0f ); //first tri
			NDebugOverlay::Triangle( vOutRects[1][2], vOutRects[1][1], vOutRects[1][0], 0, 0, 255, 100, true, 0.0f ); //make it double sided
			NDebugOverlay::Triangle( vOutRects[1][2], vOutRects[1][3], vOutRects[1][0], 0, 0, 255, 100, true, 0.0f ); //second tri
			NDebugOverlay::Triangle( vOutRects[1][0], vOutRects[1][3], vOutRects[1][2], 0, 0, 255, 100, true, 0.0f ); //make it double sided

			NDebugOverlay::Box( vec3_origin, mins, maxs, 0, 255, 0, 100, 0.0f );
#endif
			
			bool bVisible = IsBBoxVisible( mins, maxs );
			if (!bVisible)
			{
				// Spotlight's extents aren't in view
				if ( m_LightHandle != CLIENTSHADOW_INVALID_HANDLE )
				{
					ShutDownLightHandle();
				}

				return;
			}
		}

		float flAlpha = m_flCurrentLinearFloatLightAlpha * ( 1.0f / 255.0f );

		state.m_fQuadraticAtten = 0.0;
		state.m_fLinearAtten = 100;
		state.m_fConstantAtten = 0.0f;
		state.m_FarZAtten = m_flFarZ;
		state.m_fBrightnessScale = m_flBrightnessScale;
		state.m_Color[0] = m_CurrentLinearFloatLightColor.x * ( 1.0f / 255.0f ) * flAlpha;
		state.m_Color[1] = m_CurrentLinearFloatLightColor.y * ( 1.0f / 255.0f ) * flAlpha;
		state.m_Color[2] = m_CurrentLinearFloatLightColor.z * ( 1.0f / 255.0f ) * flAlpha;
		state.m_Color[3] = 0.0f; // fixme: need to make ambient work m_flAmbient;
		state.m_flShadowSlopeScaleDepthBias = g_pMaterialSystemHardwareConfig->GetShadowSlopeScaleDepthBias();
		state.m_flShadowDepthBias = g_pMaterialSystemHardwareConfig->GetShadowDepthBias();
		state.m_bEnableShadows = m_bEnableShadows;
		state.m_pSpotlightTexture = m_SpotlightTexture;
		state.m_pProjectedMaterial = NULL; // only complain if we're using material projection
		state.m_nSpotlightTextureFrame = m_nSpotlightTextureFrame;
		state.m_flProjectionSize = m_flProjectionSize;
		state.m_flProjectionRotation = m_flRotation;

		state.m_nShadowQuality = m_nShadowQuality; // Allow entity to affect shadow quality

		if ( m_bSimpleProjection == true )
		{
			state.m_bSimpleProjection = true;
			state.m_bOrtho = true;
			state.m_fOrthoLeft = -m_flProjectionSize;
			state.m_fOrthoTop = -m_flProjectionSize;
			state.m_fOrthoRight = m_flProjectionSize;
			state.m_fOrthoBottom = m_flProjectionSize;
		}

		if( m_LightHandle == CLIENTSHADOW_INVALID_HANDLE )
		{
			// Hack: env projected textures don't work like normal flashlights; they're not assigned to a given splitscreen slot,
			// but the flashlight code requires this
			HACK_GETLOCALPLAYER_GUARD( "Env projected texture" );
			if ( m_bSimpleProjection == true )
			{
				m_LightHandle = g_pClientShadowMgr->CreateProjection( state );
			}
			else
			{
				m_LightHandle = g_pClientShadowMgr->CreateFlashlight( state );
			}

			if ( m_LightHandle != CLIENTSHADOW_INVALID_HANDLE )
			{
				m_bForceUpdate = false;
			}
		}
		else
		{
			if ( m_bSimpleProjection == true )
			{
				g_pClientShadowMgr->UpdateProjectionState( m_LightHandle, state );
			}
			else
			{
				g_pClientShadowMgr->UpdateFlashlightState( m_LightHandle, state );
			}
			m_bForceUpdate = false;
		}

		g_pClientShadowMgr->GetFrustumExtents( m_LightHandle, m_vecExtentsMin, m_vecExtentsMax );

		m_vecExtentsMin = m_vecExtentsMin - GetAbsOrigin();
		m_vecExtentsMax = m_vecExtentsMax - GetAbsOrigin();
	}

	if( m_bLightOnlyTarget )
	{
		g_pClientShadowMgr->SetFlashlightTarget( m_LightHandle, m_hTargetEntity );
	}
	else
	{
		g_pClientShadowMgr->SetFlashlightTarget( m_LightHandle, NULL );
	}

	g_pClientShadowMgr->SetFlashlightLightWorld( m_LightHandle, m_bLightWorld );

	if ( !asw_perf_wtf.GetBool() && !m_bForceUpdate )
	{
		g_pClientShadowMgr->UpdateProjectedTexture( m_LightHandle, true );
	}
}
Пример #30
0
int main(void) {
    ex_sask_init();

    /*Initialise Audio input and output function*/
    ADCChannelInit(pADCChannelHandle, adcBuffer);
    OCPWMInit(pOCPWMHandle, ocPWMBuffer);

    /*Start Audio input and output function*/
    ADCChannelStart(pADCChannelHandle);
    OCPWMStart(pOCPWMHandle);

    /*Initialising variables that are needed for calculating the peak frequency*/
    int peakFrequency = 0;
    int peakFrequencyBin = 0;

    while (1) {
        /*Wait till the ADC has a new frame available*/
        while (ADCChannelIsBusy(pADCChannelHandle));

        /*Read in the Audio Samples from the ADC*/
        ADCChannelRead(pADCChannelHandle, frctAudioIn, FRAME_SIZE);

        /*Computing the FFT of the raw signal*/
        fourierTransform(FRAME_SIZE, compX, frctAudioIn);

        /*Removing the negative part of the FFT output (imaginary part) by zeroing it out*/
        filterNegativeFreq(FRAME_SIZE, compXfiltered, compX);

        /*Compute the square magnitude of the complex FFT output array so we have a Real output vetor*/
        SquareMagnitudeCplx(FRAME_SIZE / 2, &compXfiltered[0], &compXfiltered[0].real);

        /*Find the frequency Bin ( = index into the SigCmpx[] array) that has the largest energy*/
        /*i.e., the largest spectral component*/
        VectorMax(FRAME_SIZE / 2, &compXfiltered[0].real, &peakFrequencyBin);

        /*Compute the frequency (in Hz) of the largest spectral component*/
        peakFrequency = peakFrequencyBin * (8000 / FRAME_SIZE);

        /*Uses the peak frequency variable to turn on the corresponding LEDs*/
        turnOnLEDs(peakFrequency);

        /* Used for checking whether the user wants to record */
        if (CheckSwitchS1() == PRESSED) {
            if (switchState == 0) {
                //startRecording(); Code works, but doesn't record much, only a fraction of a second
            } else if (switchState == 1) {
                int i = 0;
                for (i; i < (FRAME_SIZE)*5; i++) {
                    frctAudioOut[i] = 0;
                }
                switchState = 0;
                firstPartExecutedDecision = 0;
            }
        }
        
        /* Switch two is just used to toggle between different modes */
        if (CheckSwitchS2() == PRESSED) {
            if (switchState2 == 0) {
                switchState2 = 1;
            } else if (switchState2 == 1) {
                switchState2 = 2;
            } else if (switchState2 == 2) {
                switchState2 = 0;
            }
        }
        
        /* Checking whether the peak frequency is above 800 and if so calling the function playPureSignal() */
        if (peakFrequency >= 800) {
            playPureSignal(peakFrequency);
        } else if (switchState2 != 2) {
            int i = 0;
            for (i; i < FRAME_SIZE; i++) {
                if (switchState2 == 0) {
                    frctAudioOut[i] = frctAudioIn[i]; //Used for the mode that allows for outputting of the original signal
                } else if (switchState2 == 1) {
                    frctAudioOut[i] = 0; //Used for the mode that requests silence if the threshold has not been met
                }
            }
        }

        if (switchState2 == 2) {
            int i = 0;
            for (i; i < FRAME_SIZE; i++) {
                frctAudioOut[i] = 0;
            }
        }
        
        /* Outputting the pure signal or original sound or silence, depending on what's inside frctAudioOut*/
        while (OCPWMIsBusy(pOCPWMHandle));
        OCPWMWrite(pOCPWMHandle, frctAudioOut, FRAME_SIZE);
    }

     /*=============================================================================
     | Function used for recording the input signal, a snapshot of the frame
     | is stored inside the frctAudioOut array, this is done five times as that
     | was the largest possible size for frctAudioOut array as anything larger would
     | lead to exhausting the memory, the function records correctly but the recording
     | is not long enough, hence the code was retired as it requires more work.
     *===========================================================================*/
    void startRecording() {
        if (firstPartExecutedDecision == 0) {
            int i = 0;

            for (i; i < FRAME_SIZE; i++) {
                frctAudioOut[i] = frctAudioIn[i]*0.5;
            }
            firstPartExecutedDecision = 1;
        }

        if (firstPartExecutedDecision == 1) {
            int i = FRAME_SIZE;
            int iFrameSize = 0;
            for (i; i < (FRAME_SIZE)*2; i++) {
                frctAudioOut[i] = frctAudioIn[iFrameSize]*0.5;
                iFrameSize++;
            }
            firstPartExecutedDecision = 2;
        }

        if (firstPartExecutedDecision == 2) {
            int i = (FRAME_SIZE)*2;
            int iFrameSize = 0;
            for (i; i < (FRAME_SIZE)*3; i++) {
                frctAudioOut[i] = frctAudioIn[iFrameSize]*0.5;
                iFrameSize++;
            }
            firstPartExecutedDecision = 3;
        }

        if (firstPartExecutedDecision == 3) {
            int i = (FRAME_SIZE)*3;
            int iFrameSize = 0;
            for (i; i < (FRAME_SIZE)*4; i++) {
                frctAudioOut[i] = frctAudioIn[iFrameSize]*0.5;
                iFrameSize++;
            }
            firstPartExecutedDecision = 4;
        }

        if (firstPartExecutedDecision == 4) {
            int i = (FRAME_SIZE)*4;
            int iFrameSize = 0;
            for (i; i < (FRAME_SIZE)*5; i++) {
                frctAudioOut[i] = frctAudioIn[iFrameSize]*0.5;
                iFrameSize++;
            }
            firstPartExecutedDecision = -1;
            switchState = 1;
        }
    }
    /*=============================================================================
     | Function used to generate the pure signal using the createSimpleSignal()
     | function available in the modulate.h header - this function uses the peak
     | frequency handed through the parameter call to decide what signal to generate.
     | The output signal is stored inside the frctAudioOut array which is then
     | later used for the OCPWMWrite() function to output the sound.
     *===========================================================================*/
    void playPureSignal(int peakFrequency) {
        int simpleSignalFrequency = 0;
        if (peakFrequency <= 1600) {
            simpleSignalFrequency = 500;
            createSimpleSignal(simpleSignalFrequency, FRAME_SIZE, frctAudioOut);
        } else if (peakFrequency <= 2400) {
            simpleSignalFrequency = 800;
            createSimpleSignal(simpleSignalFrequency, FRAME_SIZE, frctAudioOut);
        } else if (peakFrequency <= 3200) {
            simpleSignalFrequency = 1000;
            createSimpleSignal(simpleSignalFrequency, FRAME_SIZE, frctAudioOut);
        } else if (peakFrequency <= 4000) {
            simpleSignalFrequency = 1500;
            createSimpleSignal(simpleSignalFrequency, FRAME_SIZE, frctAudioOut);
        }
    }