void GrColorCubeEffect::GLProcessor::setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) { const GrColorCubeEffect& colorCube = proc.cast<GrColorCubeEffect>(); SkScalar size = SkIntToScalar(colorCube.colorCubeSize()); pdman.set1f(fColorCubeSizeUni, SkScalarToFloat(size)); pdman.set1f(fColorCubeInvSizeUni, SkScalarToFloat(SkScalarInvert(size))); }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { const DefaultGeoProc& dgp = gp.cast<DefaultGeoProc>(); if (!dgp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dgp.viewMatrix())) { fViewMatrix = dgp.viewMatrix(); GrGLfloat viewMatrix[3 * 3]; GrGLGetMatrix<3>(viewMatrix, fViewMatrix); pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); } if (dgp.color() != fColor && !dgp.hasVertexColor()) { GrGLfloat c[4]; GrColorToRGBAFloat(dgp.color(), c); pdman.set4fv(fColorUniform, 1, c); fColor = dgp.color(); } if (!dgp.coverageWillBeIgnored() && dgp.coverage() != fCoverage && !dgp.hasVertexCoverage()) { pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.coverage())); fCoverage = dgp.coverage(); } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& proc, const GrBatchTracker& bt) override { #ifdef SK_GAMMA_APPLY_TO_A8 const GrDistanceFieldA8TextGeoProc& dfTexEffect = proc.cast<GrDistanceFieldA8TextGeoProc>(); float distanceAdjust = dfTexEffect.getDistanceAdjust(); if (distanceAdjust != fDistanceAdjust) { pdman.set1f(fDistanceAdjustUni, distanceAdjust); fDistanceAdjust = distanceAdjust; } #endif const GrDistanceFieldA8TextGeoProc& dfa8gp = proc.cast<GrDistanceFieldA8TextGeoProc>(); if (!dfa8gp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfa8gp.viewMatrix())) { fViewMatrix = dfa8gp.viewMatrix(); GrGLfloat viewMatrix[3 * 3]; GrGLGetMatrix<3>(viewMatrix, fViewMatrix); pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); } if (dfa8gp.color() != fColor && !dfa8gp.hasVertexColor()) { GrGLfloat c[4]; GrColorToRGBAFloat(dfa8gp.color(), c); pdman.set4fv(fColorUniform, 1, c); fColor = dfa8gp.color(); } }
void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override { const LightingFP& lightingFP = proc.cast<LightingFP>(); SkVector3 lightDir = lightingFP.lightDir(); if (lightDir != fLightDir) { pdman.set3fv(fLightDirUni, 1, &lightDir.fX); fLightDir = lightDir; } GrColor lightColor = lightingFP.lightColor(); if (lightColor != fLightColor) { GrGLfloat c[4]; GrColorToRGBAFloat(lightColor, c); pdman.set4fv(fLightColorUni, 1, c); fLightColor = lightColor; } GrColor ambientColor = lightingFP.ambientColor(); if (ambientColor != fAmbientColor) { GrGLfloat c[4]; GrColorToRGBAFloat(ambientColor, c); pdman.set4fv(fAmbientColorUni, 1, c); fAmbientColor = ambientColor; } }
void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) { const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>(); pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset()); pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom()); pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset()); pdman.set4f(fBoundsVar, zoom.bounds().x(), zoom.bounds().y(), zoom.bounds().width(), zoom.bounds().height()); }
void GrGLBicubicEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) { const GrBicubicEffect& bicubicEffect = processor.cast<GrBicubicEffect>(); const GrTexture& texture = *processor.texture(0); float imageIncrement[2]; imageIncrement[0] = 1.0f / texture.width(); imageIncrement[1] = 1.0f / texture.height(); pdman.set2fv(fImageIncrementUni, 1, imageIncrement); pdman.setMatrix4f(fCoefficientsUni, bicubicEffect.coefficients()); fDomain.setData(pdman, bicubicEffect.domain(), texture.origin()); }
void GrGLPerlinNoise::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) { INHERITED::onSetData(pdman, processor); const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>(); const SkVector& baseFrequency = turbulence.baseFrequency(); pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY); if (turbulence.stitchTiles()) { const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData(); pdman.set2f(fStitchDataUni, SkIntToScalar(stitchData.fWidth), SkIntToScalar(stitchData.fHeight)); } }
void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) { const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>(); size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar); if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) { pdman.set3fv(fEdgeUniform, cpe.getEdgeCount(), cpe.getEdges()); memcpy(fPrevEdges, cpe.getEdges(), byteSize); } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrProcessor& fp) override { if (fFilterColorUni.isValid()) { const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColorFilterEffect>(); GrGLfloat c[4]; GrColorToRGBAFloat(colorModeFilter.color(), c); pdman.set4fv(fFilterColorUni, 1, c); } }
void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) { const AARectEffect& aare = processor.cast<AARectEffect>(); const SkRect& rect = aare.getRect(); if (rect != fPrevRect) { pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, rect.fRight - 0.5f, rect.fBottom - 0.5f); fPrevRect = rect; } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, const GrBatchTracker& bt) override { const GrConicEffect& ce = primProc.cast<GrConicEffect>(); this->setUniformViewMatrix(pdman, ce.viewMatrix()); const ConicBatchTracker& local = bt.cast<ConicBatchTracker>(); if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { GrGLfloat c[4]; GrColorToRGBAFloat(local.fColor, c); pdman.set4fv(fColorUniform, 1, c); fColor = local.fColor; } if (0xff != local.fCoverageScale && fCoverageScale != local.fCoverageScale) { pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale)); fCoverageScale = local.fCoverageScale; } }
void GLEllipseEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) { const EllipseEffect& ee = effect.cast<EllipseEffect>(); if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) { SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX); SkScalar invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY); pdman.set4f(fEllipseUniform, ee.getCenter().fX, ee.getCenter().fY, invRXSqd, invRYSqd); fPrevCenter = ee.getCenter(); fPrevRadii = ee.getRadii(); } }
void GrGLPathProcessor::setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, const GrBatchTracker& bt) { const PathBatchTracker& local = bt.cast<PathBatchTracker>(); if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { GrGLfloat c[4]; GrColorToRGBAFloat(local.fColor, c); pdman.set4fv(fColorUniform, 1, c); fColor = local.fColor; } }
void GrGLDisplacementMapEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) { const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>(); GrTexture* colorTex = displacementMap.texture(1); SkScalar scaleX = SkScalarDiv(displacementMap.scale().fX, SkIntToScalar(colorTex->width())); SkScalar scaleY = SkScalarDiv(displacementMap.scale().fY, SkIntToScalar(colorTex->height())); pdman.set2f(fScaleUni, SkScalarToFloat(scaleX), colorTex->origin() == kTopLeft_GrSurfaceOrigin ? SkScalarToFloat(scaleY) : SkScalarToFloat(-scaleY)); fGLDomain.setData(pdman, displacementMap.domain(), colorTex->origin()); }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { const GrBitmapTextGeoProc& btgp = gp.cast<GrBitmapTextGeoProc>(); if (btgp.color() != fColor && !btgp.hasVertexColor()) { GrGLfloat c[4]; GrColorToRGBAFloat(btgp.color(), c); pdman.set4fv(fColorUniform, 1, c); fColor = btgp.color(); } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& gp, const GrBatchTracker& bt) override { this->setUniformViewMatrix(pdman, gp.viewMatrix()); const BitmapTextBatchTracker& local = bt.cast<BitmapTextBatchTracker>(); if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { GrGLfloat c[4]; GrColorToRGBAFloat(local.fColor, c); pdman.set4fv(fColorUniform, 1, c); fColor = local.fColor; } }
void GrGLProgramEffects::initSamplers(const GrGLProgramDataManager& programResourceManager, int* texUnitIdx) { int numEffects = fGLEffects.count(); SkASSERT(numEffects == fSamplers.count()); for (int e = 0; e < numEffects; ++e) { SkTArray<Sampler, true>& samplers = fSamplers[e]; int numSamplers = samplers.count(); for (int s = 0; s < numSamplers; ++s) { SkASSERT(samplers[s].fUniform.isValid()); programResourceManager.setSampler(samplers[s].fUniform, *texUnitIdx); samplers[s].fTextureUnit = (*texUnitIdx)++; } } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& proc, const GrBatchTracker& bt) override { #ifdef SK_GAMMA_APPLY_TO_A8 const GrDistanceFieldTextureEffect& dfTexEffect = proc.cast<GrDistanceFieldTextureEffect>(); float distanceAdjust = dfTexEffect.getDistanceAdjust(); if (distanceAdjust != fDistanceAdjust) { pdman.set1f(fDistanceAdjustUni, distanceAdjust); fDistanceAdjust = distanceAdjust; } #endif this->setUniformViewMatrix(pdman, proc.viewMatrix()); const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>(); if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { GrGLfloat c[4]; GrColorToRGBAFloat(local.fColor, c); pdman.set4fv(fColorUniform, 1, c); fColor = local.fColor; } }
virtual void setData(const GrGLProgramDataManager& pdman, const GrPrimitiveProcessor& proc, const GrBatchTracker& bt) override { SkASSERT(fTextureSizeUni.isValid()); GrTexture* texture = proc.texture(0); if (texture->width() != fTextureSize.width() || texture->height() != fTextureSize.height()) { fTextureSize = SkISize::Make(texture->width(), texture->height()); pdman.set2f(fTextureSizeUni, SkIntToScalar(fTextureSize.width()), SkIntToScalar(fTextureSize.height())); } this->setUniformViewMatrix(pdman, proc.viewMatrix()); const DistanceFieldNoGammaBatchTracker& local = bt.cast<DistanceFieldNoGammaBatchTracker>(); if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { GrGLfloat c[4]; GrColorToRGBAFloat(local.fColor, c); pdman.set4fv(fColorUniform, 1, c); fColor = local.fColor; } }
void GrGLVertexProgramEffects::setTransformData(const GrGLProgramDataManager& programResourceManager, const GrDrawEffect& drawEffect, int effectIdx) { SkTArray<Transform, true>& transforms = fTransforms[effectIdx]; int numTransforms = transforms.count(); SkASSERT(numTransforms == drawEffect.effect()->numTransforms()); for (int t = 0; t < numTransforms; ++t) { SkASSERT(transforms[t].fHandle.isValid()); const SkMatrix& matrix = get_transform_matrix(drawEffect, t); if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) { programResourceManager.setSkMatrix(transforms[t].fHandle, matrix); transforms[t].fCurrentValue = matrix; } } }
void GLEllipticalRRectEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) { const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>(); const SkRRect& rrect = erre.getRRect(); if (rrect != fPrevRRect) { SkRect rect = rrect.getBounds(); const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner); SkASSERT(r0.fX >= kRadiusMin); SkASSERT(r0.fY >= kRadiusMin); switch (erre.getRRect().getType()) { case SkRRect::kSimple_Type: rect.inset(r0.fX, r0.fY); pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX), 1.f / (r0.fY * r0.fY)); break; case SkRRect::kNinePatch_Type: { const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner); SkASSERT(r1.fX >= kRadiusMin); SkASSERT(r1.fY >= kRadiusMin); rect.fLeft += r0.fX; rect.fTop += r0.fY; rect.fRight -= r1.fX; rect.fBottom -= r1.fY; pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX), 1.f / (r0.fY * r0.fY), 1.f / (r1.fX * r1.fX), 1.f / (r1.fY * r1.fY)); break; } default: SkFAIL("RRect should always be simple or nine-patch."); } pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom); fPrevRRect = rrect; } }
void GLCircleEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) { const CircleEffect& ce = processor.cast<CircleEffect>(); if (ce.getRadius() != fPrevRadius || ce.getCenter() != fPrevCenter) { SkScalar radius = ce.getRadius(); if (GrProcessorEdgeTypeIsInverseFill(ce.getEdgeType())) { radius -= 0.5f; } else { radius += 0.5f; } pdman.set4f(fCircleUniform, ce.getCenter().fX, ce.getCenter().fY, radius, SkScalarInvert(radius)); fPrevCenter = ce.getCenter(); fPrevRadius = ce.getRadius(); } }
void GrGLGeometryProcessor::setTransformData(const GrPrimitiveProcessor& primProc, const GrGLProgramDataManager& pdman, int index, const SkTArray<const GrCoordTransform*, true>& transforms) { SkSTArray<2, Transform, true>& procTransforms = fInstalledTransforms[index]; int numTransforms = transforms.count(); for (int t = 0; t < numTransforms; ++t) { SkASSERT(procTransforms[t].fHandle.isValid()); const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]); if (!procTransforms[t].fCurrentValue.cheapEqualTo(transform)) { pdman.setSkMatrix(procTransforms[t].fHandle.convertToUniformHandle(), transform); procTransforms[t].fCurrentValue = transform; } } }
void onSetData(const GrGLProgramDataManager& pdm, const GrProcessor& processor) override { GrColor color = processor.cast<GrConstColorProcessor>().color(); // We use the "illegal" color value as an uninit sentinel. However, ut isn't inherently // illegal to use this processor with unpremul colors. So we correctly handle the case // when the "illegal" color is used but we will always upload it. if (GrColor_ILLEGAL == color || fPrevColor != color) { static const GrGLfloat scale = 1.f / 255.f; GrGLfloat floatColor[4] = { GrColorUnpackR(color) * scale, GrColorUnpackG(color) * scale, GrColorUnpackB(color) * scale, GrColorUnpackA(color) * scale, }; pdm.set4fv(fColorUniform, 1, floatColor); fPrevColor = color; } }
void GLCircularRRectEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) { const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>(); const SkRRect& rrect = crre.getRRect(); if (rrect != fPrevRRect) { SkRect rect = rrect.getBounds(); SkScalar radius = 0; switch (crre.getCircularCornerFlags()) { case CircularRRectEffect::kAll_CornerFlags: SkASSERT(rrect.isSimpleCircular()); radius = rrect.getSimpleRadii().fX; SkASSERT(radius >= kRadiusMin); rect.inset(radius, radius); break; case CircularRRectEffect::kTopLeft_CornerFlag: radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX; rect.fLeft += radius; rect.fTop += radius; rect.fRight += 0.5f; rect.fBottom += 0.5f; break; case CircularRRectEffect::kTopRight_CornerFlag: radius = rrect.radii(SkRRect::kUpperRight_Corner).fX; rect.fLeft -= 0.5f; rect.fTop += radius; rect.fRight -= radius; rect.fBottom += 0.5f; break; case CircularRRectEffect::kBottomRight_CornerFlag: radius = rrect.radii(SkRRect::kLowerRight_Corner).fX; rect.fLeft -= 0.5f; rect.fTop -= 0.5f; rect.fRight -= radius; rect.fBottom -= radius; break; case CircularRRectEffect::kBottomLeft_CornerFlag: radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX; rect.fLeft += radius; rect.fTop -= 0.5f; rect.fRight += 0.5f; rect.fBottom -= radius; break; case CircularRRectEffect::kLeft_CornerFlags: radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX; rect.fLeft += radius; rect.fTop += radius; rect.fRight += 0.5f; rect.fBottom -= radius; break; case CircularRRectEffect::kTop_CornerFlags: radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX; rect.fLeft += radius; rect.fTop += radius; rect.fRight -= radius; rect.fBottom += 0.5f; break; case CircularRRectEffect::kRight_CornerFlags: radius = rrect.radii(SkRRect::kUpperRight_Corner).fX; rect.fLeft -= 0.5f; rect.fTop += radius; rect.fRight -= radius; rect.fBottom -= radius; break; case CircularRRectEffect::kBottom_CornerFlags: radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX; rect.fLeft += radius; rect.fTop -= 0.5f; rect.fRight -= radius; rect.fBottom -= radius; break; default: SkFAIL("Should have been one of the above cases."); } pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom); pdman.set1f(fRadiusPlusHalfUniform, radius + 0.5f); fPrevRRect = rrect; } }
void onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override { const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>(); pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4()); fEnforcePMColor = arith.enforcePMColor(); }