MorphologyBench(SkScalar rad, MorphologyType style)
{
fRadius = rad;
fStyle = style;
const char* name = rad > 0 ? gStyleName[style] : "none";
if (SkScalarFraction(rad) != 0) {
fName.printf("morph_%.2f_%s", SkScalarToFloat(rad), name);
} else {
fName.printf("morph_%d_%s", SkScalarRoundToInt(rad), name);
}
}
float SkTouchGesture::limitTotalZoom(float scale) const {
// this query works 'cause we know that we're square-scale w/ no skew/rotation
const float curr = SkScalarToFloat(fGlobalM[0]);
if (scale > 1 && curr * scale > MAX_ZOOM_SCALE) {
scale = MAX_ZOOM_SCALE / curr;
} else if (scale < 1 && curr * scale < MIN_ZOOM_SCALE) {
scale = MIN_ZOOM_SCALE / curr;
}
return scale;
}
BlurRectDirectBench(SkScalar rad) : INHERITED(rad) {
SkString name;
if (SkScalarFraction(rad) != 0) {
name.printf("blurrect_direct_%.2f", SkScalarToFloat(rad));
} else {
name.printf("blurrect_direct_%d", SkScalarRoundToInt(rad));
}
this->setName(name);
}
float Path::length() const
{
SkScalar length = 0;
SkPathMeasure measure(m_path, false);
do {
length += measure.getLength();
} while (measure.nextContour());
return SkScalarToFloat(length);
}
void SkTableMaskFilter::MakeGammaTable(uint8_t table[256], SkScalar gamma) {
const float dx = 1 / 255.0f;
const float g = SkScalarToFloat(gamma);
float x = 0;
for (int i = 0; i < 256; i++) {
// float ee = powf(x, g) * 255;
table[i] = SkPin32(sk_float_round2int(powf(x, g) * 255), 0, 255);
x += dx;
}
}
static void android_view_MotionEvent_nativeTransform(JNIEnv* env, jclass clazz,
jint nativePtr, jobject matrixObj) {
SkMatrix* matrix = android_graphics_Matrix_getSkMatrix(env, matrixObj);
MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
float m[9];
m[0] = SkScalarToFloat(matrix->get(SkMatrix::kMScaleX));
m[1] = SkScalarToFloat(matrix->get(SkMatrix::kMSkewX));
m[2] = SkScalarToFloat(matrix->get(SkMatrix::kMTransX));
m[3] = SkScalarToFloat(matrix->get(SkMatrix::kMSkewY));
m[4] = SkScalarToFloat(matrix->get(SkMatrix::kMScaleY));
m[5] = SkScalarToFloat(matrix->get(SkMatrix::kMTransY));
m[6] = SkScalarToFloat(matrix->get(SkMatrix::kMPersp0));
m[7] = SkScalarToFloat(matrix->get(SkMatrix::kMPersp1));
m[8] = SkScalarToFloat(matrix->get(SkMatrix::kMPersp2));
event->transform(m);
}
static jfloat measureText_String(JNIEnv* env, jobject jpaint, jstring text) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
const jchar* textArray = env->GetStringChars(text, NULL);
size_t textLength = env->GetStringLength(text);
jfloat width = SkScalarToFloat(paint->measureText(textArray, textLength << 1));
env->ReleaseStringChars(text, textArray);
return width;
}
static void drawGrad(SkCanvas* canvas, const SkScalar d0[], const SkScalar d1[]) {
const SkRect bounds = SkRect::MakeXYWH(SkIntToScalar(-50),
SkIntToScalar(-50),
SkIntToScalar(200),
SkIntToScalar(100));
SkPoint c0 = { d0[0], d0[1] };
SkScalar r0 = d0[2];
SkPoint c1 = { d1[0], d1[1] };
SkScalar r1 = d1[2];
SkColor colors[] = { SK_ColorGREEN, SK_ColorRED };
SkPaint paint;
paint.setAntiAlias(true);
SkString str;
str.printf("%g,%g,%g %g,%g,%g",
SkScalarToFloat(c0.fX), SkScalarToFloat(c0.fY), SkScalarToFloat(r0),
SkScalarToFloat(c1.fX), SkScalarToFloat(c1.fY), SkScalarToFloat(r1));
canvas->drawText(str.c_str(), str.size(),
bounds.fLeft, bounds.fTop - paint.getTextSize()/2, paint);
paint.setShader(SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1,
colors, NULL, 2,
SkShader::kClamp_TileMode))->unref();
canvas->drawRect(bounds, paint);
paint.setShader(NULL);
paint.setColor(0x66000000);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawCircle(c0.fX, c0.fY, r0, paint);
canvas->drawCircle(c1.fX, c1.fY, r1, paint);
canvas->drawRect(bounds, paint);
}
// Static function to create a 2D convolution
GrFragmentProcessor*
GrMatrixConvolutionEffect::CreateGaussian(GrTexture* texture,
const SkIRect& bounds,
const SkISize& kernelSize,
SkScalar gain,
SkScalar bias,
const SkIPoint& kernelOffset,
GrTextureDomain::Mode tileMode,
bool convolveAlpha,
SkScalar sigmaX,
SkScalar sigmaY) {
float kernel[MAX_KERNEL_SIZE];
int width = kernelSize.width();
int height = kernelSize.height();
SkASSERT(width * height <= MAX_KERNEL_SIZE);
float sum = 0.0f;
float sigmaXDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaX)));
float sigmaYDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaY)));
int xRadius = width / 2;
int yRadius = height / 2;
for (int x = 0; x < width; x++) {
float xTerm = static_cast<float>(x - xRadius);
xTerm = xTerm * xTerm * sigmaXDenom;
for (int y = 0; y < height; y++) {
float yTerm = static_cast<float>(y - yRadius);
float xyTerm = sk_float_exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
// Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
// is dropped here, since we renormalize the kernel below.
kernel[y * width + x] = xyTerm;
sum += xyTerm;
}
}
// Normalize the kernel
float scale = 1.0f / sum;
for (int i = 0; i < width * height; ++i) {
kernel[i] *= scale;
}
return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
kernelOffset, tileMode, convolveAlpha);
}
GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
const SkIRect& bounds,
const SkISize& kernelSize,
const SkScalar* kernel,
SkScalar gain,
SkScalar bias,
const SkIPoint& kernelOffset,
GrTextureDomain::Mode tileMode,
bool convolveAlpha)
: INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)),
fKernelSize(kernelSize),
fGain(SkScalarToFloat(gain)),
fBias(SkScalarToFloat(bias) / 255.0f),
fConvolveAlpha(convolveAlpha),
fDomain(GrTextureDomain::MakeTexelDomainForMode(texture, bounds, tileMode), tileMode) {
this->initClassID<GrMatrixConvolutionEffect>();
for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
fKernel[i] = SkScalarToFloat(kernel[i]);
}
fKernelOffset[0] = static_cast<float>(kernelOffset.x());
fKernelOffset[1] = static_cast<float>(kernelOffset.y());
}
virtual const char* onGetName() {
fName.printf("text_%g", SkScalarToFloat(fPaint.getTextSize()));
if (fDoPos) {
fName.append("_pos");
}
fName.appendf("_%s", fontQualityName(fPaint));
if (SK_ColorBLACK != fPaint.getColor()) {
fName.appendf("_%02X", fPaint.getAlpha());
} else {
fName.append("_BK");
}
return fName.c_str();
}
void SkSet::dump(SkAnimateMaker* maker) {
INHERITED::dump(maker);
if (dur != 1) {
#ifdef SK_CAN_USE_FLOAT
SkDebugf("dur=\"%g\" ", SkScalarToFloat(SkScalarDiv(dur,1000)));
#else
SkDebugf("dur=\"%x\" ", SkScalarDiv(dur,1000));
#endif
}
//don't want double />\n's
SkDebugf("/>\n");
}
void STDMETHODCALLTYPE SkDWriteGeometrySink::AddBeziers(const D2D1_BEZIER_SEGMENT *beziers, UINT beziersCount) {
SkPoint lastPt;
fPath->getLastPt(&lastPt);
D2D1_POINT_2F prevPt = { SkScalarToFloat(lastPt.fX), SkScalarToFloat(lastPt.fY) };
for (const D2D1_BEZIER_SEGMENT *end = &beziers[beziersCount]; beziers < end; ++beziers) {
Cubic cubic = { { prevPt.x, prevPt.y },
{ beziers->point1.x, beziers->point1.y },
{ beziers->point2.x, beziers->point2.y },
{ beziers->point3.x, beziers->point3.y }, };
Quadratic quadratic;
if (check_quadratic(cubic, quadratic)) {
fPath->quadTo(quadratic[1].x, quadratic[1].y,
quadratic[2].x, quadratic[2].y);
} else {
fPath->cubicTo(beziers->point1.x, beziers->point1.y,
beziers->point2.x, beziers->point2.y,
beziers->point3.x, beziers->point3.y);
}
prevPt = beziers->point3;
}
}
void SkDumpCanvas::didConcat(const SkMatrix& matrix) {
SkString str;
switch (matrix.getType()) {
case SkMatrix::kTranslate_Mask:
this->dump(kMatrix_Verb, nullptr, "translate(%g %g)",
SkScalarToFloat(matrix.getTranslateX()),
SkScalarToFloat(matrix.getTranslateY()));
break;
case SkMatrix::kScale_Mask:
this->dump(kMatrix_Verb, nullptr, "scale(%g %g)",
SkScalarToFloat(matrix.getScaleX()),
SkScalarToFloat(matrix.getScaleY()));
break;
default:
matrix.toString(&str);
this->dump(kMatrix_Verb, nullptr, "concat(%s)", str.c_str());
break;
}
this->INHERITED::didConcat(matrix);
}
void GrGpuGLShaders::flushTextureDomain(int s) {
const GrGLint& uni = fProgramData->fUniLocations.fStages[s].fTexDomUni;
if (GrGLProgram::kUnusedUniform != uni) {
const GrRect &texDom =
fCurrDrawState.fSamplerStates[s].getTextureDomain();
if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
fProgramData->fTextureDomain[s] != texDom) {
fProgramData->fTextureDomain[s] = texDom;
float values[4] = {
GrScalarToFloat(texDom.left()),
GrScalarToFloat(texDom.top()),
GrScalarToFloat(texDom.right()),
GrScalarToFloat(texDom.bottom())
};
GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
GrGLTexture::Orientation orientation = texture->orientation();
// vertical flip if necessary
if (GrGLTexture::kBottomUp_Orientation == orientation) {
values[1] = 1.0f - values[1];
values[3] = 1.0f - values[3];
// The top and bottom were just flipped, so correct the ordering
// of elements so that values = (l, t, r, b).
SkTSwap(values[1], values[3]);
}
values[0] *= SkScalarToFloat(texture->contentScaleX());
values[2] *= SkScalarToFloat(texture->contentScaleX());
values[1] *= SkScalarToFloat(texture->contentScaleY());
values[3] *= SkScalarToFloat(texture->contentScaleY());
GL_CALL(Uniform4fv(uni, 1, values));
}
}
}
BlurBench(SkScalar rad, SkBlurStyle bs, uint32_t flags = 0) {
fRadius = rad;
fStyle = bs;
fFlags = flags;
const char* name = rad > 0 ? gStyleName[bs] : "none";
const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality"
: "low_quality";
if (SkScalarFraction(rad) != 0) {
fName.printf("blur_%.2f_%s_%s", SkScalarToFloat(rad), name, quality);
} else {
fName.printf("blur_%d_%s_%s", SkScalarRoundToInt(rad), name, quality);
}
}
ECode CCamera::DotWithNormal(
/* [in] */ Float dx,
/* [in] */ Float dy,
/* [in] */ Float dz,
/* [out] */ Float* result)
{
VALIDATE_NOT_NULL(result);
Sk3DView* v = reinterpret_cast<Sk3DView*>(mNativeInstance);
SkScalar dot = v->dotWithNormal(dx, dy, dz);
*result = SkScalarToFloat(dot);
return NOERROR;
}
float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
{
SkASSERT(sizeof(glyph) == 2); // compile-time assert
SkPaint paint;
m_font.setupPaint(&paint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
SkScalar width = paint.measureText(&glyph, 2);
return SkScalarToFloat(width);
}
void SkTMaskGamma_build_correcting_lut(uint8_t table[256], U8CPU srcI, SkScalar contrast,
const SkColorSpaceLuminance& srcConvert, SkScalar srcGamma,
const SkColorSpaceLuminance& dstConvert, SkScalar dstGamma) {
const float src = (float)srcI / 255.0f;
const float linSrc = srcConvert.toLuma(srcGamma, src);
//Guess at the dst. The perceptual inverse provides smaller visual
//discontinuities when slight changes to desaturated colors cause a channel
//to map to a different correcting lut with neighboring srcI.
//See https://code.google.com/p/chromium/issues/detail?id=141425#c59 .
const float dst = 1.0f - src;
const float linDst = dstConvert.toLuma(dstGamma, dst);
//Contrast value tapers off to 0 as the src luminance becomes white
const float adjustedContrast = SkScalarToFloat(contrast) * linDst;
//Remove discontinuity and instability when src is close to dst.
//The value 1/256 is arbitrary and appears to contain the instability.
if (fabs(src - dst) < (1.0f / 256.0f)) {
float ii = 0.0f;
for (int i = 0; i < 256; ++i, ii += 1.0f) {
float rawSrca = ii / 255.0f;
float srca = apply_contrast(rawSrca, adjustedContrast);
table[i] = SkToU8(sk_float_round2int(255.0f * srca));
}
} else {
// Avoid slow int to float conversion.
float ii = 0.0f;
for (int i = 0; i < 256; ++i, ii += 1.0f) {
// 'rawSrca += 1.0f / 255.0f' and even
// 'rawSrca = i * (1.0f / 255.0f)' can add up to more than 1.0f.
// When this happens the table[255] == 0x0 instead of 0xff.
// See http://code.google.com/p/chromium/issues/detail?id=146466
float rawSrca = ii / 255.0f;
float srca = apply_contrast(rawSrca, adjustedContrast);
SkASSERT(srca <= 1.0f);
float dsta = 1.0f - srca;
//Calculate the output we want.
float linOut = (linSrc * srca + dsta * linDst);
SkASSERT(linOut <= 1.0f);
float out = dstConvert.fromLuma(dstGamma, linOut);
//Undo what the blit blend will do.
float result = (out - dst) / (src - dst);
SkASSERT(sk_float_round2int(255.0f * result) <= 255);
table[i] = SkToU8(sk_float_round2int(255.0f * result));
}
}
}
bool Path::pointAndNormalAtLength(float length, FloatPoint& point, float& normal) const
{
SkPathMeasure measure(m_path, false);
do {
SkScalar contourLength = measure.getLength();
if (length <= contourLength) {
SkVector tangent;
SkPoint position;
if (measure.getPosTan(length, &position, &tangent)) {
normal = rad2deg(SkScalarToFloat(SkScalarATan2(tangent.fY, tangent.fX)));
point = FloatPoint(SkScalarToFloat(position.fX), SkScalarToFloat(position.fY));
return true;
}
}
length -= contourLength;
} while (measure.nextContour());
normal = 0;
point = FloatPoint(0, 0);
return false;
}
void SkPowerMode::init(SkScalar e) {
fExp = e;
float ee = SkScalarToFloat(e);
printf("------ %g\n", ee);
for (int i = 0; i < 256; i++) {
float x = i / 255.f;
// printf(" %d %g", i, x);
x = powf(x, ee);
// printf(" %g", x);
int xx = SkScalarRound(SkFloatToScalar(x * 255));
// printf(" %d\n", xx);
fTable[i] = SkToU8(xx);
}
}
void Path::PositionCalculator::pointAndNormalAtLength(float length,
FloatPoint& point,
float& normalAngle) {
SkScalar skLength = WebCoreFloatToSkScalar(length);
if (skLength >= 0) {
if (skLength < m_accumulatedLength) {
// Reset path measurer to rewind (and restart from 0).
m_pathMeasure.setPath(&m_path, false);
m_accumulatedLength = 0;
} else {
skLength -= m_accumulatedLength;
}
if (calculatePointAndNormalOnPath(m_pathMeasure, skLength, point,
normalAngle, &m_accumulatedLength))
return;
}
SkPoint position = m_path.getPoint(0);
point =
FloatPoint(SkScalarToFloat(position.fX), SkScalarToFloat(position.fY));
normalAngle = 0;
return;
}
static void toString(const SkRRect& rrect, SkString* str) {
SkRect r = rrect.getBounds();
str->appendf("[%g,%g %g:%g]",
SkScalarToFloat(r.fLeft), SkScalarToFloat(r.fTop),
SkScalarToFloat(r.width()), SkScalarToFloat(r.height()));
if (rrect.isOval()) {
str->append("()");
} else if (rrect.isSimple()) {
const SkVector& rad = rrect.getSimpleRadii();
str->appendf("(%g,%g)", rad.x(), rad.y());
} else if (rrect.isComplex()) {
SkVector radii[4] = {
rrect.radii(SkRRect::kUpperLeft_Corner),
rrect.radii(SkRRect::kUpperRight_Corner),
rrect.radii(SkRRect::kLowerRight_Corner),
rrect.radii(SkRRect::kLowerLeft_Corner),
};
str->appendf("(%g,%g %g,%g %g,%g %g,%g)",
radii[0].x(), radii[0].y(),
radii[1].x(), radii[1].y(),
radii[2].x(), radii[2].y(),
radii[3].x(), radii[3].y());
}
}
HRESULT SkScalerContext_DW::getBoundingBox(SkGlyph* glyph,
DWRITE_RENDERING_MODE renderingMode,
DWRITE_TEXTURE_TYPE textureType,
RECT* bbox)
{
//Measure raster size.
fXform.dx = SkFixedToFloat(glyph->getSubXFixed());
fXform.dy = SkFixedToFloat(glyph->getSubYFixed());
FLOAT advance = 0;
UINT16 glyphId = glyph->getGlyphID();
DWRITE_GLYPH_OFFSET offset;
offset.advanceOffset = 0.0f;
offset.ascenderOffset = 0.0f;
DWRITE_GLYPH_RUN run;
run.glyphCount = 1;
run.glyphAdvances = &advance;
run.fontFace = fTypeface->fDWriteFontFace.get();
run.fontEmSize = SkScalarToFloat(fTextSizeRender);
run.bidiLevel = 0;
run.glyphIndices = &glyphId;
run.isSideways = FALSE;
run.glyphOffsets = &offset;
SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
{
SkAutoExclusive l(DWriteFactoryMutex);
HRM(fTypeface->fFactory->CreateGlyphRunAnalysis(
&run,
1.0f, // pixelsPerDip,
&fXform,
renderingMode,
fMeasuringMode,
0.0f, // baselineOriginX,
0.0f, // baselineOriginY,
&glyphRunAnalysis),
"Could not create glyph run analysis.");
}
{
Shared l(DWriteFactoryMutex);
HRM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, bbox),
"Could not get texture bounds.");
}
return S_OK;
}
float SimpleFontData::platformWidthForGlyph(Glyph glyph) const {
if (!m_platformData.size())
return 0;
SkASSERT(sizeof(glyph) == 2); // compile-time assert
SkPaint paint;
m_platformData.setupPaint(&paint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
SkScalar width = paint.measureText(&glyph, 2);
if (!paint.isSubpixelText())
width = SkScalarRoundToInt(width);
return SkScalarToFloat(width);
}
static int breakText(JNIEnv* env, const SkPaint& paint, const jchar text[],
int count, float maxWidth, jfloatArray jmeasured,
SkPaint::TextBufferDirection tbd) {
SkASSERT(paint.getTextEncoding() == SkPaint::kUTF16_TextEncoding);
SkScalar measured;
size_t bytes = paint.breakText(text, count << 1,
SkFloatToScalar(maxWidth), &measured, tbd);
SkASSERT((bytes & 1) == 0);
if (jmeasured && env->GetArrayLength(jmeasured) > 0) {
AutoJavaFloatArray autoMeasured(env, jmeasured, 1);
jfloat* array = autoMeasured.ptr();
array[0] = SkScalarToFloat(measured);
}
return bytes >> 1;
}
static float anp_getFontMetrics(ANPPaint* paint, ANPFontMetrics* metrics) {
SkPaint::FontMetrics fm;
SkScalar spacing = paint->getFontMetrics(&fm);
if (metrics) {
metrics->fTop = SkScalarToFloat(fm.fTop);
metrics->fAscent = SkScalarToFloat(fm.fAscent);
metrics->fDescent = SkScalarToFloat(fm.fDescent);
metrics->fBottom = SkScalarToFloat(fm.fBottom);
metrics->fLeading = SkScalarToFloat(fm.fLeading);
}
return SkScalarToFloat(spacing);
}
static jint Interpolator_timeToValues(JNIEnv* env, jobject clazz, jlong interpHandle, jint msec, jfloatArray valueArray)
{
SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle);
SkInterpolatorBase::Result result;
float* values = valueArray ? env->GetFloatArrayElements(valueArray, NULL) : NULL;
result = interp->timeToValues(msec, (SkScalar*)values);
if (valueArray) {
int n = env->GetArrayLength(valueArray);
for (int i = 0; i < n; i++) {
values[i] = SkScalarToFloat(*(SkScalar*)&values[i]);
}
env->ReleaseFloatArrayElements(valueArray, values, 0);
}
return static_cast<jint>(result);
}
static jfloat measureText_StringII(JNIEnv* env, jobject jpaint, jstring text, int start, int end) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
const jchar* textArray = env->GetStringChars(text, NULL);
size_t textLength = env->GetStringLength(text);
int count = end - start;
if ((start | count) < 0 || (size_t)count > textLength) {
doThrow(env, "java/lang/IndexOutOfBoundsException");
return 0;
}
jfloat width = SkScalarToFloat(paint->measureText(textArray + start, count << 1));
env->ReleaseStringChars(text, textArray);
return width;
}
void TwoPtRadial::init(const SkPoint& center0, SkScalar rad0,
const SkPoint& center1, SkScalar rad1) {
fCenterX = SkScalarToFloat(center0.fX);
fCenterY = SkScalarToFloat(center0.fY);
fDCenterX = SkScalarToFloat(center1.fX) - fCenterX;
fDCenterY = SkScalarToFloat(center1.fY) - fCenterY;
fRadius = SkScalarToFloat(rad0);
fDRadius = SkScalarToFloat(rad1) - fRadius;
fA = sqr(fDCenterX) + sqr(fDCenterY) - sqr(fDRadius);
fRadius2 = sqr(fRadius);
fRDR = fRadius * fDRadius;
}
