void CCircle::AppendProperties(std::ostream & strm) const
{
CSolidShape::AppendProperties(strm);
strm << "\tPosition center = (" << m_positionCenter.x << ", "
<< m_positionCenter.y << ")" << std::endl
<< "\tRadius = " << GetRadius() << std::endl;
}
bool RigidBody::SPHEREvsAABB(RigidBody* actor)
{
vec3 temp_length = m_position - actor->GetPosition();
float length = glm::length(temp_length);
float intersection = m_radius + actor->GetWidth() - length;
// First, compute the distance between the centers
glm::vec3 SepAxis = actor->GetPosition() - GetPosition();
float Dist = glm::length(SepAxis);
// then, find the unit vector that points from the box center to the sphere center
glm::normalize(SepAxis);
// divide each component of the unit vector by the maximum component, effectively "normalizing" the unit vector
if (SepAxis.x >= SepAxis.y && SepAxis.x >= SepAxis.z)
SepAxis /= SepAxis.x;
else if (SepAxis.y >= SepAxis.x && SepAxis.y >= SepAxis.z)
SepAxis /= SepAxis.y;
else
SepAxis /= SepAxis.z;
// Now, find the effective radius of the box along the "normalized" unit vector pointing to the sphere
SepAxis.x *= actor->GetWidth() / 2.0f;
SepAxis.y *= actor->GetHeight() / 2.0f;
SepAxis.z *= actor->GetLength() / 2.0f;
float Dist2 = glm::length(SepAxis);
// Finally, add the sphere radius to the box radius and compare to the distance
if (Dist <= (GetRadius() + Dist2))
{
vec3 collisionNormal = glm::normalize(temp_length);
vec3 relativeVelocity = m_velocity - actor->GetVelocity();
vec3 collisionVector = collisionNormal *(glm::dot(relativeVelocity, collisionNormal));
vec3 forceVector = collisionVector * 1.0f / (1 / m_mass + 1 / actor->GetMass());
applyForceToActor(actor, 1 * forceVector); // the 1* should really be *2
//move our spheres out of collision
vec3 seperationVector = collisionNormal * intersection * .50f;
m_position += seperationVector;
actor->m_position -= seperationVector;
std::cout << "Colliding with: CUBE!" << " ID:" << m_id << "\n";
return true;
}
else
return false;
}
const SHAPE_LINE_CHAIN SHAPE_ARC::ConvertToPolyline( double aAccuracy ) const
{
SHAPE_LINE_CHAIN rv;
double r = GetRadius();
double sa = GetStartAngle();
auto c = GetCenter();
int n;
if( r == 0.0 )
{
n = 0;
}
else
{
n = GetArcToSegmentCount( r, From_User_Unit( MILLIMETRES, aAccuracy ), m_centralAngle );
}
for( int i = 0; i <= n ; i++ )
{
double a = sa + m_centralAngle * (double) i / (double) n;
double x = c.x + r * cos( a * M_PI / 180.0 );
double y = c.y + r * sin( a * M_PI / 180.0 );
rv.Append( (int) x, (int) y );
}
return rv;
}
bool Surfel::Contains (
const Vec3Df& iPoint
) const {
float distance = ( iPoint - GetPosition () ).getLength ();
return ( distance <= GetRadius () );
}
void CprobeIGC::Terminate(void)
{
AddRef();
DataProbeTypeIGC* dataProbeType = (DataProbeTypeIGC*)(m_probeType->GetData());
if (dataProbeType->dtRipcord >= 0.0f)
{
GetMyMission()->GetIgcSite()->DestroyTeleportProbe(this);
}
if (m_projectileType)
{
m_projectileType->Release();
m_projectileType = NULL;
}
m_launcher = NULL;
m_target = NULL;
GetCluster()->GetClusterSite()->AddExplosion(GetPosition(), GetRadius(), c_etProbe);
GetMyMission()->DeleteProbe(this);
TmodelIGC<IprobeIGC>::Terminate();
if (m_probeType)
{
m_probeType->Release();
m_probeType = NULL;
}
Release();
}
void ImgMaskCreator::DrawLine( const std::vector<PointPair>& pairVect,
const std::vector<Space>& position,
PelGray8 lineVal)
{
static const double PIdiv180 = 3.1415926/180.0;
if(m_img.IsNull()) return;
m_position = position;
m_boundLineVal = lineVal;
m_img.Maximize();
size_t radius = GetRadius();
size_t size = pairVect.size();
for(size_t i=0; i<size; i++)
{
TPoint2D<long> point0 = pairVect[i].first;
TPoint2D<long> point1 = pairVect[i].last;
TPoint2D<long> diff = point1 - point0;
if(8 * abs(diff.x()) < abs(diff.y()) || diff.Mag()<radius/3 )
{
DrawLine(point0, point1);
}
else
{
DrawArc(point0, point1, radius);
}
}
}
void
GetNextPoint ( gsl_matrix *pic, gsl_matrix *raw, gsl_vector *v1,
gint dx1, gint dy1, gint dx2, gint dy2, gint dx3, gint dy3,
gint *x, gint *y ) {
gsl_matrix_view view = gsl_matrix_submatrix ( raw,
gsl_vector_get ( v1, 0 ) - 1,
gsl_vector_get ( v1, 1 ) - 1, 3, 3 );
gsl_matrix_view view2 = gsl_matrix_submatrix ( pic,
gsl_vector_get ( v1, 0 ) - 1,
gsl_vector_get ( v1, 1 ) - 1, 3, 3 );
for ( int i=0; i<3; i++ ) {
for ( int j=0; j<3; j++ ) {
if ( gsl_matrix_get((gsl_matrix*)&view2,i,j) <= 5.0
|| gsl_matrix_get((gsl_matrix*)&view2,i,j) >= 250 ) {
gsl_matrix_set ( (gsl_matrix*)&view, i, j, 0 );
} else {
gsl_matrix_set ( (gsl_matrix*)&view, i, j,
gsl_matrix_get ( (gsl_matrix*)&view, i, j )
+ GetRadius ( i-1, j-1 ) * weight
+ gsl_matrix_get ( (gsl_matrix*)&view2, i, j ) * huidu );
}
}
}
gfloat x0 = gsl_vector_get ( v1, 0 );
gfloat y0 = gsl_vector_get ( v1, 1 );
gfloat f1 = gsl_matrix_get ( raw, x0+dx1, y0+dy1 );
gfloat f2 = gsl_matrix_get ( raw, x0+dx2, y0+dy2 );
gfloat f3 = gsl_matrix_get ( raw, x0+dx3, y0+dy3 );
gfloat f = f1; *x = x0 + dx1; *y = y0 + dy1;
if ( f2 > f ) f = f2, *x = x0 + dx2, *y = y0 + dy2;
if ( f3 > f ) f = f3, *x = x0 + dx3, *y = y0 + dy3;
// if ( f1 > threshold && abs(f1 - f) < threshold ) *x = x0 + dx1, *y = y0 + dy1;
}
void
TargetMapWindow::SetTarget(unsigned index)
{
GeoPoint location;
fixed radius;
{
ProtectedTaskManager::Lease lease(*task);
const OrderedTask &o_task = lease->GetOrderedTask();
if (!o_task.IsValidIndex(index))
return;
const OrderedTaskPoint &tp = o_task.GetTaskPoint(index);
location = tp.GetLocation();
radius = std::max(GetRadius(tp) * fixed(1.3), fixed(2000));
}
projection.SetGeoLocation(location);
projection.SetScaleFromRadius(radius);
projection.SetScreenAngle(Angle::Zero());
projection.UpdateScreenBounds();
target_index = index;
Invalidate();
}
///\brief
///Evaluates the bounding box of the capsule
inline void GetBoundingBox(hkvAlignedBBox &dest)
{
dest.m_vMin = m_vStartPosition;
dest.m_vMax = m_vStartPosition;
dest.expandToInclude(m_vStartPosition+m_vDirection*GetLength());
dest.addBoundary (hkvVec3 (GetRadius()));
}
UDWORD getComponentRadius(BASE_STATS *psComponent)
{
iIMDShape *ComponentIMD = nullptr;
iIMDShape *MountIMD = nullptr;
SDWORD compID;
compID = StatIsComponent(psComponent);
if (compID >= 0)
{
StatGetComponentIMD(psComponent, compID, &ComponentIMD, &MountIMD);
if (ComponentIMD)
{
return GetRadius(ComponentIMD);
}
}
/* VTOL bombs are only stats allowed to have NULL ComponentIMD */
if (StatIsComponent(psComponent) != COMP_WEAPON
|| (((WEAPON_STATS *)psComponent)->weaponSubClass != WSC_BOMB
&& ((WEAPON_STATS *)psComponent)->weaponSubClass != WSC_EMP))
{
ASSERT(ComponentIMD, "No ComponentIMD!");
}
return COMPONENT_RADIUS;
}
ObservationZone::Boundary
AnnularSectorZone::GetBoundary() const
{
Boundary boundary;
const unsigned steps = 20;
const Angle delta = Angle::FullCircle() / steps;
const Angle start = GetStartRadial().AsBearing();
Angle end = GetEndRadial().AsBearing();
if (end <= start + Angle::FullCircle() / 512)
end += Angle::FullCircle();
const GeoPoint inner_start =
GeoVector(GetInnerRadius(), GetStartRadial()).EndPoint(GetReference());
const GeoPoint inner_end =
GeoVector(GetInnerRadius(), GetEndRadial()).EndPoint(GetReference());
GeoVector inner_vector(GetInnerRadius(), start + delta);
for (; inner_vector.bearing < end; inner_vector.bearing += delta)
boundary.push_front(inner_vector.EndPoint(GetReference()));
boundary.push_front(inner_end);
boundary.push_front(inner_start);
GeoVector vector(GetRadius(), start + delta);
for (; vector.bearing < end; vector.bearing += delta)
boundary.push_front(vector.EndPoint(GetReference()));
boundary.push_front(GetSectorEnd());
boundary.push_front(GetSectorStart());
return boundary;
}
// -----------------------------------------------------------------------------
// Calculate kinematics quantities (slip angle, longitudinal slip, camber angle,
// and toe-in angle using the current state of the associated wheel body.
// -----------------------------------------------------------------------------
void ChTire::CalculateKinematics(double time, const WheelState& state, const ChTerrain& terrain) {
// Wheel normal (expressed in global frame)
ChVector<> wheel_normal = state.rot.GetYaxis();
// Terrain normal at wheel location (expressed in global frame)
ChVector<> Z_dir = terrain.GetNormal(state.pos.x(), state.pos.y());
// Longitudinal (heading) and lateral directions, in the terrain plane
ChVector<> X_dir = Vcross(wheel_normal, Z_dir);
X_dir.Normalize();
ChVector<> Y_dir = Vcross(Z_dir, X_dir);
// Tire reference coordinate system
ChMatrix33<> rot;
rot.Set_A_axis(X_dir, Y_dir, Z_dir);
ChCoordsys<> tire_csys(state.pos, rot.Get_A_quaternion());
// Express wheel linear velocity in tire frame
ChVector<> V = tire_csys.TransformDirectionParentToLocal(state.lin_vel);
// Express wheel normal in tire frame
ChVector<> n = tire_csys.TransformDirectionParentToLocal(wheel_normal);
// Slip angle
double abs_Vx = std::abs(V.x());
double zero_Vx = 1e-4;
m_slip_angle = (abs_Vx > zero_Vx) ? std::atan(V.y() / abs_Vx) : 0;
// Longitudinal slip
m_longitudinal_slip = (abs_Vx > zero_Vx) ? -(V.x() - state.omega * GetRadius()) / abs_Vx : 0;
// Camber angle
m_camber_angle = std::atan2(n.z(), n.y());
}
bool
SectorZone::IsInSector(const GeoPoint &location) const
{
GeoVector f(GetReference(), location);
return f.distance <= GetRadius() && IsAngleInSector(f.bearing);
}
void DynamicObject::Update(uint32 p_time)
{
// caster can be not in world at time dynamic object update, but dynamic object not yet deleted in Unit destructor
Unit* caster = GetCaster();
if (!caster)
{
Delete();
return;
}
bool deleteThis = false;
if (m_aliveDuration > int32(p_time))
m_aliveDuration -= p_time;
else
deleteThis = true;
if (m_effIndex < 4)
{
if (m_updateTimer < p_time)
{
Oregon::DynamicObjectUpdater notifier(*this,caster);
VisitNearbyObject(GetRadius(), notifier);
m_updateTimer = 500; // is this official-like?
}else m_updateTimer -= p_time;
}
if (deleteThis)
{
caster->RemoveDynObjectWithGUID(GetGUID());
Delete();
}
}
bool
CylinderZone::Equals(const ObservationZonePoint &other) const
{
const CylinderZone &z = (const CylinderZone &)other;
return ObservationZonePoint::Equals(other) && GetRadius() == z.GetRadius();
}
bool CollisionSystem::IsColliding(std::shared_ptr<Entity> entity1,
std::shared_ptr<Entity> entity2)
{
auto colliderComponent1 = std::static_pointer_cast<ColliderComponent>(Engine::GetInstance().GetSingleComponentOfClass(entity1, "ColliderComponent"));
auto colliderComponent2 = std::static_pointer_cast<ColliderComponent>(Engine::GetInstance().GetSingleComponentOfClass(entity2, "ColliderComponent"));
auto particleComponent1 = std::static_pointer_cast<ParticleComponent>(Engine::GetInstance().GetSingleComponentOfClass(entity1, "ParticleComponent"));
auto particleComponent2 = std::static_pointer_cast<ParticleComponent>(Engine::GetInstance().GetSingleComponentOfClass(entity2, "ParticleComponent"));
float radius1 = colliderComponent1->GetRadius();
float radius2 = colliderComponent2->GetRadius();
Vector position1 = particleComponent1->GetPosition();
Vector position2 = particleComponent2->GetPosition();
float distance = position1.CalculateDistance(position2);
if (distance < (radius1 + radius2))
return true;
return false;
}
bool Collision2D::IsWithinRadius(const sf::Sprite& sprite1, const sf::Sprite& sprite2, const float radius1)
{
// Check for a collision
const sf::Vector2f kfCenterSubtraction = GetCenter(sprite1) - GetCenter(sprite2);
const float kfMagnitude = Maths2D::Magnitude(kfCenterSubtraction);
const float kfRadiiSum = radius1 + GetRadius(sprite2);
return kfMagnitude < kfRadiiSum;
}
void meRingCut::GetNormal( double normal[3] )
{
GetRadius();
for(int i=0; i<3; i++)
{
normal[i] = this->m_Normal[i];
}
}
void meRingCut::GetCenter( double center[3] )
{
GetRadius();
for(int i=0; i<3; i++)
{
center[i] = this->m_PointCoordinates[i];
}
}
/*
* \brief Does this bounding box intersect with another
*/
const bool CSpaghettiBoundsSphere::Intersects(
CSpaghettiBounds *other, //!< The bounding box to test against
std::vector<CCollision> &collision
)
{
if (other->GetType() == BoundsType::Box)
{
// Sphere on box
const bool result = other->Intersects(this, collision);
if (!result)
return false;
return true;
}
else if (other->GetType() == BoundsType::Sphere)
{
// Sphere on sphere
CSpaghettiBoundsSphere *const otherSphere = static_cast<CSpaghettiBoundsSphere*>(other);
const float distance = (m_position - otherSphere->GetPosition()).length();
const float radius = GetRadius() + otherSphere->GetRadius();
if (distance <= radius)
{
Ogre::Vector3 collisionNormal = otherSphere->GetPosition() - GetPosition();
collisionNormal.normalise();
Ogre::Vector3 collisionPoint =collisionNormal * GetRadius();
CCollision newCollision;
newCollision.bodyOne = GetBody();
newCollision.bodyTwo = otherSphere->GetBody();
newCollision.collisionNormal = collisionNormal;
newCollision.collisionPoint = GetPosition() + collisionPoint;
newCollision.penetration = radius - distance;
collision.push_back(newCollision);
return true;
}
return false;
}
return false;
}
void Body::Draw(){
if(big){
graphics->ScaleImage(img, game->GetScaleFactor() * 1.2f);
}else{
graphics->ScaleImage(img, game->GetScaleFactor());
}
graphics->DrawImage(GetPosition(), img);
graphics->DrawCircle(GetPosition(), GetRadius(), Color::Blue);
}
bool
AnnularSectorZone::IsInSector(const GeoPoint &location) const
{
GeoVector f(GetReference(), location);
return (f.distance <= GetRadius()) &&
(f.distance >= inner_radius) &&
IsAngleInSector(f.bearing);
}
string CCone::GetInfo() const
{
string info = GetName() + '\n' +
"height = " + to_string(GetHeight()) + '\n' +
"radius = " + to_string(GetRadius()) + '\n' +
"value = " + to_string(GetVolume()) + '\n' +
"mass = " + to_string(GetMass());
return info;
}
bool
AnnularSectorZone::IsInSector(const AircraftState &ref) const
{
GeoVector f(GetReference(), ref.location);
return (f.distance <= GetRadius()) &&
(f.distance >= inner_radius) &&
IsAngleInSector(f.bearing);
}
void CollisionMesh::DrawDiagnostics()
{
if(m_draw && m_geometry &&
m_engine->diagnostic()->AllowDiagnostics(Diagnostic::MESH))
{
// Render world vertices
const std::string id = StringCast(this);
const float vertexRadius = 0.1f;
const auto& vertices = GetVertices();
for(unsigned int i = 0; i < vertices.size(); ++i)
{
m_engine->diagnostic()->UpdateSphere(Diagnostic::MESH,
"0" + StringCast(i) + id, Diagnostic::RED,
vertices[i], vertexRadius);
}
// Render face normals
m_geometry->UpdateDiagnostics(*m_engine->diagnostic(), m_world.GetMatrix());
// Render OABB for diagnostic mesh
auto getPointColor = [=](int index) -> Diagnostic::Colour
{
return index == MINBOUND || index == MAXBOUND ?
Diagnostic::BLUE : Diagnostic::MAGENTA;
};
const float radius = 0.2f;
std::string corner;
for(unsigned int i = 0; i < CORNERS/2; ++i)
{
corner = StringCast(i);
m_engine->diagnostic()->UpdateSphere(Diagnostic::MESH,
"CornerA" + corner + id, getPointColor(i), m_oabb[i], radius);
m_engine->diagnostic()->UpdateSphere(Diagnostic::MESH,
"CornerB" + corner + id, getPointColor(i+4), m_oabb[i+4], radius);
m_engine->diagnostic()->UpdateLine(Diagnostic::MESH,
"LineA" + corner + id, Diagnostic::MAGENTA,
m_oabb[i], m_oabb[i+1 >= 4 ? 0 : i+1]);
m_engine->diagnostic()->UpdateLine(Diagnostic::MESH,
"LineB" + corner + id, Diagnostic::MAGENTA,
m_oabb[i+4], m_oabb[i+5 >= CORNERS ? 4 : i+5]);
m_engine->diagnostic()->UpdateLine(Diagnostic::MESH,
"LineC" + corner + id, Diagnostic::MAGENTA,
m_oabb[i], m_oabb[i+4]);
}
// Render radius of diagnostic mesh in wireframe
m_engine->diagnostic()->UpdateSphere(Diagnostic::MESH,
"Radius" + id, Diagnostic::WHITE, GetPosition(), GetRadius());
}
}
std::string CCylinder::GetInfo() const
{
std::ostringstream info;
info << "Cylinder with base radius " << GetRadius();
info << ", height " << GetHeight();
info << " and density " << GetDensity();
return info.str();
}
void FGPropagate::UpdateVehicleState(void)
{
RecomputeLocalTerrainVelocity();
VehicleRadius = GetRadius();
VState.vInertialPosition = Tec2i * VState.vLocation;
UpdateLocationMatrices();
UpdateBodyMatrices();
vVel = Tb2l * VState.vUVW;
VState.qAttitudeLocal = Tl2b.GetQuaternion();
}
std::string CCone::GetInformation() const
{
std::ostringstream info;
info << "Cone with base radius " << GetRadius();
info << ", height " << GetHeight();
info << " and density " << GetDensity();
return info.str();
}
double FGLocation::GetDistanceTo(double target_longitude,
double target_latitude) const
{
double delta_lat_rad = target_latitude - GetLatitude();
double delta_lon_rad = target_longitude - GetLongitude();
double distance_a = pow(sin(0.5*delta_lat_rad), 2.0)
+ (GetCosLatitude() * cos(target_latitude)
* (pow(sin(0.5*delta_lon_rad), 2.0)));
return 2.0 * GetRadius() * atan2(sqrt(distance_a), sqrt(1.0 - distance_a));
}
void cStructGenWormNestCaves::cCaveSystem::GenerateTunnelsFromPoint(
int a_OriginX, int a_OriginY, int a_OriginZ,
cNoise & a_Noise, int a_NumSegments
)
{
int DoubleSize = m_Size * 2;
int Radius = GetRadius(a_Noise, a_OriginX + a_OriginY, a_OriginY + a_OriginZ, a_OriginZ + a_OriginX);
for (int i = a_NumSegments - 1; i >= 0; --i)
{
int EndX = a_OriginX + (((a_Noise.IntNoise3DInt(a_OriginX, a_OriginY, a_OriginZ + 11 * a_NumSegments) / 7) % DoubleSize) - m_Size) / 2;
int EndY = a_OriginY + (((a_Noise.IntNoise3DInt(a_OriginY, 13 * a_NumSegments, a_OriginZ + a_OriginX) / 7) % DoubleSize) - m_Size) / 4;
int EndZ = a_OriginZ + (((a_Noise.IntNoise3DInt(a_OriginZ + 17 * a_NumSegments, a_OriginX, a_OriginY) / 7) % DoubleSize) - m_Size) / 2;
int EndR = GetRadius(a_Noise, a_OriginX + 7 * i, a_OriginY + 11 * i, a_OriginZ + a_OriginX);
m_Tunnels.push_back(new cCaveTunnel(a_OriginX, a_OriginY, a_OriginZ, Radius, EndX, EndY, EndZ, EndR, a_Noise));
GenerateTunnelsFromPoint(EndX, EndY, EndZ, a_Noise, i);
a_OriginX = EndX;
a_OriginY = EndY;
a_OriginZ = EndZ;
Radius = EndR;
} // for i - a_NumSegments
}
