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;
}
