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());
}
}
ALWAYS_INLINE void FELighting::setPixel(LightingData& data, LightSource::PaintingData& paintingData,
int lightX, int lightY, float factorX, int normalX, float factorY, int normalY)
{
m_lightSource->updatePaintingData(paintingData, lightX, lightY, static_cast<float>(data.pixels->get(data.offset + 3)) * data.surfaceScale);
data.normalVector.setX(factorX * static_cast<float>(normalX) * data.surfaceScale);
data.normalVector.setY(factorY * static_cast<float>(normalY) * data.surfaceScale);
data.normalVector.setZ(1.0f);
data.normalVector.normalize();
if (m_lightingType == FELighting::DiffuseLighting)
data.lightStrength = m_diffuseConstant * (data.normalVector * paintingData.lightVector);
else {
FloatPoint3D halfwayVector = paintingData.lightVector;
halfwayVector.setZ(halfwayVector.z() + 1.0f);
halfwayVector.normalize();
if (m_specularExponent == 1.0f)
data.lightStrength = m_specularConstant * (data.normalVector * halfwayVector);
else
data.lightStrength = m_specularConstant * powf(data.normalVector * halfwayVector, m_specularExponent);
}
if (data.lightStrength > 1.0f)
data.lightStrength = 1.0f;
if (data.lightStrength < 0.0f)
data.lightStrength = 0.0f;
data.pixels->set(data.offset, static_cast<unsigned char>(data.lightStrength * paintingData.colorVector.x()));
data.pixels->set(data.offset + 1, static_cast<unsigned char>(data.lightStrength * paintingData.colorVector.y()));
data.pixels->set(data.offset + 2, static_cast<unsigned char>(data.lightStrength * paintingData.colorVector.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 PrintTo(const FloatPoint3D& point, std::ostream* os)
{
ScopedFloatFlags scope(*os);
*os << "FloatPoint3D("
<< point.x() << ", "
<< point.y() << ", "
<< point.z() << ")";
}
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 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();
}
float ShaderProgram::zValue(const TransformationMatrix& drawMatrix, float w, float h)
{
TransformationMatrix modifiedDrawMatrix = drawMatrix;
modifiedDrawMatrix.scale3d(w, h, 1);
TransformationMatrix renderMatrix = m_projectionMatrix * modifiedDrawMatrix;
FloatPoint3D point(0.5, 0.5, 0.0);
FloatPoint3D result = renderMatrix.mapPoint(point);
return result.z();
}
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 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);
}
void LayerRendererChromium::drawLayer(CCLayerImpl* layer, RenderSurfaceChromium* targetSurface)
{
if (layer->renderSurface() && layer->renderSurface() != targetSurface) {
layer->renderSurface()->draw(layer->getDrawRect());
return;
}
if (!layer->drawsContent())
return;
if (layer->bounds().isEmpty()) {
layer->unreserveContentsTexture();
return;
}
setScissorToRect(layer->scissorRect());
IntRect targetSurfaceRect = m_currentRenderSurface ? m_currentRenderSurface->contentRect() : m_defaultRenderSurface->contentRect();
IntRect scissorRect = layer->scissorRect();
if (!scissorRect.isEmpty())
targetSurfaceRect.intersect(scissorRect);
// Check if the layer falls within the visible bounds of the page.
IntRect layerRect = layer->getDrawRect();
bool isLayerVisible = targetSurfaceRect.intersects(layerRect);
if (!isLayerVisible) {
layer->unreserveContentsTexture();
return;
}
// FIXME: Need to take into account the commulative render surface transforms all the way from
// the default render surface in order to determine visibility.
TransformationMatrix combinedDrawMatrix = (layer->targetRenderSurface() ? layer->targetRenderSurface()->drawTransform().multiply(layer->drawTransform()) : layer->drawTransform());
if (!layer->doubleSided()) {
FloatRect layerRect(FloatPoint(0, 0), FloatSize(layer->bounds()));
FloatQuad mappedLayer = combinedDrawMatrix.mapQuad(FloatQuad(layerRect));
FloatSize horizontalDir = mappedLayer.p2() - mappedLayer.p1();
FloatSize verticalDir = mappedLayer.p4() - mappedLayer.p1();
FloatPoint3D xAxis(horizontalDir.width(), horizontalDir.height(), 0);
FloatPoint3D yAxis(verticalDir.width(), verticalDir.height(), 0);
FloatPoint3D zAxis = xAxis.cross(yAxis);
if (zAxis.z() < 0) {
layer->unreserveContentsTexture();
return;
}
}
layer->draw(targetSurfaceRect);
// Draw the debug border if there is one.
layer->drawDebugBorder();
}
void LoopBlinnLocalTriangulator::Triangle::makeCounterClockwise()
{
// Possibly swaps two vertices so that the triangle's vertices are
// always specified in counterclockwise order. This orders the
// vertices canonically when walking the interior edges from the
// start to the end vertex.
FloatPoint3D point0(m_vertices[0]->xyCoordinates());
FloatPoint3D point1(m_vertices[1]->xyCoordinates());
FloatPoint3D point2(m_vertices[2]->xyCoordinates());
FloatPoint3D crossProduct = (point1 - point0).cross(point2 - point0);
if (crossProduct.z() < 0)
std::swap(m_vertices[1], m_vertices[2]);
}
double PannerNode::calculateDopplerRate()
{
double dopplerShift = 1.0;
double dopplerFactor = listener()->dopplerFactor();
if (dopplerFactor > 0.0) {
double speedOfSound = listener()->speedOfSound();
const FloatPoint3D &sourceVelocity = m_velocity;
const FloatPoint3D &listenerVelocity = listener()->velocity();
// Don't bother if both source and listener have no velocity
bool sourceHasVelocity = !sourceVelocity.isZero();
bool listenerHasVelocity = !listenerVelocity.isZero();
if (sourceHasVelocity || listenerHasVelocity) {
// Calculate the source to listener vector
FloatPoint3D listenerPosition = listener()->position();
FloatPoint3D sourceToListener = m_position - listenerPosition;
double sourceListenerMagnitude = sourceToListener.length();
if (!sourceListenerMagnitude) {
// Source and listener are at the same position. Skip the computation of the doppler
// shift, and just return the cached value.
dopplerShift = m_cachedDopplerRate;
} else {
double listenerProjection = sourceToListener.dot(listenerVelocity) / sourceListenerMagnitude;
double sourceProjection = sourceToListener.dot(sourceVelocity) / sourceListenerMagnitude;
listenerProjection = -listenerProjection;
sourceProjection = -sourceProjection;
double scaledSpeedOfSound = speedOfSound / dopplerFactor;
listenerProjection = std::min(listenerProjection, scaledSpeedOfSound);
sourceProjection = std::min(sourceProjection, scaledSpeedOfSound);
dopplerShift = ((speedOfSound - dopplerFactor * listenerProjection) / (speedOfSound - dopplerFactor * sourceProjection));
fixNANs(dopplerShift); // avoid illegal values
// Limit the pitch shifting to 4 octaves up and 3 octaves down.
if (dopplerShift > 16.0)
dopplerShift = 16.0;
else if (dopplerShift < 0.125)
dopplerShift = 0.125;
}
}
}
return dopplerShift;
}
void LayerRendererChromium::drawLayer(CCLayerImpl* layer, CCRenderSurface* targetSurface)
{
if (layer->renderSurface() && layer->renderSurface() != targetSurface) {
layer->renderSurface()->draw(this, layer->getDrawRect());
layer->renderSurface()->releaseContentsTexture();
return;
}
if (!layer->drawsContent())
return;
if (!layer->opacity())
return;
if (layer->bounds().isEmpty())
return;
IntRect targetSurfaceRect = layer->targetRenderSurface() ? layer->targetRenderSurface()->contentRect() : m_defaultRenderSurface->contentRect();
if (layer->usesLayerScissor()) {
IntRect scissorRect = layer->scissorRect();
targetSurfaceRect.intersect(scissorRect);
if (targetSurfaceRect.isEmpty())
return;
setScissorToRect(scissorRect);
} else
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
IntRect visibleLayerRect = CCLayerTreeHostCommon::calculateVisibleLayerRect(targetSurfaceRect, layer->bounds(), layer->contentBounds(), layer->drawTransform());
visibleLayerRect.move(toSize(layer->scrollPosition()));
layer->setVisibleLayerRect(visibleLayerRect);
// The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is facing the screen.
// This second condition is checked by computing the transformed normal of the layer.
if (!layer->doubleSided()) {
FloatRect layerRect(FloatPoint(0, 0), FloatSize(layer->bounds()));
FloatQuad mappedLayer = layer->screenSpaceTransform().mapQuad(FloatQuad(layerRect));
FloatSize horizontalDir = mappedLayer.p2() - mappedLayer.p1();
FloatSize verticalDir = mappedLayer.p4() - mappedLayer.p1();
FloatPoint3D xAxis(horizontalDir.width(), horizontalDir.height(), 0);
FloatPoint3D yAxis(verticalDir.width(), verticalDir.height(), 0);
FloatPoint3D zAxis = xAxis.cross(yAxis);
if (zAxis.z() < 0)
return;
}
layer->draw(this);
// Draw the debug border if there is one.
layer->drawDebugBorder(this);
}
float PannerNode::dopplerRate(ContextRenderLock& r)
{
double dopplerShift = 1.0;
// FIXME: optimize for case when neither source nor listener has changed...
double dopplerFactor = listener(r)->dopplerFactor();
if (dopplerFactor > 0.0)
{
double speedOfSound = listener(r)->speedOfSound();
const FloatPoint3D &sourceVelocity = m_velocity;
const FloatPoint3D &listenerVelocity = listener(r)->velocity();
// Don't bother if both source and listener have no velocity
bool sourceHasVelocity = !sourceVelocity.isZero();
bool listenerHasVelocity = !listenerVelocity.isZero();
if (sourceHasVelocity || listenerHasVelocity)
{
// Calculate the source to listener vector
FloatPoint3D listenerPosition = listener(r)->position();
FloatPoint3D sourceToListener = m_position - listenerPosition;
double sourceListenerMagnitude = sourceToListener.length();
double listenerProjection = sourceToListener.dot(listenerVelocity) / sourceListenerMagnitude;
double sourceProjection = sourceToListener.dot(sourceVelocity) / sourceListenerMagnitude;
listenerProjection = -listenerProjection;
sourceProjection = -sourceProjection;
double scaledSpeedOfSound = speedOfSound / dopplerFactor;
listenerProjection = min(listenerProjection, scaledSpeedOfSound);
sourceProjection = min(sourceProjection, scaledSpeedOfSound);
dopplerShift = ((speedOfSound - dopplerFactor * listenerProjection) / (speedOfSound - dopplerFactor * sourceProjection));
fixNANs(dopplerShift); // avoid illegal values
// Limit the pitch shifting to 4 octaves up and 3 octaves down.
if (dopplerShift > 16.0)
dopplerShift = 16.0;
else if (dopplerShift < 0.125)
dopplerShift = 0.125;
}
}
return static_cast<float>(dopplerShift);
}
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);
}
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());
}
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;
}
}
bool RotateTransformOperation::shareSameAxis(const RotateTransformOperation* from, const RotateTransformOperation* to, FloatPoint3D* axis, double* fromAngle, double* toAngle)
{
*axis = FloatPoint3D(0, 0, 1);
*fromAngle = 0;
*toAngle = 0;
if (!from && !to)
return true;
bool fromZero = !from || from->axis().isZero();
bool toZero = !to || to->axis().isZero();
if (fromZero && toZero)
return true;
if (fromZero) {
*axis = to->axis();
*toAngle = to->angle();
return true;
}
if (toZero) {
*axis = from->axis();
*fromAngle = from->angle();
return true;
}
FloatPoint3D fromAxis = from->axis();
FloatPoint3D toAxis = to->axis();
double fromSquared = fromAxis.lengthSquared();
double toSquared = toAxis.lengthSquared();
double dot = fromAxis.dot(toAxis);
double error = std::abs(1 - (dot * dot) / (fromSquared * toSquared));
if (error > angleEpsilon)
return false;
*axis = from->axis();
*fromAngle = from->angle();
*toAngle = to->angle();
return true;
}
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));
}
double ConeEffect::gain(FloatPoint3D sourcePosition, FloatPoint3D sourceOrientation, FloatPoint3D listenerPosition)
{
if (sourceOrientation.isZero() || ((m_innerAngle == 360.0) && (m_outerAngle == 360.0)))
return 1.0; // no cone specified - unity gain
// Normalized source-listener vector
FloatPoint3D sourceToListener = listenerPosition - sourcePosition;
sourceToListener.normalize();
FloatPoint3D normalizedSourceOrientation = sourceOrientation;
normalizedSourceOrientation.normalize();
// Angle between the source orientation vector and the source-listener vector
double dotProduct = sourceToListener.dot(normalizedSourceOrientation);
double angle = 180.0 * acos(dotProduct) / piDouble;
double absAngle = fabs(angle);
// Divide by 2.0 here since API is entire angle (not half-angle)
double absInnerAngle = fabs(m_innerAngle) / 2.0;
double absOuterAngle = fabs(m_outerAngle) / 2.0;
double gain = 1.0;
if (absAngle <= absInnerAngle)
// No attenuation
gain = 1.0;
else if (absAngle >= absOuterAngle)
// Max attenuation
gain = m_outerGain;
else {
// Between inner and outer cones
// inner -> outer, x goes from 0 -> 1
double x = (absAngle - absInnerAngle) / (absOuterAngle - absInnerAngle);
gain = (1.0 - x) + m_outerGain * x;
}
return gain;
}
inline void FELighting::inlineSetPixel(int offset, LightingData& data, LightSource::PaintingData& paintingData,
int lightX, int lightY, float factorX, float factorY, IntPoint& normal2DVector)
{
m_lightSource->updatePaintingData(paintingData, lightX, lightY, static_cast<float>(data.pixels->item(offset + cAlphaChannelOffset)) * data.surfaceScale);
float lightStrength;
if (!normal2DVector.x() && !normal2DVector.y()) {
// Normal vector is (0, 0, 1). This is a quite frequent case.
if (m_lightingType == FELighting::DiffuseLighting) {
lightStrength = m_diffuseConstant * paintingData.lightVector.z() / paintingData.lightVectorLength;
} else {
FloatPoint3D halfwayVector = paintingData.lightVector;
halfwayVector.setZ(halfwayVector.z() + paintingData.lightVectorLength);
float halfwayVectorLength = halfwayVector.length();
if (m_specularExponent == 1)
lightStrength = m_specularConstant * halfwayVector.z() / halfwayVectorLength;
else
lightStrength = m_specularConstant * powf(halfwayVector.z() / halfwayVectorLength, m_specularExponent);
}
} else {
FloatPoint3D normalVector;
normalVector.setX(factorX * static_cast<float>(normal2DVector.x()) * data.surfaceScale);
normalVector.setY(factorY * static_cast<float>(normal2DVector.y()) * data.surfaceScale);
normalVector.setZ(1);
float normalVectorLength = normalVector.length();
if (m_lightingType == FELighting::DiffuseLighting) {
lightStrength = m_diffuseConstant * (normalVector * paintingData.lightVector) / (normalVectorLength * paintingData.lightVectorLength);
} else {
FloatPoint3D halfwayVector = paintingData.lightVector;
halfwayVector.setZ(halfwayVector.z() + paintingData.lightVectorLength);
float halfwayVectorLength = halfwayVector.length();
if (m_specularExponent == 1)
lightStrength = m_specularConstant * (normalVector * halfwayVector) / (normalVectorLength * halfwayVectorLength);
else
lightStrength = m_specularConstant * powf((normalVector * halfwayVector) / (normalVectorLength * halfwayVectorLength), m_specularExponent);
}
}
if (lightStrength > 1)
lightStrength = 1;
if (lightStrength < 0)
lightStrength = 0;
data.pixels->set(offset, static_cast<unsigned char>(lightStrength * paintingData.colorVector.x()));
data.pixels->set(offset + 1, static_cast<unsigned char>(lightStrength * paintingData.colorVector.y()));
data.pixels->set(offset + 2, static_cast<unsigned char>(lightStrength * paintingData.colorVector.z()));
}
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 PrintTo(const FloatPoint3D& point, std::ostream* os) {
*os << point.toString();
}
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();
}
void PlatformCALayer::setPosition(const FloatPoint3D& value)
{
CACFLayerSetPosition(m_layer.get(), CGPointMake(value.x(), value.y()));
CACFLayerSetZPosition(m_layer.get(), value.z());
setNeedsCommit();
}
void PannerNode::getAzimuthElevation(double* outAzimuth, double* outElevation)
{
// FIXME: we should cache azimuth and elevation (if possible), so we only re-calculate if a change has been made.
double azimuth = 0.0;
// Calculate the source-listener vector
FloatPoint3D listenerPosition = listener()->position();
FloatPoint3D sourceListener = m_position - listenerPosition;
if (sourceListener.isZero()) {
// degenerate case if source and listener are at the same point
*outAzimuth = 0.0;
*outElevation = 0.0;
return;
}
sourceListener.normalize();
// Align axes
FloatPoint3D listenerFront = listener()->orientation();
FloatPoint3D listenerUp = listener()->upVector();
FloatPoint3D listenerRight = listenerFront.cross(listenerUp);
listenerRight.normalize();
FloatPoint3D listenerFrontNorm = listenerFront;
listenerFrontNorm.normalize();
FloatPoint3D up = listenerRight.cross(listenerFrontNorm);
float upProjection = sourceListener.dot(up);
FloatPoint3D projectedSource = sourceListener - upProjection * up;
projectedSource.normalize();
azimuth = 180.0 * acos(projectedSource.dot(listenerRight)) / piDouble;
fixNANs(azimuth); // avoid illegal values
// Source in front or behind the listener
double frontBack = projectedSource.dot(listenerFrontNorm);
if (frontBack < 0.0)
azimuth = 360.0 - azimuth;
// Make azimuth relative to "front" and not "right" listener vector
if ((azimuth >= 0.0) && (azimuth <= 270.0))
azimuth = 90.0 - azimuth;
else
azimuth = 450.0 - azimuth;
// Elevation
double elevation = 90.0 - 180.0 * acos(sourceListener.dot(up)) / piDouble;
fixNANs(elevation); // avoid illegal values
if (elevation > 90.0)
elevation = 180.0 - elevation;
else if (elevation < -90.0)
elevation = -180.0 - elevation;
if (outAzimuth)
*outAzimuth = azimuth;
if (outElevation)
*outElevation = elevation;
}
void PannerNode::calculateAzimuthElevation(double* outAzimuth, double* outElevation)
{
double azimuth = 0.0;
// Calculate the source-listener vector
FloatPoint3D listenerPosition = listener()->position();
FloatPoint3D sourceListener = m_position - listenerPosition;
// normalize() does nothing if the length of |sourceListener| is zero.
sourceListener.normalize();
// Align axes
FloatPoint3D listenerFront = listener()->orientation();
FloatPoint3D listenerUp = listener()->upVector();
FloatPoint3D listenerRight = listenerFront.cross(listenerUp);
listenerRight.normalize();
FloatPoint3D listenerFrontNorm = listenerFront;
listenerFrontNorm.normalize();
FloatPoint3D up = listenerRight.cross(listenerFrontNorm);
float upProjection = sourceListener.dot(up);
FloatPoint3D projectedSource = sourceListener - upProjection * up;
projectedSource.normalize();
azimuth = 180.0 * acos(projectedSource.dot(listenerRight)) / piDouble;
fixNANs(azimuth); // avoid illegal values
// Source in front or behind the listener
double frontBack = projectedSource.dot(listenerFrontNorm);
if (frontBack < 0.0)
azimuth = 360.0 - azimuth;
// Make azimuth relative to "front" and not "right" listener vector
if ((azimuth >= 0.0) && (azimuth <= 270.0))
azimuth = 90.0 - azimuth;
else
azimuth = 450.0 - azimuth;
// Elevation
double elevation = 90.0 - 180.0 * acos(sourceListener.dot(up)) / piDouble;
fixNANs(elevation); // avoid illegal values
if (elevation > 90.0)
elevation = 180.0 - elevation;
else if (elevation < -90.0)
elevation = -180.0 - elevation;
if (outAzimuth)
*outAzimuth = azimuth;
if (outElevation)
*outElevation = elevation;
}
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);
}
