void conv(quad_float& z, const ZZ& a) { double xhi, xlo; conv(xhi, a); if (!IsFinite(&xhi)) { z.hi = xhi; z.lo = 0; return; } static ZZ t; conv(t, xhi); sub(t, a, t); conv(xlo, t); normalize(z, xhi, xlo); // The following is just paranoia. if (fabs(z.hi) < NTL_FDOUBLE_PRECISION && z.lo != 0) Error("internal error: ZZ to quad_float conversion"); }
static float calculateNormalizationScale(ThreadSharedFloatArrayBufferList* response, size_t aLength, float sampleRate) { // Normalize by RMS power size_t numberOfChannels = response->GetChannels(); float power = 0; for (size_t i = 0; i < numberOfChannels; ++i) { float channelPower = AudioBufferSumOfSquares(static_cast<const float*>(response->GetData(i)), aLength); power += channelPower; } power = sqrt(power / (numberOfChannels * aLength)); // Protect against accidental overload if (!IsFinite(power) || IsNaN(power) || power < MinPower) power = MinPower; float scale = 1 / power; scale *= powf(10, GainCalibration * 0.05f); // calibrate to make perceived volume same as unprocessed // Scale depends on sample-rate. if (sampleRate) scale *= GainCalibrationSampleRate / sampleRate; // True-stereo compensation if (response->GetChannels() == 4) scale *= 0.5f; return scale; }
ON_RevSurface* ON_Cylinder::RevSurfaceForm( ON_RevSurface* srf ) const { if ( srf ) srf->Destroy(); ON_RevSurface* pRevSurface = NULL; if ( IsFinite() && IsValid() ) { ON_Line line; line.from = PointAt(0.0,height[0]); line.to = PointAt(0.0,height[1]); ON_Interval h(height[0],height[1]); // h = evaluation domain for line (must be increasing) if ( h.IsDecreasing() ) h.Swap(); ON_LineCurve* line_curve = new ON_LineCurve( line, h[0], h[1] ); if ( srf ) pRevSurface = srf; else pRevSurface = new ON_RevSurface(); pRevSurface->m_angle.Set(0.0,2.0*ON_PI); pRevSurface->m_t = pRevSurface->m_angle; pRevSurface->m_curve = line_curve; pRevSurface->m_axis.from = circle.plane.origin; pRevSurface->m_axis.to = circle.plane.origin + circle.plane.zaxis; pRevSurface->m_bTransposed = false; ON_Circle c0(circle); c0.Translate(height[0]*circle.plane.zaxis); ON_Circle c1(circle); c1.Translate(height[1]*circle.plane.zaxis); pRevSurface->m_bbox = c0.BoundingBox(); pRevSurface->m_bbox.Union(c1.BoundingBox()); } return pRevSurface; }
// ---------------------------------------------------------------------- // // Proxies. // ---------------------------------------------------------------------- // void SendProxy_AngleToFloat( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID) { float angle; angle = *((float*)pData); pOut->m_Float = anglemod( angle ); Assert( IsFinite( pOut->m_Float ) ); }
FundamentalValue::FundamentalValue(double in_value) : Value(TYPE_DOUBLE), double_value_(in_value) { if(!IsFinite(double_value_)) { NOTREACHED() << "Non-finite (i.e. NaN or positive/negative infinity) " << "values cannot be represented in JSON"; double_value_ = 0.0; } }
bool IsArrayValid(const int size, const double* x) { if (x != NULL) { for (int i = 0; i < size; ++i) { if (!IsFinite(x[i]) || (x[i] == kImpossibleValue)) { return false; } } } return true; }
float SVGLength::GetValueInSpecifiedUnit(uint8_t aUnit, const nsSVGElement *aElement, uint8_t aAxis) const { if (aUnit == mUnit) { return mValue; } if ((aUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER && mUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_PX) || (aUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_PX && mUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER)) { return mValue; } if (IsAbsoluteUnit(aUnit) && IsAbsoluteUnit(mUnit)) { return mValue * GetAbsUnitsPerAbsUnit(aUnit, mUnit); } // Otherwise we do a two step convertion via user units. This can only // succeed if aElement is non-null (although that's not sufficent to // guarantee success). float userUnitsPerCurrentUnit = GetUserUnitsPerUnit(aElement, aAxis); float userUnitsPerNewUnit = SVGLength(0.0f, aUnit).GetUserUnitsPerUnit(aElement, aAxis); NS_ASSERTION(userUnitsPerCurrentUnit >= 0 || !IsFinite(userUnitsPerCurrentUnit), "bad userUnitsPerCurrentUnit"); NS_ASSERTION(userUnitsPerNewUnit >= 0 || !IsFinite(userUnitsPerNewUnit), "bad userUnitsPerNewUnit"); float value = mValue * userUnitsPerCurrentUnit / userUnitsPerNewUnit; // userUnitsPerCurrentUnit could be infinity, or userUnitsPerNewUnit could // be zero. if (IsFinite(value)) { return value; } return std::numeric_limits<float>::quiet_NaN(); }
NS_IMETHODIMP DOMSVGLength::SetValueInSpecifiedUnits(float aValue) { if (!IsFinite(aValue)) { return NS_ERROR_ILLEGAL_VALUE; } ErrorResult rv; SetValueInSpecifiedUnits(aValue, rv); return rv.StealNSResult(); }
NS_IMETHODIMP DOMSVGLength::NewValueSpecifiedUnits(uint16_t aUnit, float aValue) { if (!IsFinite(aValue)) { return NS_ERROR_ILLEGAL_VALUE; } ErrorResult rv; NewValueSpecifiedUnits(aUnit, aValue, rv); return rv.StealNSResult(); }
void DOMSVGLength::ConvertToSpecifiedUnits(uint16_t aUnit, ErrorResult& aRv) { if (mIsAnimValItem) { aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (mVal) { mVal->ConvertToSpecifiedUnits(aUnit, mSVGElement); return; } if (!SVGLength::IsValidUnitType(aUnit)) { aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); return; } if (HasOwner()) { if (InternalItem().GetUnit() == aUnit) { return; } float val = InternalItem().GetValueInSpecifiedUnit( aUnit, Element(), Axis()); if (IsFinite(val)) { AutoChangeLengthNotifier notifier(this); InternalItem().SetValueAndUnit(val, aUnit); return; } } else { SVGLength len(mValue, mUnit); float val = len.GetValueInSpecifiedUnit(aUnit, nullptr, 0); if (IsFinite(val)) { mValue = val; mUnit = aUnit; return; } } // else [SVGWG issue] Can't convert unit // ReportToConsole aRv.Throw(NS_ERROR_FAILURE); }
std::string ToMathematica(Quantity<D> const& quantity) { std::string s = DebugString(quantity); if (IsFinite(quantity)) { s.replace(s.find("e"), 1, "*^"); } std::string const number = ToMathematica(quantity / SIUnit<Quantity<D>>()); std::size_t const split = s.find(" "); std::string const units = Escape(s.substr(split, s.size())); return Apply( "SetPrecision", {Apply("Quantity", {number, units}), "MachinePrecision"}); }
void ViewerRenderer::SetCamera(float* cameraPosition, float* cameraTarget, float* cameraUp) { Normalize( cameraUp ); bool good_numbers = true; for ( int i = 0; i < 3 && good_numbers; i++ ) { if ( ! IsANumber( cameraPosition[ i ] ) || ! IsFinite( cameraPosition[ i ] ) ) good_numbers = false; if ( ! IsANumber( cameraTarget[ i ] ) || ! IsFinite( cameraTarget[ i ] ) ) good_numbers = false; if ( ! IsANumber( cameraUp[ i ] ) || ! IsFinite( cameraUp[ i ] ) ) good_numbers = false; } if ( ! good_numbers ) return; float viewVector[ 3 ]; Normalize( Subtract( cameraTarget, cameraPosition, viewVector ) ); if ( Length( viewVector ) < 0.0001 ) return; // Can't have cameraPosition == cameraTarget float dot = DotProduct( viewVector, cameraUp ); if ( dot < -0.999f || 0.999f < dot ) return; // Can't have view vector parallel to up vector if ( dot < -.1 || 1 < dot ) { // Change the up vector to form a 90 degree angle with the view vector... float cameraRight[ 3 ]; CrossProduct( viewVector, cameraUp, cameraRight ); CrossProduct( cameraRight, viewVector, cameraUp ); dot = DotProduct( viewVector, cameraUp ); if ( dot < -0.999f || 0.999f < dot ) return; // Can't have view vector parallel to up vector } for (int i = 0; i < 3; i++) { _cameraPosition[i] = cameraPosition[i]; _cameraTarget[i] = cameraTarget[i]; _cameraUp[i] = cameraUp[i]; } }
already_AddRefed<SVGMatrix> SVGMatrix::SkewX(float angle, ErrorResult& rv) { double ta = tan(angle * radPerDegree); if (!IsFinite(ta)) { rv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR); return nullptr; } const gfxMatrix& mx = GetMatrix(); gfxMatrix skewMx(mx._11, mx._12, (float)(mx._21 + mx._11 * ta), (float)(mx._22 + mx._12 * ta), mx._31, mx._32); RefPtr<SVGMatrix> matrix = new SVGMatrix(skewMx); return matrix.forget(); }
void CSDKGameRules::ServerActivate() { //Tony; initialize the level CheckLevelInitialized(); //Tony; do any post stuff m_flGameStartTime = gpGlobals->curtime; if ( !IsFinite( m_flGameStartTime.Get() ) ) { Warning( "Trying to set a NaN game start time\n" ); m_flGameStartTime.GetForModify() = 0.0f; } }
float3 Capsule::RandomPointInside(LCG &rng) const { assume(IsFinite()); OBB obb = MinimalEnclosingOBB(); for(int i = 0; i < 1000; ++i) { float3 pt = obb.RandomPointInside(rng); if (Contains(pt)) return pt; } assume(false && "Warning: Capsule::RandomPointInside ran out of iterations to perform!"); return Center(); // Just return some point that is known to be inside. }
//----------------------------------------------------------------------------- // Builds a rotation matrix that rotates one direction vector into another //----------------------------------------------------------------------------- void MatrixBuildRotation( VMatrix &dst, const Vector& initialDirection, const Vector& finalDirection ) { float angle = DotProduct( initialDirection, finalDirection ); assert( IsFinite(angle) ); Vector axis; // No rotation required if (angle - 1.0 > -1e-3) { // parallel case MatrixSetIdentity(dst); return; } else if (angle + 1.0 < 1e-3) { // antiparallel case, pick any axis in the plane // perpendicular to the final direction. Choose the direction (x,y,z) // which has the minimum component of the final direction, use that // as an initial guess, then subtract out the component which is // parallel to the final direction int idx = 0; if (FloatMakePositive(finalDirection[1]) < FloatMakePositive(finalDirection[idx])) idx = 1; if (FloatMakePositive(finalDirection[2]) < FloatMakePositive(finalDirection[idx])) idx = 2; axis.Init( 0, 0, 0 ); axis[idx] = 1.0f; VectorMA( axis, -DotProduct( axis, finalDirection ), finalDirection, axis ); VectorNormalize(axis); angle = 180.0f; } else { CrossProduct( initialDirection, finalDirection, axis ); VectorNormalize( axis ); angle = acos(angle) * 180 / M_PI; } MatrixBuildRotationAboutAxis( dst, axis, angle ); #ifdef _DEBUG Vector test; Vector3DMultiply( dst, initialDirection, test ); test -= finalDirection; assert( test.LengthSqr() < 1e-3 ); #endif }
void Standard_model_low_scale_constraint<Two_scale>::apply() { assert(model && "Error: Standard_model_low_scale_constraint::apply():" " model pointer must not be zero"); qedqcd.runto(scale, 1.0e-5); model->calculate_DRbar_masses(); const double alpha_em = qedqcd.displayAlpha(softsusy::ALPHA); const double alpha_s = qedqcd.displayAlpha(softsusy::ALPHAS); const double mz_pole = qedqcd.displayPoleMZ(); double delta_alpha_em = 0.; double delta_alpha_s = 0.; if (model->get_thresholds()) { delta_alpha_em = model->calculate_delta_alpha_em(alpha_em); delta_alpha_s = model->calculate_delta_alpha_s(alpha_s); } const double alpha_em_drbar = alpha_em / (1.0 - delta_alpha_em); const double alpha_s_drbar = alpha_s / (1.0 - delta_alpha_s); const double e_drbar = Sqrt(4.0 * Pi * alpha_em_drbar); const double g1 = model->get_g1(); const double g2 = model->get_g2(); const double mZ = model->get_thresholds() ? model->calculate_MVZ_DRbar(mz_pole) : mz_pole; double theta_w = model->calculate_theta_w(qedqcd, alpha_em_drbar); if (IsFinite(theta_w)) { model->get_problems().unflag_non_perturbative_parameter( "sin(theta_W)"); } else { model->get_problems().flag_non_perturbative_parameter( "sin(theta_W)", theta_w, get_scale(), 0); theta_w = ArcSin(Electroweak_constants::sinThetaW); } model->set_v(Re((2*mZ)/Sqrt(0.6*Sqr(g1) + Sqr(g2)))); model->calculate_Yu_DRbar(qedqcd); model->calculate_Yd_DRbar(qedqcd); model->calculate_Ye_DRbar(qedqcd); model->set_g1(1.2909944487358056*e_drbar*Sec(theta_w)); model->set_g2(e_drbar*Csc(theta_w)); model->set_g3(3.5449077018110318*Sqrt(alpha_s_drbar)); if (model->get_thresholds()) qedqcd.setPoleMW(model->recalculate_mw_pole(qedqcd.displayPoleMW())); }
bool LineSearchFunction::Evaluate(const double x, double* f, double* g) { scaled_direction_ = x * direction_; if (!evaluator_->Plus(position_.data(), scaled_direction_.data(), evaluation_point_.data())) { return false; } if (g == NULL) { return (evaluator_->Evaluate(evaluation_point_.data(), f, NULL, NULL, NULL) && IsFinite(*f)); } if (!evaluator_->Evaluate(evaluation_point_.data(), f, NULL, gradient_.data(), NULL)) { return false; } *g = direction_.dot(gradient_); return IsFinite(*f) && IsFinite(*g); }
void CSheetSimulator::EulerStep( float dt ) { ClearForces(); ComputeForces(); // Update positions and velocities for ( int i = 0; i < NumParticles(); ++i) { m_Particle[i].m_Position += m_Particle[i].m_Velocity * dt; m_Particle[i].m_Velocity += m_Particle[i].m_Force * dt / m_Particle[i].m_Mass; Assert( IsFinite( m_Particle[i].m_Velocity.x ) && IsFinite( m_Particle[i].m_Velocity.y) && IsFinite( m_Particle[i].m_Velocity.z) ); // clamp for stability float lensq = m_Particle[i].m_Velocity.LengthSqr(); if (lensq > 1e6) { m_Particle[i].m_Velocity *= 1e3 / sqrt(lensq); } } SatisfyCollisionConstraints(); }
xdouble to_xdouble(double a) { if (a == 0 || a == 1 || (a > 0 && a >= NTL_XD_HBOUND_INV && a <= NTL_XD_HBOUND) || (a < 0 && a <= -NTL_XD_HBOUND_INV && a >= -NTL_XD_HBOUND)) { return xdouble(a, 0); } if (!IsFinite(&a)) ArithmeticError("double to xdouble conversion: non finite value"); xdouble z = xdouble(a, 0); z.normalize(); return z; }
void CNPC_Hydra::CheckLength( ) { int i; ClearCondition( COND_HYDRA_SNAGGED ); ClearCondition( COND_HYDRA_NOSTUCK ); ClearCondition( COND_HYDRA_OVERSTRETCH ); m_bHasStuckSegments = m_body[m_body.Count() - 1].bStuck; m_flCurrentLength = 0; for (i = 1; i < m_body.Count() - 1; i++) { float length = (m_body[i+1].vecPos - m_body[i].vecPos).Length(); Assert( m_body[i+1].vecPos.IsValid( ) ); Assert( m_body[i].vecPos.IsValid( ) ); Assert( IsFinite( length ) ); m_body[i].flActualLength = length; m_flCurrentLength += length; // check for over streatched segements if (length > m_idealSegmentLength * 3.0 && (m_body[i].bStuck || m_body[i+1].bStuck)) { //NDebugOverlay::Line( m_body[i].vecPos, m_body[i+1].vecPos, 255, 0, 0, true, 1.0); SetCondition( COND_HYDRA_SNAGGED ); } if (m_body[i].bStuck) { m_bHasStuckSegments = true; } } if (m_flCurrentLength > HYDRA_MAX_LENGTH) // FIXME { SetCondition( COND_HYDRA_OVERSTRETCH ); } if (!m_bHasStuckSegments) { SetCondition( COND_HYDRA_NOSTUCK ); } }
//---------------------------------------------------------------------------- bool GpuLocalSolver3::OnPostIteration (uint64_t) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFrameBuffer[mActive[1]]); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); glReadPixels(0, 0, mBound[0], mBound[1], GL_RED, GL_FLOAT, mReadBack); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glReadBuffer(GL_BACK); for (int i = 0; i < mNumTexels; ++i) { if (!IsFinite(mReadBack[i])) { return false; } } return true; }
float vParticleImpulseGen::GetImpulse( vParticle *parent ) { Assert( parent != NULL ); float val = 0; switch ( mode ) { case PARTICLEIMPULSEGENERATOR_FRAMETIME: val = CFrameTimeHelper::GetFrameTime() * impulse_multiplier; break; case PARTICLEIMPULSEGENERATOR_LIFETIME_LINEAR: val = NORMALIZE( ( CFrameTimeHelper::GetCurrentTime() - parent->GetCreationTime() ) / parent->GetLifeDuration() ) * impulse_multiplier; break; case PARTICLEIMPULSEGENERATOR_LIFETIME_SINE: val = NORMALIZE( ( CFrameTimeHelper::GetCurrentTime() - parent->GetCreationTime() ) / parent->GetLifeDuration() ); val = NORMALIZE( abs( sin( M_PI_F * val * impulse_multiplier ) ) ); break; case PARTICLEIMPULSEGENERATOR_VELOCITY_LINEAR: val = parent->vecVelocity.Length() * impulse_multiplier; break; case PARTICLEIMPULSEGENERATOR_ANGULAR_VELOCITY_LINEAR: val = abs( parent->flAngularVelocity ) * impulse_multiplier; break; case PARTICLEIMPULSEGENERATOR_CURTIME_SINE: val = NORMALIZE( abs( sin( M_PI_F * CFrameTimeHelper::GetCurrentTime() * impulse_multiplier ) ) ); break; case PARTICLEIMPULSEGENERATOR_CURTIME_SINE_SIGNED: val = ( ( sin( M_PI_F * CFrameTimeHelper::GetCurrentTime() * impulse_multiplier ) ) ); break; default: Assert(0); break; } Assert( IsFinite(val) ); float sign = Sign( val ); val = sign * Bias( abs(val), impulse_bias ); val = RemapVal( val, 0.0f, 1.0f, reference_min, reference_max ); return val; }
//---------------------------------------------------------------------------- bool NonlocalSolver2::OnPostIteration (uint64_t) { // The output of the last pass is u1; copy to u0. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFrameBuffer[mActive[1]]); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); glBindTexture(GL_TEXTURE_2D, mTexture[mActive[0]]); glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 0, 0, mDimension[0], mDimension[1], 0); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glReadBuffer(GL_BACK); // Get the maximum of u1. Both u1 and u2 are overwritten. if (!mMaxPyramid.Use(mTexture[mActive[1]], mTexture[mActive[2]], mFrameBuffer[mActive[1]], mFrameBuffer[mActive[2]])) { return false; } if (!mMaxPyramid.Execute()) { return false; } float umax = mMaxPyramid.GetMaximum(); // Copy to u0 to u1 and u2, so now u0, u1 and u2 are equal for the next // pass. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFrameBuffer[mActive[0]]); glReadBuffer(GL_COLOR_ATTACHMENT0_EXT); glReadPixels(0, 0, mDimension[0], mDimension[1], GL_RED, GL_FLOAT, mReadBack); glBindTexture(GL_TEXTURE_2D, mTexture[mActive[1]]); glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 0, 0, mDimension[0], mDimension[1], 0); glBindTexture(GL_TEXTURE_2D, mTexture[mActive[2]]); glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 0, 0, mDimension[0], mDimension[1], 0); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glReadBuffer(GL_BACK); Enable(); glUniform2f(mNonlinearLocation, mNonlinear0, mNonlinear1); return IsFinite(umax); }
uint32_t HTMLImageElement::NaturalHeight() { uint32_t height; nsresult rv = nsImageLoadingContent::GetNaturalHeight(&height); if (NS_FAILED(rv)) { MOZ_ASSERT(false, "GetNaturalHeight should not fail"); return 0; } if (mResponsiveSelector) { double density = mResponsiveSelector->GetSelectedImageDensity(); MOZ_ASSERT(IsFinite(density) && density > 0.0); height = NSToIntRound(double(height) / density); height = std::max(height, 0u); } return height; }
uint32_t HTMLImageElement::NaturalWidth() { uint32_t width; nsresult rv = nsImageLoadingContent::GetNaturalWidth(&width); if (NS_FAILED(rv)) { MOZ_ASSERT(false, "GetNaturalWidth should not fail"); return 0; } if (mResponsiveSelector) { double density = mResponsiveSelector->GetSelectedImageDensity(); MOZ_ASSERT(IsFinite(density) && density > 0.0); width = NSToIntRound(double(width) / density); width = std::max(width, 0u); } return width; }
void DOMSVGLength::SetValue(float aUserUnitValue, ErrorResult& aRv) { if (mIsAnimValItem) { aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (mVal) { mVal->SetBaseValue(aUserUnitValue, mSVGElement, true); return; } // Although the value passed in is in user units, this method does not turn // this length into a user unit length. Instead it converts the user unit // value to this length's current unit and sets that, leaving this length's // unit as it is. if (HasOwner()) { if (InternalItem().GetValueInUserUnits(Element(), Axis()) == aUserUnitValue) { return; } float uuPerUnit = InternalItem().GetUserUnitsPerUnit(Element(), Axis()); if (uuPerUnit > 0) { float newValue = aUserUnitValue / uuPerUnit; if (IsFinite(newValue)) { AutoChangeLengthNotifier notifier(this); InternalItem().SetValueAndUnit(newValue, InternalItem().GetUnit()); return; } } } else if (mUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER || mUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_PX) { mValue = aUserUnitValue; return; } // else [SVGWG issue] Can't convert user unit value to this length's unit // ReportToConsole aRv.Throw(NS_ERROR_FAILURE); }
void SVGTransform::SetSkewY(float angle, ErrorResult& rv) { if (mIsAnimValItem) { rv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (Transform().Type() == SVG_TRANSFORM_SKEWY && Transform().Angle() == angle) { return; } if (!IsFinite(tan(angle * kRadPerDegree))) { rv.Throw(NS_ERROR_RANGE_ERR); return; } AutoChangeTransformNotifier notifier(this); DebugOnly<nsresult> result = Transform().SetSkewY(angle); MOZ_ASSERT(NS_SUCCEEDED(result), "SetSkewY unexpectedly failed"); }
OBB Frustum::MinimalEnclosingOBB(float expandGuardband) const { assume(IsFinite()); assume(front.IsNormalized()); assume(up.IsNormalized()); OBB obb; obb.pos = pos + (nearPlaneDistance + farPlaneDistance) * 0.5f * front; obb.axis[1] = up; obb.axis[2] = -front; obb.axis[0] = Cross(obb.axis[1], obb.axis[2]); obb.r = float3::zero; for(int i = 0; i < 8; ++i) obb.Enclose(CornerPoint(i)); // Expand the generated OBB very slightly to avoid numerical issues when // testing whether this Frustum actually is contained inside the generated OBB. obb.r.x += expandGuardband; obb.r.y += expandGuardband; obb.r.z += expandGuardband; return obb; }
ostream& operator<<(ostream& s, const quad_float& a) { quad_float aa = a; if (!IsFinite(&aa)) { s << "NaN"; return s; } RRPush push; RROutputPush opush; RR::SetPrecision(long(3.33*quad_float::oprec) + 10); RR::SetOutputPrecision(quad_float::oprec); NTL_TLS_LOCAL(RR, t); conv(t, a); s << t; return s; }