Эффект внутренней тени на слое UIView?
У меня есть следующий CALayer:
CAGradientLayer *gradient = [CAGradientLayer layer];
gradient.frame = CGRectMake(8, 57, 296, 30);
gradient.cornerRadius = 3.0f;
gradient.colors = [NSArray arrayWithObjects:(id)[RGB(130, 0, 140) CGColor], (id)[RGB(108, 0, 120) CGColor], nil];
[self.layer insertSublayer:gradient atIndex:0];
Я хотел бы добавить к нему эффект внутренней тени, но я не совсем уверен, как это сделать. Я полагаю, мне потребуется рисовать в drawRect, однако это добавит слой поверх других объектов UIView, так как он должен быть полосой за некоторыми кнопками, так что я не знаю, что делать?
Я мог бы добавить еще один слой, но опять же, не уверен, как добиться эффекта внутренней тени (например, так:
Помощь оценена...
15 ответов
Для всех, кто интересуется, как нарисовать внутреннюю тень, используя Core Graphics в соответствии с рекомендациями Costique, вот что: (на iOS отрегулируйте по мере необходимости)
В вашем drawRect: метод...
CGRect bounds = [self bounds];
CGContextRef context = UIGraphicsGetCurrentContext();
CGFloat radius = 0.5f * CGRectGetHeight(bounds);
// Create the "visible" path, which will be the shape that gets the inner shadow
// In this case it's just a rounded rect, but could be as complex as your want
CGMutablePathRef visiblePath = CGPathCreateMutable();
CGRect innerRect = CGRectInset(bounds, radius, radius);
CGPathMoveToPoint(visiblePath, NULL, innerRect.origin.x, bounds.origin.y);
CGPathAddLineToPoint(visiblePath, NULL, innerRect.origin.x + innerRect.size.width, bounds.origin.y);
CGPathAddArcToPoint(visiblePath, NULL, bounds.origin.x + bounds.size.width, bounds.origin.y, bounds.origin.x + bounds.size.width, innerRect.origin.y, radius);
CGPathAddLineToPoint(visiblePath, NULL, bounds.origin.x + bounds.size.width, innerRect.origin.y + innerRect.size.height);
CGPathAddArcToPoint(visiblePath, NULL, bounds.origin.x + bounds.size.width, bounds.origin.y + bounds.size.height, innerRect.origin.x + innerRect.size.width, bounds.origin.y + bounds.size.height, radius);
CGPathAddLineToPoint(visiblePath, NULL, innerRect.origin.x, bounds.origin.y + bounds.size.height);
CGPathAddArcToPoint(visiblePath, NULL, bounds.origin.x, bounds.origin.y + bounds.size.height, bounds.origin.x, innerRect.origin.y + innerRect.size.height, radius);
CGPathAddLineToPoint(visiblePath, NULL, bounds.origin.x, innerRect.origin.y);
CGPathAddArcToPoint(visiblePath, NULL, bounds.origin.x, bounds.origin.y, innerRect.origin.x, bounds.origin.y, radius);
CGPathCloseSubpath(visiblePath);
// Fill this path
UIColor *aColor = [UIColor redColor];
[aColor setFill];
CGContextAddPath(context, visiblePath);
CGContextFillPath(context);
// Now create a larger rectangle, which we're going to subtract the visible path from
// and apply a shadow
CGMutablePathRef path = CGPathCreateMutable();
//(when drawing the shadow for a path whichs bounding box is not known pass "CGPathGetPathBoundingBox(visiblePath)" instead of "bounds" in the following line:)
//-42 cuould just be any offset > 0
CGPathAddRect(path, NULL, CGRectInset(bounds, -42, -42));
// Add the visible path (so that it gets subtracted for the shadow)
CGPathAddPath(path, NULL, visiblePath);
CGPathCloseSubpath(path);
// Add the visible paths as the clipping path to the context
CGContextAddPath(context, visiblePath);
CGContextClip(context);
// Now setup the shadow properties on the context
aColor = [UIColor colorWithRed:0.0f green:0.0f blue:0.0f alpha:0.5f];
CGContextSaveGState(context);
CGContextSetShadowWithColor(context, CGSizeMake(0.0f, 1.0f), 3.0f, [aColor CGColor]);
// Now fill the rectangle, so the shadow gets drawn
[aColor setFill];
CGContextSaveGState(context);
CGContextAddPath(context, path);
CGContextEOFillPath(context);
// Release the paths
CGPathRelease(path);
CGPathRelease(visiblePath);
Итак, по сути есть следующие шаги:
- Создайте свой путь
- Установите нужный цвет заливки, добавьте этот путь в контекст и заполните контекст
- Теперь создайте больший прямоугольник, который может ограничивать видимый путь. Прежде чем закрыть этот путь, добавьте видимый путь. Затем закройте путь, чтобы создать фигуру с видимой траекторией, вычтенной из нее. Возможно, вы захотите изучить методы заполнения (ненулевое наматывание четного / нечетного) в зависимости от того, как вы создали эти пути. В сущности, чтобы заставить подпуть "вычитать", когда вы складываете их вместе, вам нужно нарисовать их (или, скорее, построить) в противоположных направлениях, один по часовой стрелке, а другой против часовой стрелки.
- Затем вам нужно установить видимый путь в качестве обтравочного контура в контексте, чтобы вы ничего не рисовали вне его на экране.
- Затем настройте тень в контексте, который включает смещение, размытие и цвет.
- Затем заполните большую форму с отверстием в нем. Цвет не имеет значения, потому что если вы все сделали правильно, вы не увидите этот цвет, только тень.
Я знаю, что я опоздал на эту вечеринку, но это помогло бы мне найти в начале моих путешествий...
Чтобы отдать должное должному, это, по сути, является модификацией разработки Дэниела Торпа о решении Costique вычитания меньшего региона из более крупного региона. Эта версия для тех, кто использует состав слоя вместо переопределения -drawRect:
CAShapeLayer Класс можно использовать для достижения того же эффекта:
CAShapeLayer* shadowLayer = [CAShapeLayer layer];
[shadowLayer setFrame:[self bounds]];
// Standard shadow stuff
[shadowLayer setShadowColor:[[UIColor colorWithWhite:0 alpha:1] CGColor]];
[shadowLayer setShadowOffset:CGSizeMake(0.0f, 0.0f)];
[shadowLayer setShadowOpacity:1.0f];
[shadowLayer setShadowRadius:5];
// Causes the inner region in this example to NOT be filled.
[shadowLayer setFillRule:kCAFillRuleEvenOdd];
// Create the larger rectangle path.
CGMutablePathRef path = CGPathCreateMutable();
CGPathAddRect(path, NULL, CGRectInset(bounds, -42, -42));
// Add the inner path so it's subtracted from the outer path.
// someInnerPath could be a simple bounds rect, or maybe
// a rounded one for some extra fanciness.
CGPathAddPath(path, NULL, someInnerPath);
CGPathCloseSubpath(path);
[shadowLayer setPath:path];
CGPathRelease(path);
[[self layer] addSublayer:shadowLayer];
На этом этапе, если ваш родительский слой не маскируется до его границ, вы увидите дополнительную область маскирующего слоя по краям слоя. Это будет 42 пикселя черного цвета, если вы просто скопировали пример напрямую. Чтобы избавиться от него, вы можете просто использовать другой CAShapeLayer с тем же путем и установите его как маску теневого слоя:
CAShapeLayer* maskLayer = [CAShapeLayer layer];
[maskLayer setPath:someInnerPath];
[shadowLayer setMask:maskLayer];
Я не тестировал это сам, но подозреваю, что использование этого подхода в сочетании с растеризацией более производительно, чем переопределение -drawRect:,
Можно нарисовать внутреннюю тень с помощью Core Graphics, сделав большой путь прямоугольника за пределами границ, вычтя путь прямоугольника размером с границы и заполнив полученный путь "нормальной" тенью.
Однако, поскольку вам нужно объединить его с градиентным слоем, я думаю, что более простое решение - создать прозрачное PNG-изображение внутренней тени из 9 частей и растянуть его до нужного размера. 9-элементное теневое изображение будет выглядеть так (его размер 21x21 пикселей):
CALayer *innerShadowLayer = [CALayer layer];
innerShadowLayer.contents = (id)[UIImage imageNamed: @"innershadow.png"].CGImage;
innerShadowLayer.contentsCenter = CGRectMake(10.0f/21.0f, 10.0f/21.0f, 1.0f/21.0f, 1.0f/21.0f);
Затем установите рамку innerShadowLayer, и она должна правильно растянуть тень.
Упрощенная версия с использованием всего лишь CALayer в Swift:
import UIKit
final class FrameView : UIView {
init() {
super.init(frame: CGRect.zero)
backgroundColor = UIColor.white
}
@available(*, unavailable)
required init?(coder decoder: NSCoder) { fatalError("unavailable") }
override func layoutSubviews() {
super.layoutSubviews()
addInnerShadow()
}
private func addInnerShadow() {
let innerShadow = CALayer()
innerShadow.frame = bounds
// Shadow path (1pt ring around bounds)
let path = UIBezierPath(rect: innerShadow.bounds.insetBy(dx: -1, dy: -1))
let cutout = UIBezierPath(rect: innerShadow.bounds).reversing()
path.append(cutout)
innerShadow.shadowPath = path.cgPath
innerShadow.masksToBounds = true
// Shadow properties
innerShadow.shadowColor = UIColor(white: 0, alpha: 1).cgColor // UIColor(red: 0.71, green: 0.77, blue: 0.81, alpha: 1.0).cgColor
innerShadow.shadowOffset = CGSize.zero
innerShadow.shadowOpacity = 1
innerShadow.shadowRadius = 3
// Add
layer.addSublayer(innerShadow)
}
}
Обратите внимание, что слой innerShadow не должен иметь непрозрачный цвет фона, так как он будет отображаться перед тенью.
Немного обойдется, но избегает необходимости использовать изображения (читай: легко менять цвета, радиус тени и т. Д.), И это всего лишь несколько строк кода.
Добавьте UIImageView в качестве первого подпредставления UIView, на котором вы хотите создать тень. Я использую IB, но вы можете сделать то же самое программно.
Предполагая, что ссылка на UIImageView 'innerShadow'
`
[[innerShadow layer] setMasksToBounds:YES];
[[innerShadow layer] setCornerRadius:12.0f];
[[innerShadow layer] setBorderColor:[UIColorFromRGB(180, 180, 180) CGColor]];
[[innerShadow layer] setBorderWidth:1.0f];
[[innerShadow layer] setShadowColor:[UIColorFromRGB(0, 0, 0) CGColor]];
[[innerShadow layer] setShadowOffset:CGSizeMake(0, 0)];
[[innerShadow layer] setShadowOpacity:1];
[[innerShadow layer] setShadowRadius:2.0];
Предостережение: у вас должна быть граница, иначе тень не появится. [UIColor clearColor] не работает. В примере я использую другой цвет, но вы можете возиться с ним, чтобы получить тот же цвет, что и начало тени. :)
Смотрите ниже комментарий bbrame о UIColorFromRGB макро.
Лучше поздно, чем никогда...
Вот еще один подход, вероятно, не лучше, чем уже опубликованный, но он приятный и простой -
-(void)drawInnerShadowOnView:(UIView *)view
{
UIImageView *innerShadowView = [[UIImageView alloc] initWithFrame:view.bounds];
innerShadowView.contentMode = UIViewContentModeScaleToFill;
innerShadowView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
[view addSubview:innerShadowView];
[innerShadowView.layer setMasksToBounds:YES];
[innerShadowView.layer setBorderColor:[UIColor lightGrayColor].CGColor];
[innerShadowView.layer setShadowColor:[UIColor blackColor].CGColor];
[innerShadowView.layer setBorderWidth:1.0f];
[innerShadowView.layer setShadowOffset:CGSizeMake(0, 0)];
[innerShadowView.layer setShadowOpacity:1.0];
// this is the inner shadow thickness
[innerShadowView.layer setShadowRadius:1.5];
}
Вместо того, чтобы рисовать внутреннюю тень с помощью drawRect или добавьте UIView в View. Вы можете напрямую добавить CALayer к границе, например: если я хочу эффект внутренней тени на дне UIView V.
innerShadowOwnerLayer = [[CALayer alloc]init];
innerShadowOwnerLayer.frame = CGRectMake(0, V.frame.size.height+2, V.frame.size.width, 2);
innerShadowOwnerLayer.backgroundColor = [UIColor whiteColor].CGColor;
innerShadowOwnerLayer.shadowColor = [UIColor blackColor].CGColor;
innerShadowOwnerLayer.shadowOffset = CGSizeMake(0, 0);
innerShadowOwnerLayer.shadowRadius = 10.0;
innerShadowOwnerLayer.shadowOpacity = 0.7;
[V.layer addSubLayer:innerShadowOwnerLayer];
Это добавляет нижнюю внутреннюю тень для целевого UIView
Вот версия Swift, изменить startPoint а также endPoint сделать это на каждой стороне.
let layer = CAGradientLayer()
layer.startPoint = CGPointMake(0.5, 0.0);
layer.endPoint = CGPointMake(0.5, 1.0);
layer.colors = [UIColor(white: 0.1, alpha: 1.0).CGColor, UIColor(white: 0.1, alpha: 0.5).CGColor, UIColor.clearColor().CGColor]
layer.locations = [0.05, 0.2, 1.0 ]
layer.frame = CGRectMake(0, 0, self.view.frame.width, 60)
self.view.layer.insertSublayer(layer, atIndex: 0)
Это ваше решение, которое я экспортировал из PaintCode:
-(void) drawRect:(CGRect)rect
{
CGContextRef context = UIGraphicsGetCurrentContext();
//// Shadow Declarations
UIColor* shadow = UIColor.whiteColor;
CGSize shadowOffset = CGSizeMake(0, 0);
CGFloat shadowBlurRadius = 10;
//// Rectangle Drawing
UIBezierPath* rectanglePath = [UIBezierPath bezierPathWithRect: self.bounds];
[[UIColor blackColor] setFill];
[rectanglePath fill];
////// Rectangle Inner Shadow
CGContextSaveGState(context);
UIRectClip(rectanglePath.bounds);
CGContextSetShadowWithColor(context, CGSizeZero, 0, NULL);
CGContextSetAlpha(context, CGColorGetAlpha([shadow CGColor]));
CGContextBeginTransparencyLayer(context, NULL);
{
UIColor* opaqueShadow = [shadow colorWithAlphaComponent: 1];
CGContextSetShadowWithColor(context, shadowOffset, shadowBlurRadius, [opaqueShadow CGColor]);
CGContextSetBlendMode(context, kCGBlendModeSourceOut);
CGContextBeginTransparencyLayer(context, NULL);
[opaqueShadow setFill];
[rectanglePath fill];
CGContextEndTransparencyLayer(context);
}
CGContextEndTransparencyLayer(context);
CGContextRestoreGState(context);
}
Вот мое решение в Swift 4.2. Хотите попробовать?
final class ACInnerShadowLayer : CAShapeLayer {
var innerShadowColor: CGColor? = UIColor.black.cgColor {
didSet { setNeedsDisplay() }
}
var innerShadowOffset: CGSize = .zero {
didSet { setNeedsDisplay() }
}
var innerShadowRadius: CGFloat = 8 {
didSet { setNeedsDisplay() }
}
var innerShadowOpacity: Float = 1 {
didSet { setNeedsDisplay() }
}
override init() {
super.init()
masksToBounds = true
contentsScale = UIScreen.main.scale
setNeedsDisplay()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func draw(in ctx: CGContext) {
ctx.setAllowsAntialiasing(true)
ctx.setShouldAntialias(true)
ctx.interpolationQuality = .high
let colorspace = CGColorSpaceCreateDeviceRGB()
var rect = bounds
var radius = cornerRadius
if borderWidth != 0 {
rect = rect.insetBy(dx: borderWidth, dy: borderWidth)
radius -= borderWidth
radius = max(radius, 0)
}
let innerShadowPath = UIBezierPath(roundedRect: rect, cornerRadius: radius).cgPath
ctx.addPath(innerShadowPath)
ctx.clip()
let shadowPath = CGMutablePath()
let shadowRect = rect.insetBy(dx: -rect.size.width, dy: -rect.size.width)
shadowPath.addRect(shadowRect)
shadowPath.addPath(innerShadowPath)
shadowPath.closeSubpath()
if let innerShadowColor = innerShadowColor, let oldComponents = innerShadowColor.components {
var newComponets = Array<CGFloat>(repeating: 0, count: 4) // [0, 0, 0, 0] as [CGFloat]
let numberOfComponents = innerShadowColor.numberOfComponents
switch numberOfComponents {
case 2:
newComponets[0] = oldComponents[0]
newComponets[1] = oldComponents[0]
newComponets[2] = oldComponents[0]
newComponets[3] = oldComponents[1] * CGFloat(innerShadowOpacity)
case 4:
newComponets[0] = oldComponents[0]
newComponets[1] = oldComponents[1]
newComponets[2] = oldComponents[2]
newComponets[3] = oldComponents[3] * CGFloat(innerShadowOpacity)
default:
break
}
if let innerShadowColorWithMultipliedAlpha = CGColor(colorSpace: colorspace, components: newComponets) {
ctx.setFillColor(innerShadowColorWithMultipliedAlpha)
ctx.setShadow(offset: innerShadowOffset, blur: innerShadowRadius, color: innerShadowColorWithMultipliedAlpha)
ctx.addPath(shadowPath)
ctx.fillPath(using: .evenOdd)
}
}
}
}
Я очень опаздываю на вечеринку, но я хотел бы отдать ее сообществу.. Это метод, который я написал, чтобы удалить фоновое изображение UITextField, поскольку я предоставлял Статическую библиотеку и НЕТ ресурсов... Я использовал это для экран ввода PIN-кода из четырех экземпляров UITextField, которые могут отображать один необработанный символ или (BOOL)[self isUsingBullets] или (BOOL)[self usingAsterisks] в ViewController. Приложение для iPhone/iPhone Retina / iPad / iPad Retina, поэтому мне не нужно поставлять четыре изображения...
#import <QuartzCore/QuartzCore.h>
- (void)setTextFieldInnerGradient:(UITextField *)textField
{
[textField setSecureTextEntry:self.isUsingBullets];
[textField setBackgroundColor:[UIColor blackColor]];
[textField setTextColor:[UIColor blackColor]];
[textField setBorderStyle:UITextBorderStyleNone];
[textField setClipsToBounds:YES];
[textField.layer setBorderColor:[[UIColor blackColor] CGColor]];
[textField.layer setBorderWidth:1.0f];
// make a gradient off-white background
CAGradientLayer *gradient = [CAGradientLayer layer];
CGRect gradRect = CGRectInset([textField bounds], 3, 3); // Reduce Width and Height and center layer
gradRect.size.height += 2; // minimise Bottom shadow, rely on clipping to remove these 2 pts.
gradient.frame = gradRect;
struct CGColor *topColor = [UIColor colorWithWhite:0.6f alpha:1.0f].CGColor;
struct CGColor *bottomColor = [UIColor colorWithWhite:0.9f alpha:1.0f].CGColor;
// We need to use this fancy __bridge object in order to get the array we want.
gradient.colors = [NSArray arrayWithObjects:(__bridge id)topColor, (__bridge id)bottomColor, nil];
[gradient setCornerRadius:4.0f];
[gradient setShadowOffset:CGSizeMake(0, 0)];
[gradient setShadowColor:[[UIColor whiteColor] CGColor]];
[gradient setShadowOpacity:1.0f];
[gradient setShadowRadius:3.0f];
// Now we need to Blur the edges of this layer "so it blends"
// This rasterizes the view down to 4x4 pixel chunks then scales it back up using bilinear filtering...
// it's EXTREMELY fast and looks ok if you are just wanting to blur a background view under a modal view.
// To undo it, just set the rasterization scale back to 1.0 or turn off rasterization.
[gradient setRasterizationScale:0.25];
[gradient setShouldRasterize:YES];
[textField.layer insertSublayer:gradient atIndex:0];
if (self.usingAsterisks) {
[textField setFont:[UIFont systemFontOfSize:80.0]];
} else {
[textField setFont:[UIFont systemFontOfSize:40.0]];
}
[textField setTextAlignment:UITextAlignmentCenter];
[textField setEnabled:NO];
}
Я надеюсь, что это поможет кому-то, так как этот форум помог мне.
Масштабируемое решение с использованием CALayer в Swift
С описанным InnerShadowLayerвы также можете включить внутренние тени только для определенных краев, исключая другие. (например, вы можете включить внутренние тени только на левом и верхнем краях вашего обзора)
Затем вы можете добавить InnerShadowLayer на ваш взгляд, используя:
init(...) {
// ... your initialization code ...
super.init(frame: .zero)
layer.addSublayer(shadowLayer)
}
public override func layoutSubviews() {
super.layoutSubviews()
shadowLayer.frame = bounds
}
InnerShadowLayer реализация
/// Shadow is a struct defining the different kinds of shadows
public struct Shadow {
let x: CGFloat
let y: CGFloat
let blur: CGFloat
let opacity: CGFloat
let color: UIColor
}
/// A layer that applies an inner shadow to the specified edges of either its path or its bounds
public class InnerShadowLayer: CALayer {
private let shadow: Shadow
private let edge: UIRectEdge
public init(shadow: Shadow, edge: UIRectEdge) {
self.shadow = shadow
self.edge = edge
super.init()
setupShadow()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
public override func layoutSublayers() {
updateShadow()
}
private func setupShadow() {
shadowColor = shadow.color.cgColor
shadowOpacity = Float(shadow.opacity)
shadowRadius = shadow.blur / 2.0
masksToBounds = true
}
private func updateShadow() {
shadowOffset = {
let topWidth: CGFloat = 0
let leftWidth = edge.contains(.left) ? shadow.y / 2 : 0
let bottomWidth: CGFloat = 0
let rightWidth = edge.contains(.right) ? -shadow.y / 2 : 0
let topHeight = edge.contains(.top) ? shadow.y / 2 : 0
let leftHeight: CGFloat = 0
let bottomHeight = edge.contains(.bottom) ? -shadow.y / 2 : 0
let rightHeight: CGFloat = 0
return CGSize(width: [topWidth, leftWidth, bottomWidth, rightWidth].reduce(0, +),
height: [topHeight, leftHeight, bottomHeight, rightHeight].reduce(0, +))
}()
let insets = UIEdgeInsets(top: edge.contains(.top) ? -bounds.height : 0,
left: edge.contains(.left) ? -bounds.width : 0,
bottom: edge.contains(.bottom) ? -bounds.height : 0,
right: edge.contains(.right) ? -bounds.width : 0)
let path = UIBezierPath(rect: bounds.inset(by: insets))
let cutout = UIBezierPath(rect: bounds).reversing()
path.append(cutout)
shadowPath = path.cgPath
}
}
Посмотрите замечательную статью Криса Эмери, посвященную Inner Shadows in Quartz, которая объясняет, как PaintCode рисует внутренние тени, и дает чистый и аккуратный фрагмент кода:
- (void)drawInnerShadowInContext:(CGContextRef)context
withPath:(CGPathRef)path
shadowColor:(CGColorRef)shadowColor
offset:(CGSize)offset
blurRadius:(CGFloat)blurRadius
{
CGContextSaveGState(context);
CGContextAddPath(context, path);
CGContextClip(context);
CGColorRef opaqueShadowColor = CGColorCreateCopyWithAlpha(shadowColor, 1.0);
CGContextSetAlpha(context, CGColorGetAlpha(shadowColor));
CGContextBeginTransparencyLayer(context, NULL);
CGContextSetShadowWithColor(context, offset, blurRadius, opaqueShadowColor);
CGContextSetBlendMode(context, kCGBlendModeSourceOut);
CGContextSetFillColorWithColor(context, opaqueShadowColor);
CGContextAddPath(context, path);
CGContextFillPath(context);
CGContextEndTransparencyLayer(context);
CGContextRestoreGState(context);
CGColorRelease(opaqueShadowColor);
}
Этот код работал для меня
class InnerDropShadowView: UIView {
override func draw(_ rect: CGRect) {
//Drawing code
let context = UIGraphicsGetCurrentContext()
//// Shadow Declarations
let shadow: UIColor? = UIColor.init(hexString: "a3a3a3", alpha: 1.0) //UIColor.black.withAlphaComponent(0.6) //UIColor.init(hexString: "d7d7da", alpha: 1.0)
let shadowOffset = CGSize(width: 0, height: 0)
let shadowBlurRadius: CGFloat = 7.5
//// Rectangle Drawing
let rectanglePath = UIBezierPath(rect: bounds)
UIColor.groupTableViewBackground.setFill()
rectanglePath.fill()
////// Rectangle Inner Shadow
context?.saveGState()
UIRectClip(rectanglePath.bounds)
context?.setShadow(offset: CGSize.zero, blur: 0, color: nil)
context?.setAlpha((shadow?.cgColor.alpha)!)
context?.beginTransparencyLayer(auxiliaryInfo: nil)
do {
let opaqueShadow: UIColor? = shadow?.withAlphaComponent(1)
context?.setShadow(offset: shadowOffset, blur: shadowBlurRadius, color: opaqueShadow?.cgColor)
context!.setBlendMode(.sourceOut)
context?.beginTransparencyLayer(auxiliaryInfo: nil)
opaqueShadow?.setFill()
rectanglePath.fill()
context!.endTransparencyLayer()
}
context!.endTransparencyLayer()
context?.restoreGState()
}
}
Использование градиентного слоя:
UIView * mapCover = [UIView new];
mapCover.frame = map.frame;
[view addSubview:mapCover];
CAGradientLayer * vertical = [CAGradientLayer layer];
vertical.frame = mapCover.bounds;
vertical.colors = [NSArray arrayWithObjects:(id)[UIColor whiteColor].CGColor,
(id)[[UIColor whiteColor] colorWithAlphaComponent:0.0f].CGColor,
(id)[[UIColor whiteColor] colorWithAlphaComponent:0.0f].CGColor,
(id)[UIColor whiteColor].CGColor, nil];
vertical.locations = @[@0.01,@0.1,@0.9,@0.99];
[mapCover.layer insertSublayer:vertical atIndex:0];
CAGradientLayer * horizontal = [CAGradientLayer layer];
horizontal.frame = mapCover.bounds;
horizontal.colors = [NSArray arrayWithObjects:(id)[UIColor whiteColor].CGColor,
(id)[[UIColor whiteColor] colorWithAlphaComponent:0.0f].CGColor,
(id)[[UIColor whiteColor] colorWithAlphaComponent:0.0f].CGColor,
(id)[UIColor whiteColor].CGColor, nil];
horizontal.locations = @[@0.01,@0.1,@0.9,@0.99];
horizontal.startPoint = CGPointMake(0.0, 0.5);
horizontal.endPoint = CGPointMake(1.0, 0.5);
[mapCover.layer insertSublayer:horizontal atIndex:0];
Здесь есть некоторый код, который может сделать это для вас. Если вы измените слой в вашем представлении (переопределяя + (Class)layerClass), JTAInnerShadowLayer, затем вы можете установить внутреннюю тень на слое отступа в вашем методе init, и он сделает всю работу за вас. Если вы также хотите нарисовать оригинальный контент, обязательно позвоните setDrawOriginalImage:yes на отступе слоя. Здесь есть запись в блоге о том, как это работает.
Есть простое решение - просто нарисуйте нормальную тень и поверните, как это
@objc func shadowView() -> UIView {
let shadowView = UIView(frame: .zero)
shadowView.backgroundColor = .white
shadowView.layer.shadowColor = UIColor.grey.cgColor
shadowView.layer.shadowOffset = CGSize(width: 0, height: 2)
shadowView.layer.shadowOpacity = 1.0
shadowView.layer.shadowRadius = 4
shadowView.layer.compositingFilter = "multiplyBlendMode"
return shadowView
}
func idtm_addBottomShadow() {
let shadow = shadowView()
shadow.transform = transform.rotated(by: 180 * CGFloat(Double.pi))
shadow.transform = transform.rotated(by: -1 * CGFloat(Double.pi))
shadow.translatesAutoresizingMaskIntoConstraints = false
addSubview(shadow)
NSLayoutConstraint.activate([
shadow.leadingAnchor.constraint(equalTo: leadingAnchor),
shadow.trailingAnchor.constraint(equalTo: trailingAnchor),
shadow.bottomAnchor.constraint(equalTo: bottomAnchor),
shadow.heightAnchor.constraint(equalToConstant: 1),
])
}