void TileGrid::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&)
{
#if PLATFORM(IOS)
if (pthread_main_np())
WebThreadLock();
#endif
{
GraphicsContextStateSaver stateSaver(context);
FloatPoint3D layerOrigin = platformCALayer->position();
context.translate(-layerOrigin.x(), -layerOrigin.y());
context.scale(FloatSize(m_scale, m_scale));
PlatformCALayer::RepaintRectList dirtyRects = PlatformCALayer::collectRectsToPaint(context.platformContext(), platformCALayer);
PlatformCALayer::drawLayerContents(context.platformContext(), &m_controller.rootLayer(), dirtyRects);
}
int repaintCount = platformCALayerIncrementRepaintCount(platformCALayer);
if (m_controller.rootLayer().owner()->platformCALayerShowRepaintCounter(0))
PlatformCALayer::drawRepaintIndicator(context.platformContext(), platformCALayer, repaintCount, cachedCGColor(m_controller.tileDebugBorderColor()));
if (m_controller.scrollingPerformanceLoggingEnabled()) {
FloatRect visiblePart(platformCALayer->position().x(), platformCALayer->position().y(), platformCALayer->bounds().size().width(), platformCALayer->bounds().size().height());
visiblePart.intersect(m_controller.visibleRect());
if (repaintCount == 1 && !visiblePart.isEmpty())
WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), blankPixelCount());
}
}
CCLayerSorter::LayerShape::LayerShape(const FloatPoint3D& p1, const FloatPoint3D& p2, const FloatPoint3D& p3, const FloatPoint3D& p4)
: normal((p2 - p1).cross(p3 - p1))
, c1(FloatPoint(p1.x(), p1.y()))
, c2(FloatPoint(p2.x(), p2.y()))
, c3(FloatPoint(p3.x(), p3.y()))
, c4(FloatPoint(p4.x(), p4.y()))
, origin(p1)
{
boundingBox.fitToPoints(c1, c2, c3, c4);
}
FloatPoint3D TransformationMatrix::mapPoint(const FloatPoint3D& p) const
{
if (isIdentityOrTranslation())
return FloatPoint3D(p.x() + static_cast<float>(m_matrix[3][0]),
p.y() + static_cast<float>(m_matrix[3][1]),
p.z() + static_cast<float>(m_matrix[3][2]));
double x, y, z;
multVecMatrix(p.x(), p.y(), p.z(), x, y, z);
return FloatPoint3D(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
}
void LayerCompositingThread::setDrawTransform(double scale, const TransformationMatrix& matrix, const TransformationMatrix& projectionMatrix)
{
m_drawTransform = projectionMatrix * matrix;
FloatRect boundsRect(-origin(), bounds());
if (sizeIsScaleInvariant())
boundsRect.scale(1 / scale);
m_centerW = 0;
m_transformedBounds.clear();
m_ws.clear();
m_textureCoordinates.clear();
if (matrix.hasPerspective() && !m_layerRendererSurface) {
// Perform processing according to http://www.w3.org/TR/css3-transforms 6.2
// If w < 0 for all four corners of the transformed box, the box is not rendered.
// If w < 0 for one to three corners of the transformed box, the box
// must be replaced by a polygon that has any parts with w < 0 cut out.
// If w = 0, (x′, y′, z′) = (x ⋅ n, y ⋅ n, z ⋅ n)
// We implement this by intersecting with the image plane, i.e. the last row of the column-major matrix.
// To avoid problems with w close to 0, we use w = epsilon as the near plane by subtracting epsilon from matrix.m44().
const float epsilon = 1e-3;
Vector<FloatPoint3D, 4> quad = toVector<FloatPoint3D, 4>(boundsRect);
Vector<FloatPoint3D, 4> polygon = intersect(quad, LayerClipPlane(FloatPoint3D(matrix.m14(), matrix.m24(), matrix.m34()), matrix.m44() - epsilon));
// Compute the clipped texture coordinates.
if (polygon != quad) {
for (size_t i = 0; i < polygon.size(); ++i) {
FloatPoint3D& p = polygon[i];
m_textureCoordinates.append(FloatPoint(p.x() / boundsRect.width() + 0.5f, p.y() / boundsRect.height() + 0.5f));
}
}
// If w > 0, (x′, y′, z′) = (x/w, y/w, z/w)
for (size_t i = 0; i < polygon.size(); ++i) {
float w;
FloatPoint3D p = multVecMatrix(matrix, polygon[i], w);
if (w != 1) {
p.setX(p.x() / w);
p.setY(p.y() / w);
p.setZ(p.z() / w);
}
FloatPoint3D q = projectionMatrix.mapPoint(p);
m_transformedBounds.append(FloatPoint(q.x(), q.y()));
m_ws.append(w);
}
m_centerW = matrix.m44();
} else
m_transformedBounds = toVector<FloatPoint, 4>(m_drawTransform.mapQuad(boundsRect));
m_boundingBox = WebCore::boundingBox(m_transformedBounds);
}
FloatPoint3D SVGFilter::resolve3dPoint(const FloatPoint3D& point) const
{
if (!m_effectBBoxMode)
return point;
return FloatPoint3D(point.x() * m_targetBoundingBox.width() + m_targetBoundingBox.x(),
point.y() * m_targetBoundingBox.height() + m_targetBoundingBox.y(),
point.z() * sqrtf(m_targetBoundingBox.size().diagonalLengthSquared() / 2));
}
void PrintTo(const FloatPoint3D& point, std::ostream* os)
{
ScopedFloatFlags scope(*os);
*os << "FloatPoint3D("
<< point.x() << ", "
<< point.y() << ", "
<< point.z() << ")";
}
FloatPoint3D Filter::resolve3dPoint(const FloatPoint3D& point) const
{
if (m_unitScaling != BoundingBox)
return point;
return FloatPoint3D(point.x() * referenceBox().width() + referenceBox().x(),
point.y() * referenceBox().height() + referenceBox().y(),
point.z() * sqrtf(referenceBox().size().diagonalLengthSquared() / 2));
}
void PlatformCAAnimation::setToValue(const FloatPoint3D& value)
{
if (animationType() != Basic)
return;
float a[3] = { value.x(), value.y(), value.z() };
RetainPtr<CACFVectorRef> v(AdoptCF, CACFVectorCreate(3, a));
CACFAnimationSetToValue(m_animation.get(), v.get());
}
void GraphicsLayerClutter::updateGeometry(float pageScaleFactor, const FloatPoint& positionRelativeToBase)
{
FloatPoint scaledPosition;
FloatPoint3D scaledAnchorPoint;
FloatSize scaledSize;
// FIXME: Need to support scaling
scaledPosition = m_position;
scaledAnchorPoint = m_anchorPoint;
scaledSize = m_size;
FloatRect adjustedBounds(m_boundsOrigin , scaledSize);
FloatPoint adjustedPosition(scaledPosition.x() + scaledAnchorPoint.x() * scaledSize.width(), scaledPosition.y() + scaledAnchorPoint.y() * scaledSize.height());
clutter_actor_set_size(CLUTTER_ACTOR(m_layer.get()), adjustedBounds.width(), adjustedBounds.height());
clutter_actor_set_position(CLUTTER_ACTOR(m_layer.get()), adjustedPosition.x(), adjustedPosition.y());
graphicsLayerActorSetAnchorPoint(m_layer.get(), scaledAnchorPoint.x(), scaledAnchorPoint.y(), scaledAnchorPoint.z());
}
void GraphicsLayerAndroid::setAnchorPoint(const FloatPoint3D& point)
{
if (point == m_anchorPoint)
return;
GraphicsLayer::setAnchorPoint(point);
m_contentLayer->setAnchorPoint(point.x(), point.y());
m_contentLayer->setAnchorPointZ(point.z());
askForSync();
}
PassRefPtr<SkImageFilter> FELighting::createImageFilter(SkiaImageFilterBuilder* builder)
{
SkIRect rect = getCropRect(builder->cropOffset());
RefPtr<SkImageFilter> input(builder ? builder->build(inputEffect(0), operatingColorSpace()) : 0);
switch (m_lightSource->type()) {
case LS_DISTANT: {
DistantLightSource* distantLightSource = static_cast<DistantLightSource*>(m_lightSource.get());
float azimuthRad = deg2rad(distantLightSource->azimuth());
float elevationRad = deg2rad(distantLightSource->elevation());
SkPoint3 direction(cosf(azimuthRad) * cosf(elevationRad),
sinf(azimuthRad) * cosf(elevationRad),
sinf(elevationRad));
if (m_specularConstant > 0)
return adoptRef(SkLightingImageFilter::CreateDistantLitSpecular(direction, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect));
else
return adoptRef(SkLightingImageFilter::CreateDistantLitDiffuse(direction, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect));
}
case LS_POINT: {
PointLightSource* pointLightSource = static_cast<PointLightSource*>(m_lightSource.get());
FloatPoint3D position = pointLightSource->position();
SkPoint3 skPosition(position.x(), position.y(), position.z());
if (m_specularConstant > 0)
return adoptRef(SkLightingImageFilter::CreatePointLitSpecular(skPosition, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect));
else
return adoptRef(SkLightingImageFilter::CreatePointLitDiffuse(skPosition, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect));
}
case LS_SPOT: {
SpotLightSource* spotLightSource = static_cast<SpotLightSource*>(m_lightSource.get());
SkPoint3 location(spotLightSource->position().x(), spotLightSource->position().y(), spotLightSource->position().z());
SkPoint3 target(spotLightSource->direction().x(), spotLightSource->direction().y(), spotLightSource->direction().z());
float specularExponent = spotLightSource->specularExponent();
float limitingConeAngle = spotLightSource->limitingConeAngle();
if (!limitingConeAngle || limitingConeAngle > 90 || limitingConeAngle < -90)
limitingConeAngle = 90;
if (m_specularConstant > 0)
return adoptRef(SkLightingImageFilter::CreateSpotLitSpecular(location, target, specularExponent, limitingConeAngle, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect));
else
return adoptRef(SkLightingImageFilter::CreateSpotLitDiffuse(location, target, specularExponent, limitingConeAngle, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect));
}
default:
ASSERT_NOT_REACHED();
return 0;
}
}
static void printLayer(const PlatformCALayer* layer, int indent)
{
FloatPoint3D layerPosition = layer->position();
FloatPoint3D layerAnchorPoint = layer->anchorPoint();
FloatRect layerBounds = layer->bounds();
printIndent(indent);
char* layerTypeName = 0;
switch (layer->layerType()) {
case PlatformCALayer::LayerTypeLayer: layerTypeName = "layer"; break;
case PlatformCALayer::LayerTypeWebLayer: layerTypeName = "web-layer"; break;
case PlatformCALayer::LayerTypeTransformLayer: layerTypeName = "transform-layer"; break;
case PlatformCALayer::LayerTypeWebTiledLayer: layerTypeName = "web-tiled-layer"; break;
case PlatformCALayer::LayerTypeTiledBackingLayer: layerTypeName = "tiled-backing-layer"; break;
case PlatformCALayer::LayerTypeRootLayer: layerTypeName = "root-layer"; break;
case PlatformCALayer::LayerTypeCustom: layerTypeName = "custom-layer"; break;
}
fprintf(stderr, "(%s [%g %g %g] [%g %g %g %g] [%g %g %g] superlayer=%p\n",
layerTypeName,
layerPosition.x(), layerPosition.y(), layerPosition.z(),
layerBounds.x(), layerBounds.y(), layerBounds.width(), layerBounds.height(),
layerAnchorPoint.x(), layerAnchorPoint.y(), layerAnchorPoint.z(), layer->superlayer());
// Print name if needed
String layerName = CACFLayerGetName(layer->platformLayer());
if (!layerName.isEmpty()) {
printIndent(indent + 1);
fprintf(stderr, "(name %s)\n", layerName.utf8().data());
}
// Print masksToBounds if needed
bool layerMasksToBounds = layer->masksToBounds();
if (layerMasksToBounds) {
printIndent(indent + 1);
fprintf(stderr, "(masksToBounds true)\n");
}
// Print opacity if needed
float layerOpacity = layer->opacity();
if (layerOpacity != 1) {
printIndent(indent + 1);
fprintf(stderr, "(opacity %hf)\n", layerOpacity);
}
// Print sublayerTransform if needed
TransformationMatrix layerTransform = layer->sublayerTransform();
if (!layerTransform.isIdentity()) {
printIndent(indent + 1);
fprintf(stderr, "(sublayerTransform ");
printTransform(layerTransform);
fprintf(stderr, ")\n");
}
// Print transform if needed
layerTransform = layer->transform();
if (!layerTransform.isIdentity()) {
printIndent(indent + 1);
fprintf(stderr, "(transform ");
printTransform(layerTransform);
fprintf(stderr, ")\n");
}
// Print contents if needed
CFTypeRef layerContents = layer->contents();
if (layerContents) {
if (CFGetTypeID(layerContents) == CGImageGetTypeID()) {
CGImageRef imageContents = static_cast<CGImageRef>(const_cast<void*>(layerContents));
printIndent(indent + 1);
fprintf(stderr, "(contents (image [%d %d]))\n",
CGImageGetWidth(imageContents), CGImageGetHeight(imageContents));
}
}
// Print sublayers if needed
int n = intern(layer)->sublayerCount();
if (n > 0) {
printIndent(indent + 1);
fprintf(stderr, "(sublayers\n");
PlatformCALayerList sublayers;
intern(layer)->getSublayers(sublayers);
ASSERT(n == sublayers.size());
for (int i = 0; i < n; ++i)
printLayer(sublayers[i].get(), indent + 2);
printIndent(indent + 1);
fprintf(stderr, ")\n");
}
printIndent(indent);
fprintf(stderr, ")\n");
}
void PlatformCALayerWin::setAnchorPoint(const FloatPoint3D& value)
{
CACFLayerSetAnchorPoint(m_layer.get(), CGPointMake(value.x(), value.y()));
CACFLayerSetAnchorPointZ(m_layer.get(), value.z());
setNeedsCommit();
}
PassRefPtr<TransformOperation> RotateTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)
{
if (from && !from->isSameType(*this))
return this;
if (blendToIdentity)
return RotateTransformOperation::create(m_x, m_y, m_z, m_angle - m_angle * progress, m_type);
const RotateTransformOperation* fromOp = static_cast<const RotateTransformOperation*>(from);
// Optimize for single axis rotation
if (!fromOp || (fromOp->m_x == 0 && fromOp->m_y == 0 && fromOp->m_z == 1) ||
(fromOp->m_x == 0 && fromOp->m_y == 1 && fromOp->m_z == 0) ||
(fromOp->m_x == 1 && fromOp->m_y == 0 && fromOp->m_z == 0)) {
double fromAngle = fromOp ? fromOp->m_angle : 0;
return RotateTransformOperation::create(fromOp ? fromOp->m_x : m_x,
fromOp ? fromOp->m_y : m_y,
fromOp ? fromOp->m_z : m_z,
WebCore::blend(fromAngle, m_angle, progress), m_type);
}
double fromAngle;
double toAngle;
FloatPoint3D axis;
if (shareSameAxis(fromOp, this, &axis, &fromAngle, &toAngle))
return RotateTransformOperation::create(axis.x(), axis.y(), axis.z(), WebCore::blend(fromAngle, toAngle, progress), m_type);
const RotateTransformOperation* toOp = this;
// Create the 2 rotation matrices
TransformationMatrix fromT;
TransformationMatrix toT;
fromT.rotate3d((fromOp ? fromOp->m_x : 0),
(fromOp ? fromOp->m_y : 0),
(fromOp ? fromOp->m_z : 1),
(fromOp ? fromOp->m_angle : 0));
toT.rotate3d((toOp ? toOp->m_x : 0),
(toOp ? toOp->m_y : 0),
(toOp ? toOp->m_z : 1),
(toOp ? toOp->m_angle : 0));
// Blend them
toT.blend(fromT, progress);
// Extract the result as a quaternion
TransformationMatrix::DecomposedType decomp;
toT.decompose(decomp);
// Convert that to Axis/Angle form
double x = -decomp.quaternionX;
double y = -decomp.quaternionY;
double z = -decomp.quaternionZ;
double length = sqrt(x * x + y * y + z * z);
double angle = 0;
if (length > 0.00001) {
x /= length;
y /= length;
z /= length;
angle = rad2deg(acos(decomp.quaternionW) * 2);
} else {
x = 0;
y = 0;
z = 1;
}
return RotateTransformOperation::create(x, y, z, angle, Rotate3D);
}
static void printLayer(StringBuilder& builder, const PlatformCALayer* layer, int indent)
{
FloatPoint3D layerPosition = layer->position();
FloatPoint3D layerAnchorPoint = layer->anchorPoint();
FloatRect layerBounds = layer->bounds();
builder.append('\n');
printIndent(builder, indent);
char* layerTypeName = nullptr;
switch (layer->layerType()) {
case PlatformCALayer::LayerTypeLayer: layerTypeName = "layer"; break;
case PlatformCALayer::LayerTypeWebLayer: layerTypeName = "web-layer"; break;
case PlatformCALayer::LayerTypeSimpleLayer: layerTypeName = "simple-layer"; break;
case PlatformCALayer::LayerTypeTransformLayer: layerTypeName = "transform-layer"; break;
case PlatformCALayer::LayerTypeWebTiledLayer: layerTypeName = "web-tiled-layer"; break;
case PlatformCALayer::LayerTypeTiledBackingLayer: layerTypeName = "tiled-backing-layer"; break;
case PlatformCALayer::LayerTypePageTiledBackingLayer: layerTypeName = "page-tiled-backing-layer"; break;
case PlatformCALayer::LayerTypeTiledBackingTileLayer: layerTypeName = "tiled-backing-tile-layer"; break;
case PlatformCALayer::LayerTypeRootLayer: layerTypeName = "root-layer"; break;
case PlatformCALayer::LayerTypeAVPlayerLayer: layerTypeName = "avplayer-layer"; break;
case PlatformCALayer::LayerTypeWebGLLayer: layerTypeName = "webgl-layer"; break;
case PlatformCALayer::LayerTypeBackdropLayer: layerTypeName = "backdrop-layer"; break;
case PlatformCALayer::LayerTypeShapeLayer: layerTypeName = "shape-layer"; break;
case PlatformCALayer::LayerTypeLightSystemBackdropLayer: layerTypeName = "light-system-backdrop-layer"; break;
case PlatformCALayer::LayerTypeDarkSystemBackdropLayer: layerTypeName = "dark-system-backdrop-layer"; break;
case PlatformCALayer::LayerTypeScrollingLayer: layerTypeName = "scrolling-layer"; break;
case PlatformCALayer::LayerTypeCustom: layerTypeName = "custom-layer"; break;
}
builder.append("(");
builder.append(layerTypeName);
builder.append(" [");
builder.appendNumber(layerPosition.x());
builder.append(' ');
builder.appendNumber(layerPosition.y());
builder.append(' ');
builder.appendNumber(layerPosition.z());
builder.append("] [");
builder.appendNumber(layerBounds.x());
builder.append(' ');
builder.appendNumber(layerBounds.y());
builder.append(' ');
builder.appendNumber(layerBounds.width());
builder.append(' ');
builder.appendNumber(layerBounds.height());
builder.append("] [");
builder.appendNumber(layerAnchorPoint.x());
builder.append(' ');
builder.appendNumber(layerAnchorPoint.y());
builder.append(' ');
builder.appendNumber(layerAnchorPoint.z());
builder.append("] superlayer=");
builder.appendNumber(reinterpret_cast<unsigned long long>(layer->superlayer()));
// Print name if needed
String layerName = CACFLayerGetName(layer->platformLayer());
if (!layerName.isEmpty()) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(name \"");
builder.append(layerName);
builder.append("\")");
}
// Print borderWidth if needed
if (CGFloat borderWidth = CACFLayerGetBorderWidth(layer->platformLayer())) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(borderWidth ");
builder.appendNumber(borderWidth);
builder.append(')');
}
// Print backgroundColor if needed
printColor(builder, indent + 1, "backgroundColor", CACFLayerGetBackgroundColor(layer->platformLayer()));
// Print borderColor if needed
printColor(builder, indent + 1, "borderColor", CACFLayerGetBorderColor(layer->platformLayer()));
// Print masksToBounds if needed
if (bool layerMasksToBounds = layer->masksToBounds()) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(masksToBounds true)");
}
if (bool geometryFlipped = layer->geometryFlipped()) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(geometryFlipped true)");
}
// Print opacity if needed
float layerOpacity = layer->opacity();
if (layerOpacity != 1) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(opacity ");
builder.appendNumber(layerOpacity);
builder.append(')');
}
// Print sublayerTransform if needed
TransformationMatrix layerTransform = layer->sublayerTransform();
if (!layerTransform.isIdentity()) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(sublayerTransform ");
printTransform(builder, layerTransform);
builder.append(')');
}
// Print transform if needed
layerTransform = layer->transform();
if (!layerTransform.isIdentity()) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(transform ");
printTransform(builder, layerTransform);
builder.append(')');
}
// Print contents if needed
if (CFTypeRef layerContents = layer->contents()) {
if (CFGetTypeID(layerContents) == CGImageGetTypeID()) {
CGImageRef imageContents = static_cast<CGImageRef>(const_cast<void*>(layerContents));
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(contents (image [");
builder.appendNumber(CGImageGetWidth(imageContents));
builder.append(' ');
builder.appendNumber(CGImageGetHeight(imageContents));
builder.append("]))");
}
if (CFGetTypeID(layerContents) == CABackingStoreGetTypeID()) {
CABackingStoreRef backingStore = static_cast<CABackingStoreRef>(const_cast<void*>(layerContents));
CGImageRef imageContents = CABackingStoreGetCGImage(backingStore);
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(contents (backing-store [");
builder.appendNumber(CGImageGetWidth(imageContents));
builder.append(' ');
builder.appendNumber(CGImageGetHeight(imageContents));
builder.append("]))");
}
}
// Print sublayers if needed
int n = intern(layer)->sublayerCount();
if (n > 0) {
builder.append('\n');
printIndent(builder, indent + 1);
builder.append("(sublayers");
PlatformCALayerList sublayers;
intern(layer)->getSublayers(sublayers);
ASSERT(n == sublayers.size());
for (int i = 0; i < n; ++i)
printLayer(builder, sublayers[i].get(), indent + 2);
builder.append(')');
}
builder.append(')');
}
void PlatformCALayer::setPosition(const FloatPoint3D& value)
{
CACFLayerSetPosition(m_layer.get(), CGPointMake(value.x(), value.y()));
CACFLayerSetZPosition(m_layer.get(), value.z());
setNeedsCommit();
}
