void rvMonsterStroggHover::TryStartPursuit ( void ) { if ( GetEnemy() ) { inPursuit = false; if ( !marker.GetEntity() ) { //wtf?! assert(0); return; } attackPosOffset.Set( gameLocal.random.CRandomFloat()*500.0f, gameLocal.random.CRandomFloat()*500.0f, 0.0f ); if ( attackPosOffset.Length() < 150.0f ) { attackPosOffset.Normalize(); attackPosOffset *= 150.0f; } attackPosOffset.z = (gameLocal.random.CRandomFloat()*30.0f)+50.0f + move.fly_offset; marker.GetEntity()->GetPhysics()->SetOrigin( GetEnemy()->GetPhysics()->GetOrigin()+attackPosOffset ); if ( MarkerPosValid() ) { if ( MoveToEntity( marker ) ) { inPursuit = true; holdPosTime = 0; SetState( "State_Pursue" ); } } } }
static int Ballistics( const idVec3 &start, const idVec3 &end, float speed, float gravity, ballistics_t bal[2] ) { int n, i; float x, y, a, b, c, d, sqrtd, inva, p[2]; x = ( end.ToVec2() - start.ToVec2() ).Length(); y = end[2] - start[2]; a = 4.0f * y * y + 4.0f * x * x; b = -4.0f * speed * speed - 4.0f * y * gravity; c = gravity * gravity; d = b * b - 4.0f * a * c; if ( d <= 0.0f || a == 0.0f ) { return 0; } sqrtd = idMath::Sqrt( d ); inva = 0.5f / a; p[0] = ( - b + sqrtd ) * inva; p[1] = ( - b - sqrtd ) * inva; n = 0; for ( i = 0; i < 2; i++ ) { if ( p[i] <= 0.0f ) { continue; } d = idMath::Sqrt( p[i] ); bal[n].angle = atan2( 0.5f * ( 2.0f * y * p[i] - gravity ) / d, d * x ); bal[n].time = x / ( cos( bal[n].angle ) * speed ); bal[n].angle = idMath::AngleNormalize180( RAD2DEG( bal[n].angle ) ); n++; } return n; }
/* =================== R_ClipLineToLight If neither point is clearly behind the clipping plane, the edge will be passed unmodified. A sil edge that is on a border plane must be drawn. If one point is clearly clipped by the plane and the other point is on the plane, it will be completely removed. =================== */ ID_STATIC_TEMPLATE ID_INLINE bool R_ClipLineToLight( const idVec3 &a, const idVec3 &b, const idPlane frustum[6], idVec3 &p1, idVec3 &p2 ) { float *clip; int j; float d1, d2; float f; p1 = a; p2 = b; // clip it for( j = 0; j < 6; j++ ) { d1 = frustum[j].Distance( p1 ); d2 = frustum[j].Distance( p2 ); // if both on or in front, not clipped to this plane if( d1 > -LIGHT_CLIP_EPSILON && d2 > -LIGHT_CLIP_EPSILON ) { continue; } // if one is behind and the other isn't clearly in front, the edge is clipped off if( d1 <= -LIGHT_CLIP_EPSILON && d2 < LIGHT_CLIP_EPSILON ) { return false; } if( d2 <= -LIGHT_CLIP_EPSILON && d1 < LIGHT_CLIP_EPSILON ) { return false; } // clip it, keeping the negative side if( d1 < 0 ) { clip = p1.ToFloatPtr(); } else { clip = p2.ToFloatPtr(); } f = d1 / ( d1 - d2 ); clip[0] = p1[0] + f * ( p2[0] - p1[0] ); clip[1] = p1[1] + f * ( p2[1] - p1[1] ); clip[2] = p1[2] + f * ( p2[2] - p1[2] ); } return true; // retain a fragment }
void idSimpleWindow::SetupTransforms( float x, float y ) { static idMat3 trans; static idVec3 org; trans.Identity(); org.Set( origin.x + x, origin.y + y, 0 ); if( rotate ) { static idRotation rot; static idVec3 vec( 0, 0, 1 ); rot.Set( org, vec, rotate ); trans = rot.ToMat3(); } static idMat3 smat; smat.Identity(); if( shear.x() || shear.y() ) { smat[0][1] = shear.x(); smat[1][0] = shear.y(); trans *= smat; } if( !trans.IsIdentity() ) { dc->SetTransformInfo( org, trans ); } }
/* ============ idAASLocal::GetEdge ============ */ void idAASLocal::GetEdge( int edgeNum, idVec3 &start, idVec3 &end ) const { if ( !file ) { start.Zero(); end.Zero(); return; } const int *v = file->GetEdge( abs(edgeNum) ).vertexNum; start = file->GetVertex( v[INTSIGNBITSET(edgeNum)] ); end = file->GetVertex( v[INTSIGNBITNOTSET(edgeNum)] ); }
/* ============ idAI::FindPathAroundObstacles Finds a path around dynamic obstacles using a path tree with clockwise and counter clockwise edge walks. ============ */ bool idAI::FindPathAroundObstacles( const idPhysics *physics, const idAAS *aas, const idEntity *ignore, const idVec3 &startPos, const idVec3 &seekPos, obstaclePath_t &path ) { int numObstacles, areaNum, insideObstacle; obstacle_t obstacles[MAX_OBSTACLES]; idBounds clipBounds; idBounds bounds; pathNode_t *root; bool pathToGoalExists; path.seekPos = seekPos; path.firstObstacle = NULL; path.startPosOutsideObstacles = startPos; path.startPosObstacle = NULL; path.seekPosOutsideObstacles = seekPos; path.seekPosObstacle = NULL; if( !aas ) { return true; } bounds[1] = aas->GetSettings()->boundingBoxes[0][1]; bounds[0] = -bounds[1]; bounds[1].z = 32.0f; // get the AAS area number and a valid point inside that area areaNum = aas->PointReachableAreaNum( path.startPosOutsideObstacles, bounds, ( AREA_REACHABLE_WALK | AREA_REACHABLE_FLY ) ); aas->PushPointIntoAreaNum( areaNum, path.startPosOutsideObstacles ); // get all the nearby obstacles numObstacles = GetObstacles( physics, aas, ignore, areaNum, path.startPosOutsideObstacles, path.seekPosOutsideObstacles, obstacles, MAX_OBSTACLES, clipBounds ); // get a source position outside the obstacles GetPointOutsideObstacles( obstacles, numObstacles, path.startPosOutsideObstacles.ToVec2(), &insideObstacle, NULL ); if( insideObstacle != -1 ) { path.startPosObstacle = obstacles[insideObstacle].entity; } // get a goal position outside the obstacles GetPointOutsideObstacles( obstacles, numObstacles, path.seekPosOutsideObstacles.ToVec2(), &insideObstacle, NULL ); if( insideObstacle != -1 ) { path.seekPosObstacle = obstacles[insideObstacle].entity; } // if start and destination are pushed to the same point, we don't have a path around the obstacle if( ( path.seekPosOutsideObstacles.ToVec2() - path.startPosOutsideObstacles.ToVec2() ).LengthSqr() < Square( 1.0f ) ) { if( ( seekPos.ToVec2() - startPos.ToVec2() ).LengthSqr() > Square( 2.0f ) ) { return false; } } // build a path tree root = BuildPathTree( obstacles, numObstacles, clipBounds, path.startPosOutsideObstacles.ToVec2(), path.seekPosOutsideObstacles.ToVec2(), path ); // draw the path tree if( ai_showObstacleAvoidance.GetBool() ) { DrawPathTree( root, physics->GetOrigin().z ); } // prune the tree PrunePathTree( root, path.seekPosOutsideObstacles.ToVec2() ); // find the optimal path pathToGoalExists = FindOptimalPath( root, obstacles, numObstacles, physics->GetOrigin().z, physics->GetLinearVelocity(), path.seekPos ); // free the tree FreePathTree_r( root ); return pathToGoalExists; }
/* ================ idBrittleFracture::DropShard ================ */ void idBrittleFracture::DropShard( shard_t* shard, const idVec3& point, const idVec3& dir, const float impulse, const int time ) { int i, j, clipModelId; float dist, f; idVec3 dir2, origin; idMat3 axis; shard_t* neighbour; // don't display decals on dropped shards shard->decals.DeleteContents( true ); // remove neighbour pointers of neighbours pointing to this shard for( i = 0; i < shard->neighbours.Num(); i++ ) { neighbour = shard->neighbours[i]; for( j = 0; j < neighbour->neighbours.Num(); j++ ) { if( neighbour->neighbours[j] == shard ) { neighbour->neighbours.RemoveIndex( j ); break; } } } // remove neighbour pointers shard->neighbours.Clear(); // remove the clip model from the static physics object clipModelId = shard->clipModel->GetId(); physicsObj.SetClipModel( NULL, 1.0f, clipModelId, false ); origin = shard->clipModel->GetOrigin(); axis = shard->clipModel->GetAxis(); // set the dropped time for fading shard->droppedTime = time; dir2 = origin - point; dist = dir2.Normalize(); f = dist > maxShatterRadius ? 1.0f : idMath::Sqrt( idMath::Fabs( dist - minShatterRadius ) ) * ( 1.0f / idMath::Sqrt( idMath::Fabs( maxShatterRadius - minShatterRadius ) ) ); // setup the physics shard->physicsObj.SetSelf( this ); shard->physicsObj.SetClipModel( shard->clipModel, density ); shard->physicsObj.SetMass( shardMass ); shard->physicsObj.SetOrigin( origin ); shard->physicsObj.SetAxis( axis ); shard->physicsObj.SetBouncyness( bouncyness ); shard->physicsObj.SetFriction( 0.6f, 0.6f, friction ); shard->physicsObj.SetGravity( gameLocal.GetGravity() ); shard->physicsObj.SetContents( CONTENTS_RENDERMODEL ); shard->physicsObj.SetClipMask( MASK_SOLID | CONTENTS_MOVEABLECLIP ); shard->physicsObj.ApplyImpulse( 0, origin, impulse * linearVelocityScale * dir ); shard->physicsObj.SetAngularVelocity( dir.Cross( dir2 ) * ( f * angularVelocityScale ) ); shard->clipModel->SetId( clipModelId ); BecomeActive( TH_PHYSICS ); }
float Aimbot::AdvancedHumanization( float distance, idVec3 targetVelocity ) { //targetVelocity.z = 0; float targetSpeed = targetVelocity.Length(); //speed in units/seconds float returnValue = max( distance / 1000.0f, 1.192092896e-07f ); return returnValue + targetSpeed / 320.0f; }
/* ===================== idPhysics_Monster::SlideMove ===================== */ monsterMoveResult_t idPhysics_Monster::SlideMove(idVec3 &start, idVec3 &velocity, const idVec3 &delta) { int i; trace_t tr; idVec3 move; blockingEntity = NULL; move = delta; for (i = 0; i < 3; i++) { gameLocal.clip.Translation(tr, start, start + move, clipModel, clipModel->GetAxis(), clipMask, self); start = tr.endpos; if (tr.fraction == 1.0f) { if (i > 0) { return MM_SLIDING; } return MM_OK; } if (tr.c.entityNum != ENTITYNUM_NONE) { blockingEntity = gameLocal.entities[ tr.c.entityNum ]; } // clip the movement delta and velocity move.ProjectOntoPlane(tr.c.normal, OVERCLIP); velocity.ProjectOntoPlane(tr.c.normal, OVERCLIP); } return MM_BLOCKED; }
/* ============ idAASSettings::ParseVector ============ */ bool idAASSettings::ParseVector( idLexer &src, idVec3 &vec ) { if ( !src.ExpectTokenString( "=" ) ) { return false; } return ( src.Parse1DMatrix( 3, vec.ToFloatPtr() ) != 0 ); }
/* ================ idCollisionModelManagerLocal::CollisionBetweenEdgeBounds verifies if the collision of two edges occurs between the edge bounds also calculates the collision point and collision plane normal if the collision occurs between the bounds ================ */ int idCollisionModelManagerLocal::CollisionBetweenEdgeBounds( cm_traceWork_t *tw, const idVec3 &va, const idVec3 &vb, const idVec3 &vc, const idVec3 &vd, float tanHalfAngle, idVec3 &collisionPoint, idVec3 &collisionNormal ) { float d1, d2, d; idVec3 at, bt, dir, dir1, dir2; idPluecker pl1, pl2; at = va; bt = vb; if ( tanHalfAngle != 0.0f ) { CM_RotateEdge( at, bt, tw->origin, tw->axis, tanHalfAngle ); } dir1 = (at - tw->origin).Cross( tw->axis ); dir2 = (bt - tw->origin).Cross( tw->axis ); if ( dir1 * dir1 > dir2 * dir2 ) { dir = dir1; } else { dir = dir2; } if ( tw->angle < 0.0f ) { dir = -dir; } pl1.FromLine( at, bt ); pl2.FromRay( vc, dir ); d1 = pl1.PermutedInnerProduct( pl2 ); pl2.FromRay( vd, dir ); d2 = pl1.PermutedInnerProduct( pl2 ); if ( ( d1 > 0.0f && d2 > 0.0f ) || ( d1 < 0.0f && d2 < 0.0f ) ) { return false; } pl1.FromLine( vc, vd ); pl2.FromRay( at, dir ); d1 = pl1.PermutedInnerProduct( pl2 ); pl2.FromRay( bt, dir ); d2 = pl1.PermutedInnerProduct( pl2 ); if ( ( d1 > 0.0f && d2 > 0.0f ) || ( d1 < 0.0f && d2 < 0.0f ) ) { return false; } // collision point on the edge at-bt dir1 = (vd - vc).Cross( dir ); d = dir1 * vc; d1 = dir1 * at - d; d2 = dir1 * bt - d; if ( d1 == d2 ) { return false; } collisionPoint = at + ( d1 / (d1 - d2) ) * ( bt - at ); // normal is cross product of the rotated edge va-vb and the edge vc-vd collisionNormal.Cross( bt-at, vd-vc ); return true; }
/* ================= R_MirrorVector ================= */ static void R_MirrorVector( const idVec3 in, orientation_t* surface, orientation_t* camera, idVec3& out ) { out.Zero(); for( int i = 0; i < 3; i++ ) { const float d = in * surface->axis[i]; out += d * camera->axis[i]; } }
/* ============ idAASLocal::GetAreaNumAndLocation ============ */ bool idAASLocal::GetAreaNumAndLocation( idCVar &cvar, const idVec3 &origin, int &areaNum, idVec3 &location ) const { areaNum = 0; location.Zero(); if ( cvar.GetString()[0] == '\0' ) { return false; } if ( idStr::Icmp( cvar.GetString(), "memory" ) == 0 ) { cvar.SetString( aas_locationMemory.GetString() ); } if ( idStr::Icmp( cvar.GetString(), "current" ) == 0 ) { cvar.SetString( origin.ToString() ); } idLexer src( LEXFL_NOERRORS|LEXFL_NOWARNINGS ); src.LoadMemory( cvar.GetString(), idStr::Length( cvar.GetString() ), "areaNum" ); bool error = false; location.x = src.ParseFloat( &error ); location.y = src.ParseFloat( &error ); location.z = src.ParseFloat( &error ); if ( !error ) { areaNum = PointReachableAreaNum( location, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() ); PushPointIntoArea( areaNum, location ); return true; } src.Reset(); areaNum = src.ParseInt(); if ( ( areaNum > 0 ) && ( areaNum < file->GetNumAreas() ) ) { location = AreaCenter( areaNum ); return true; } return false; }
/* ================ idDict::GetVector ================ */ bool idDict::GetVector( const char *key, const char *defaultString, idVec3 &out ) const { bool found; const char *s; if( !defaultString ) { defaultString = "0 0 0"; } found = GetString( key, defaultString, &s ); out.Zero(); sscanf( s, "%f %f %f", &out.x, &out.y, &out.z ); return found; }
/* ================ idThread::Event_VecToOrthoBasisAngles ================ */ void idThread::Event_VecToOrthoBasisAngles( idVec3 &vec ) { idVec3 left, up; idAngles ang; vec.OrthogonalBasis( left, up ); idMat3 axis( left, up, vec ); ang = axis.ToAngles(); ReturnVector( idVec3( ang[0], ang[1], ang[2] ) ); }
/* ================ idLiquid::Collide Spawns a splash particle and attaches a sound to the colliding entity. ================ */ bool idLiquid::Collide( const trace_t &collision, const idVec3 &velocity ) { idEntity *e = gameLocal.entities[collision.c.entityNum]; idPhysics_Liquid *phys = static_cast<idPhysics_Liquid *>( this->GetPhysics() ); const idDeclParticle *splash; const char *sName; float eMass; idVec3 splashSpot; float velSquare = velocity.LengthSqr(); ProcCollisionStims( e, collision.c.id ); eMass = e->GetPhysics()->GetMass(); splashSpot = collision.c.point; if( velSquare > phys->GetMinSplashVelocity().LengthSqr() ) { // pick which splash particle to spawn // first we check the entity, if it's not defined we use // one defined for this liquid. sName = e->spawnArgs.GetString( this->smokeName.c_str() ); if( *sName != '\0' ) { // load entity particle splash = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, sName ) ); } else { // load a liquid particle based on the mass of the splashing entity if( eMass < SMALL_SPLASH ) { splash = this->splash[0]; } else if( eMass < MEDIUM_SPLASH ) { splash = this->splash[1]; } else { splash = this->splash[2]; } } // play the sound for a splash e->StartSound( this->soundName.c_str(), SND_CHANNEL_ANY, 0, false, NULL ); // grayman #3413 - propagate the global sound for the splash idStr size = e->spawnArgs.GetString( "spr_object_size" ); if( size.IsEmpty() ) { if( eMass < SMALL_SPLASH ) { size = "small"; } else if( eMass < MEDIUM_SPLASH ) { size = "medium"; } else { size = "large"; } } idStr splashName = idStr( "splash_" ) + size; e->PropSoundS( NULL, splashName, 0, 0 ); } else if( velSquare > phys->GetMinWaveVelocity().LengthSqr() ) { splash = this->waves; } else { // the object is moving to slow so we abort return true; } // spawn the particle gameLocal.smokeParticles->EmitSmoke( splash, gameLocal.time, gameLocal.random.RandomFloat(), splashSpot, collision.endAxis ); return true; }
/* ===================== sdClientAnimated::GetJointWorldTransform ===================== */ bool sdClientAnimated::GetJointWorldTransform( jointHandle_t jointHandle, int currentTime, idVec3 &offset, idMat3 &axis ) { if ( !animator.GetJointTransform( jointHandle, currentTime, offset, axis ) ) { offset.Zero(); axis.Identity(); return false; } offset = renderEntity.origin + offset * renderEntity.axis; axis *= renderEntity.axis; return true; }
/* ================ CM_RotateEdge rotates an edge about an arbitrary axis using the tangent of half the rotation angle ================ */ void CM_RotateEdge( idVec3 &start, idVec3 &end, const idVec3 &origin, const idVec3 &axis, const float tanHalfAngle ) { double d, t, s, c; idVec3 proj, v1, v2; // r = tan( a / 2 ); // sin(a) = 2*r/(1+r*r); // cos(a) = (1-r*r)/(1+r*r); t = tanHalfAngle * tanHalfAngle; d = 1.0f / ( 1.0f + t ); s = 2.0f * tanHalfAngle * d; c = ( 1.0f - t ) * d; start -= origin; proj = axis * ( start * axis ); v1 = start - proj; v2 = axis.Cross( v1 ); start = v1 * c - v2 * s + proj + origin; end -= origin; proj = axis * ( end * axis ); v1 = end - proj; v2 = axis.Cross( v1 ); end = v1 * c - v2 * s + proj + origin; }
/* ================ glLabeledPoint ================ */ void glLabeledPoint(idVec4 &color, idVec3 &point, float size, const char *label) { qglColor3fv( color.ToFloatPtr() ); qglPointSize( size ); qglBegin( GL_POINTS ); qglVertex3fv( point.ToFloatPtr() ); qglEnd(); idVec3 v = point; v.x += 1; v.y += 1; v.z += 1; qglRasterPos3fv( v.ToFloatPtr() ); qglCallLists( strlen(label), GL_UNSIGNED_BYTE, label ); }
void DrawLine( idVec3 v1, idVec3 v2, int color ) { if( !dmapGlobals.drawflag ) { return; } switch( color ) { case 0: GL_Color( 0.0f, 0.0f, 0.0f ); break; case 1: GL_Color( 0.0f, 0.0f, 1.0f ); break; case 2: GL_Color( 0.0f, 1.0f, 0.0f ); break; case 3: GL_Color( 0.0f, 1.0f, 1.0f ); break; case 4: GL_Color( 1.0f, 0.0f, 0.0f ); break; case 5: GL_Color( 1.0f, 0.0f, 1.0f ); break; case 6: GL_Color( 1.0f, 1.0f, 0.0f ); break; case 7: GL_Color( 1.0f, 1.0f, 1.0f ); break; } glBegin( GL_LINES ); glVertex3fv( v1.ToFloatPtr() ); glVertex3fv( v2.ToFloatPtr() ); glEnd(); glFlush(); }
/* ================ CM_RotatePoint rotates a point about an arbitrary axis using the tangent of half the rotation angle ================ */ void CM_RotatePoint( idVec3 &point, const idVec3 &origin, const idVec3 &axis, const float tanHalfAngle ) { double d, t, s, c; idVec3 proj, v1, v2; point -= origin; proj = axis * ( point * axis ); v1 = point - proj; v2 = axis.Cross( v1 ); // r = tan( a / 2 ); // sin(a) = 2*r/(1+r*r); // cos(a) = (1-r*r)/(1+r*r); t = tanHalfAngle * tanHalfAngle; d = 1.0f / ( 1.0f + t ); s = 2.0f * tanHalfAngle * d; c = ( 1.0f - t ) * d; point = v1 * c - v2 * s + proj + origin; }
/* ================ hhCameraInterpolator::DetermineIdealRotation ================ */ idQuat hhCameraInterpolator::DetermineIdealRotation( const idVec3& idealUpVector, const idVec3& viewDir, const idMat3& untransformedViewAxis ) { idMat3 mat; idVec3 newViewVector( viewDir ); newViewVector.ProjectOntoPlane( idealUpVector ); if( newViewVector.LengthSqr() < VECTOR_EPSILON ) { newViewVector = -Sign( newViewVector * idealUpVector ); } newViewVector.Normalize(); mat[0] = newViewVector; mat[1] = idealUpVector.Cross( newViewVector ); mat[2] = idealUpVector; mat = untransformedViewAxis.Transpose() * mat; return mat.ToQuat(); }
/* ================ rvClientMoveable::Collide ================ */ bool rvClientMoveable::Collide ( const trace_t &collision, const idVec3 &velocity ) { if (mPlayBounceSoundOnce && mHasBounced) { return false; } if ( bounceSoundShader && gameLocal.time > bounceSoundTime ) { float speed; speed = velocity.LengthFast ( ); if ( speed > BOUNCE_SOUND_MIN_VELOCITY ) { StartSoundShader ( bounceSoundShader, SND_CHANNEL_BODY, 0 ); bounceSoundTime = BOUNCE_SOUND_DELAY; mHasBounced = true; } } return false; }
fhRenderMatrix fhRenderMatrix::CreateLookAtMatrix( const idVec3& dir, const idVec3& up ) { idVec3 zaxis = (dir * -1).Normalized(); idVec3 xaxis = up.Cross( zaxis ).Normalized(); idVec3 yaxis = zaxis.Cross( xaxis ); fhRenderMatrix m; m[0] = xaxis.x; m[1] = yaxis.x; m[2] = zaxis.x; m[4] = xaxis.y; m[5] = yaxis.y; m[6] = zaxis.y; m[8] = xaxis.z; m[9] = yaxis.z; m[10] = zaxis.z; return m; }
/* ============ idTraceModel::GetMassProperties ============ */ void idTraceModel::GetMassProperties( const float density, float &mass, idVec3 ¢erOfMass, idMat3 &inertiaTensor ) const { volumeIntegrals_t integrals; // if polygon trace model if ( type == TRM_POLYGON ) { idTraceModel trm; VolumeFromPolygon( trm, 1.0f ); trm.GetMassProperties( density, mass, centerOfMass, inertiaTensor ); return; } VolumeIntegrals( integrals ); // if no volume if ( integrals.T0 == 0.0f ) { mass = 1.0f; centerOfMass.Zero(); inertiaTensor.Identity(); return; } // mass of model mass = density * integrals.T0; // center of mass centerOfMass = integrals.T1 / integrals.T0; // compute inertia tensor inertiaTensor[0][0] = density * (integrals.T2[1] + integrals.T2[2]); inertiaTensor[1][1] = density * (integrals.T2[2] + integrals.T2[0]); inertiaTensor[2][2] = density * (integrals.T2[0] + integrals.T2[1]); inertiaTensor[0][1] = inertiaTensor[1][0] = - density * integrals.TP[0]; inertiaTensor[1][2] = inertiaTensor[2][1] = - density * integrals.TP[1]; inertiaTensor[2][0] = inertiaTensor[0][2] = - density * integrals.TP[2]; // translate inertia tensor to center of mass inertiaTensor[0][0] -= mass * (centerOfMass[1]*centerOfMass[1] + centerOfMass[2]*centerOfMass[2]); inertiaTensor[1][1] -= mass * (centerOfMass[2]*centerOfMass[2] + centerOfMass[0]*centerOfMass[0]); inertiaTensor[2][2] -= mass * (centerOfMass[0]*centerOfMass[0] + centerOfMass[1]*centerOfMass[1]); inertiaTensor[0][1] = inertiaTensor[1][0] += mass * centerOfMass[0] * centerOfMass[1]; inertiaTensor[1][2] = inertiaTensor[2][1] += mass * centerOfMass[1] * centerOfMass[2]; inertiaTensor[2][0] = inertiaTensor[0][2] += mass * centerOfMass[2] * centerOfMass[0]; }
END_CLASS /* ================ rvMonsterStroggHover::rvMonsterStroggHover ================ */ rvMonsterStroggHover::rvMonsterStroggHover ( ) { effectDust = NULL; for ( int i = 0; i < MAX_HOVER_JOINTS; i++ ) { effectHover[i] = NULL; } effectHeadlight = NULL; shots = 0; strafeTime = 0; strafeRight = false; circleStrafing = false; evadeDebounce = 0; deathPitch = 0; deathRoll = 0; deathPitchRate = 0; deathYawRate = 0; deathRollRate = 0; deathSpeed = 0; deathGrav = 0; markerCheckTime = 0; marker = NULL; attackPosOffset.Zero(); inPursuit = false; holdPosTime = 0; nextMGunFireTime = 0; nextMissileFireTime = 0; nextBombFireTime = 0; lightHandle = -1; }
// RAVEN BEGIN // jnewquist: Controller rumble void idPlayerView::ShakeOffsets( idVec3 &shakeOffset, idAngles &shakeAngleOffset, const idBounds bounds ) const { float shakeVolume = 0.0f; shakeOffset.Zero(); shakeAngleOffset.Zero(); if( gameLocal.isMultiplayer ) { return; } shakeVolume = CalculateShake( shakeAngleOffset ); if( gameLocal.time < shakeFinishTime ) { float offset = ( shakeFinishTime - gameLocal.time ) * shakeScale * 0.001f; shakeOffset[0] = idMath::ClampFloat( bounds[0][0] - 1.0f, bounds[1][0] + 1.0f, rvRandom::flrand( -offset, offset ) ); shakeOffset[1] = idMath::ClampFloat( bounds[0][1] - 1.0f, bounds[1][1] + 1.0f, rvRandom::flrand( -offset, offset ) ); shakeOffset[2] = idMath::ClampFloat( bounds[0][2] - 1.0f, bounds[1][2] + 1.0f, rvRandom::flrand( -offset, offset ) ); shakeAngleOffset[0] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) ); shakeAngleOffset[1] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) ); shakeAngleOffset[2] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) ); } }
/* ================ rvClientMoveable::Collide ================ */ bool rvClientMoveable::Collide ( const trace_t &collision, const idVec3 &velocity ) { if ( firstBounce ) { // first bounce, play effect const char* bounceEffectName = "fx_firstbounce"; if ( effectSet != 0 ) { bounceEffectName = va( "fx_firstbounce_%i", effectSet ); } const idVec3& origin = physicsObj.GetOrigin(); idMat3 axis = ( idVec3( 0.0f, 0.0f, 1.0f ) ).ToMat3(); gameLocal.PlayEffect( *spawnArgs, colorWhite.ToVec3(), bounceEffectName, NULL, origin, axis ); firstBounce = false; } if ( bounceSoundShader && gameLocal.time > bounceSoundTime ) { float speed; speed = velocity.LengthFast ( ); if ( speed > BOUNCE_SOUND_MIN_VELOCITY ) { StartSoundShader ( bounceSoundShader, SND_ANY, 0 ); bounceSoundTime = BOUNCE_SOUND_DELAY; } } return false; }
void hhControlHand::UpdateControlDirection(idVec3 &dir) { int anim; int curStatus = dir.DirectionMask(); if (bProcessControls && oldStatus != curStatus) { // Determine which anim group to play. (Up/Down/Normal & Forward/Center/Back) int z_index = dir.z < 0 ? 0 : dir.z > 0 ? 2 : 1; int x_index = dir.x < 0 ? 0 : dir.x > 0 ? 2 : 1; anim = anims[ z_index ][ x_index ]; GetAnimator()->CycleAnim( ANIMCHANNEL_ALL, anim, gameLocal.time, 250); // Now determine which left and right to play float left = dir.y > 0 ? 1.0f : 0.0f; float right = dir.y < 0 ? 1.0f : 0.0f; GetAnimator()->CurrentAnim( ANIMCHANNEL_ALL )->SetSyncedAnimWeight( 0, left ); GetAnimator()->CurrentAnim( ANIMCHANNEL_ALL )->SetSyncedAnimWeight( 1, 1.0f ); GetAnimator()->CurrentAnim( ANIMCHANNEL_ALL )->SetSyncedAnimWeight( 2, right ); oldStatus = curStatus; } }
/* ================ idUsercmdGenLocal::ClearAngles ================ */ void idUsercmdGenLocal::ClearAngles( void ) { viewangles.Zero(); }