nsresult SVGPathSegListSMILType::Add(SMILValue& aDest,
                                     const SMILValue& aValueToAdd,
                                     uint32_t aCount) const {
  MOZ_ASSERT(aDest.mType == this, "Unexpected SMIL type");
  MOZ_ASSERT(aValueToAdd.mType == this, "Incompatible SMIL type");

  SVGPathDataAndInfo& dest = *static_cast<SVGPathDataAndInfo*>(aDest.mU.mPtr);
  const SVGPathDataAndInfo& valueToAdd =
      *static_cast<const SVGPathDataAndInfo*>(aValueToAdd.mU.mPtr);

  if (valueToAdd.IsIdentity()) {  // Adding identity value - no-op
    return NS_OK;
  }

  if (!dest.IsIdentity()) {
    // Neither value is identity; make sure they're compatible.
    MOZ_ASSERT(dest.Element() == valueToAdd.Element(),
               "adding values from different elements...?");

    PathInterpolationResult check = CanInterpolate(dest, valueToAdd);
    if (check == eCannotInterpolate) {
      // SVGContentUtils::ReportToConsole - can't add path segment lists with
      // different numbers of segments, with arcs that have different flag
      // values, or with incompatible segment types.
      return NS_ERROR_FAILURE;
    }
    if (check == eRequiresConversion) {
      // Convert dest, in-place, to match the types in valueToAdd:
      ConvertAllPathSegmentData(dest.begin(), dest.end(), valueToAdd.begin(),
                                valueToAdd.end(), dest.begin());
    }
  }

  return AddWeightedPathSegLists(1.0, dest, aCount, valueToAdd, dest);
}
Exemplo n.º 2
0
double TLinear::Interpolate(const uint64& Tm) const {
	AssertR(CanInterpolate(Tm), "TLinear::Interpolate: Time not in the desired interval!");

	const TUInt64FltPr& PrevRec = Buff.GetOldest();
	if (Tm == PrevRec.Val1) { return PrevRec.Val2; }
	const TUInt64FltPr& NextRec = Buff.GetOldest(1);

	// don't need to check if the times of the previous rec and next rec are equal since if
	// that is true Tm will be equal to PrevRec.Tm and the correct result will be returned
	const double Result = PrevRec.Val2 + ((double) (Tm - PrevRec.Val1) / (NextRec.Val1 - PrevRec.Val1)) * (NextRec.Val2 - PrevRec.Val2);
	EAssertR(!TFlt::IsNan(Result), "TLinear: result of interpolation is NaN!");
	return Result;
}
Exemplo n.º 3
0
void TCurrentPoint::SetNextInterpTm(const uint64& Tm) {
	// at least one past (or current time) record needs to be in the buffer
	bool Change = false;
	while (Buff.Len() >= 2 && Buff.GetOldest(1).Val1 <= Tm) {
		Buff.DelOldest();
		Change = true;
	}
	if (Change) {
		EAssertR(CanInterpolate(Tm), "WTF!? Current point interpolator cannot intrpolate after setting new time!");
	}
	// when the loop finishes we have at least 1 record in the buffer
	// with a timestamp <= Tm
}
nsresult SVGPathSegListSMILType::Interpolate(const SMILValue& aStartVal,
                                             const SMILValue& aEndVal,
                                             double aUnitDistance,
                                             SMILValue& aResult) const {
  MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
             "Trying to interpolate different types");
  MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
  MOZ_ASSERT(aResult.mType == this, "Unexpected result type");

  const SVGPathDataAndInfo& start =
      *static_cast<const SVGPathDataAndInfo*>(aStartVal.mU.mPtr);
  const SVGPathDataAndInfo& end =
      *static_cast<const SVGPathDataAndInfo*>(aEndVal.mU.mPtr);
  SVGPathDataAndInfo& result =
      *static_cast<SVGPathDataAndInfo*>(aResult.mU.mPtr);
  MOZ_ASSERT(result.IsIdentity(),
             "expecting outparam to start out as identity");

  PathInterpolationResult check = CanInterpolate(start, end);

  if (check == eCannotInterpolate) {
    // SVGContentUtils::ReportToConsole - can't interpolate path segment lists
    // with different numbers of segments, with arcs with different flag values,
    // or with incompatible segment types.
    return NS_ERROR_FAILURE;
  }

  const SVGPathDataAndInfo* startListToUse = &start;
  if (check == eRequiresConversion) {
    // Can't convert |start| in-place, since it's const. Instead, we copy it
    // into |result|, converting the types as we go, and use that as our start.
    if (!result.SetLength(end.Length())) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
    result.SetElement(end.Element());  // propagate target element info!

    ConvertAllPathSegmentData(start.begin(), start.end(), end.begin(),
                              end.end(), result.begin());
    startListToUse = &result;
  }

  return AddWeightedPathSegLists(1.0 - aUnitDistance, *startListToUse,
                                 aUnitDistance, end, result);
}
Exemplo n.º 5
0
double TCurrentPoint::Interpolate(const uint64& Tm) const {
	IAssertR(CanInterpolate(Tm), "TCurrentPoint::Interpolate: Time not in the desired interval!");
	return Buff.GetOldest().Val2;
}