Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/SpaceWarpView/STCMeshView/BUILD

@@ -0,0 +1,23 @@
+
+objc_library(
+    name = "STCMeshView",
+    enable_modules = True,
+    module_name = "STCMeshView",
+    srcs = glob([
+        "Sources/**/*.m",
+        "Sources/**/*.h",
+    ], allow_empty=True),
+    hdrs = glob([
+        "PublicHeaders/**/*.h",
+    ]),
+    includes = [
+        "PublicHeaders",
+    ],
+    sdk_frameworks = [
+        "Foundation",
+        "UIKit",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/TelegramUI/Components/SpaceWarpView/STCMeshView/PublicHeaders/STCMeshView/STCMeshLayer.h

@@ -0,0 +1,58 @@
+/**
+ Copyright (c) 2014-present, Facebook, Inc.
+ All rights reserved.
+
+ This source code is licensed under the BSD-style license found in the
+ LICENSE file in the root directory of this source tree. An additional grant
+ of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <QuartzCore/QuartzCore.h>
+
+/* A mesh layer allows individually transforming areas inside its subtree. */
+
+@interface STCMeshLayer : CAReplicatorLayer
+
+/* An array of bounds regions to use for each instance. The length
+ * of this array is assumed to match `instanceCount'. Required. */
+
+@property (atomic, assign) CGRect *instanceBounds;
+
+/* An array of positions to use for each instance. The length
+ * of this array is assumed to match `instanceCount'. Required. */
+
+@property (atomic, assign) CGPoint *instancePositions;
+
+/* An array of anchor points to use for each instance. The length
+ * of this array is assumed to match `instanceCount'. Required. */
+
+@property (atomic, assign) CGPoint *instanceAnchorPoints;
+
+/* An array of transforms to apply to each instance. The length
+ * of this array is assumed to match `instanceCount'. Required. */
+
+@property (atomic, assign) CATransform3D *instanceTransforms;
+
+/* Add content to this layer to transform it in the mesh. */
+
+@property (atomic, strong) CALayer *contentLayer;
+
+/* This CAReplicatorLayer property is used internally and is not
+ * available for use by clients. Do not set it. */
+
+@property (atomic, assign) CFTimeInterval instanceDelay NS_UNAVAILABLE;
+
+/* This CAReplicatorLayer property is used internally and is not
+ * available for use by clients. Do not set it. */
+
+@property (atomic, assign) CATransform3D instanceTransform NS_UNAVAILABLE;
+
+@end
+
+@interface STCMeshLayer (UIViewSupport)
+
+/* The wrapper replicator layer used to preserve a linear timespace. */
+
+@property (atomic, strong) CAReplicatorLayer *wrapperLayer;
+
+@end

submodules/TelegramUI/Components/SpaceWarpView/STCMeshView/PublicHeaders/STCMeshView/STCMeshView.h

@@ -0,0 +1,26 @@
+/**
+ Copyright (c) 2014-present, Facebook, Inc.
+ All rights reserved.
+
+ This source code is licensed under the BSD-style license found in the
+ LICENSE file in the root directory of this source tree. An additional grant
+ of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <STCMeshView/STCMeshLayer.h>
+
+// shows different part of its subviews with different transforms
+@interface STCMeshView : UIView
+
+@property (nonatomic, retain, readonly) STCMeshLayer *layer;
+@property (nonatomic, retain, readwrite) UIView *contentView; // only subviews added to this are transformed
+
+@property (nonatomic, assign, readwrite) NSInteger instanceCount; // defaults to 1
+@property (nonatomic, assign, readwrite) CATransform3D *instanceTransforms; // optional
+@property (nonatomic, assign, readwrite) CGRect *instanceBounds; // optional
+@property (nonatomic, assign, readwrite) CGPoint *instancePositions; // optional
+@property (nonatomic, assign, readwrite) CGPoint *instanceAnchorPoints; // optional
+
+@end

submodules/TelegramUI/Components/SpaceWarpView/STCMeshView/Sources/STCMeshLayer.m

@@ -0,0 +1,337 @@
+/**
+ Copyright (c) 2014-present, Facebook, Inc.
+ All rights reserved.
+
+ This source code is licensed under the BSD-style license found in the
+ LICENSE file in the root directory of this source tree. An additional grant
+ of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <STCMeshView/STCMeshLayer.h>
+
+static const CFTimeInterval STCMeshLayerTotalInstanceDelay = 10000000.0;
+static NSString *const STCMeshLayerBoundsAnimationKey = @"STCMeshLayerBoundsAnimation";
+static NSString *const STCMeshLayerTransformAnimationKey = @"STCMeshLayerTransformAnimation";
+static NSString *const STCMeshLayerPositionAnimationKey = @"STCMeshLayerPositionAnimation";
+static NSString *const STCMeshLayerAnchorPointAnimationKey = @"STCMeshLayerAnchorPointAnimation";
+static NSString *const STCMeshLayerInstanceDelayAnimationKey = @"STCMeshLayerInstanceDelayAnimation";
+
+@implementation STCMeshLayer {
+    CAReplicatorLayer *_wrapperLayer;
+    CALayer *_contentLayer;
+
+    CGRect *_instanceBounds;
+    CATransform3D *_instanceTransforms;
+    CGPoint *_instancePositions;
+    CGPoint *_instanceAnchorPoints;
+}
+
+#pragma mark - Lifecycle
+
+- (instancetype)init
+{
+    if ((self = [super init])) {
+        self.wrapperLayer = [[CAReplicatorLayer alloc] init];
+        self.contentLayer = [[CALayer alloc] init];
+    }
+
+    return self;
+}
+
+- (void)dealloc
+{
+    free(_instanceTransforms);
+    _instanceTransforms = NULL;
+    free(_instanceBounds);
+    _instanceBounds = NULL;
+}
+
+- (void)layoutSublayers
+{
+    [super layoutSublayers];
+
+    _wrapperLayer.frame = self.bounds;
+    _contentLayer.frame = _wrapperLayer.bounds;
+    [self _updateMeshAnimations];
+}
+
+#pragma mark - Properties
+
+@dynamic instanceDelay;
+
+@dynamic instanceTransform;
+
+- (void)setInstanceCount:(NSInteger)instanceCount
+{
+    if (instanceCount != self.instanceCount) {
+        [super setInstanceCount:instanceCount];
+
+        free(_instanceTransforms);
+        _instanceTransforms = NULL;
+        free(_instanceBounds);
+        _instanceBounds = NULL;
+
+        [self setNeedsLayout];
+    }
+}
+
+- (CATransform3D *)instanceTransforms
+{
+    CATransform3D *instanceTransforms = _instanceTransforms;
+
+    return instanceTransforms;
+}
+
+- (void)setInstanceTransforms:(CATransform3D *)instanceTransforms
+{
+    free(_instanceTransforms);
+    _instanceTransforms = NULL;
+
+    if (instanceTransforms != NULL) {
+        _instanceTransforms = calloc(sizeof(CATransform3D), self.instanceCount);
+        memcpy(_instanceTransforms, instanceTransforms, self.instanceCount * sizeof(CATransform3D));
+    }
+
+    [self setNeedsLayout];
+}
+
+- (CGPoint *)instancePositions
+{
+  CGPoint *instancePositions = _instancePositions;
+
+  return instancePositions;
+}
+
+- (void)setInstancePositions:(CGPoint *)instancePositions
+{
+  free(_instancePositions);
+  _instancePositions = NULL;
+
+  if (instancePositions != NULL) {
+    _instancePositions = calloc(sizeof(CGPoint), self.instanceCount);
+    memcpy(_instancePositions, instancePositions, self.instanceCount * sizeof(CGPoint));
+  }
+
+  [self setNeedsLayout];
+}
+
+- (CGPoint *)instanceAnchorPoints
+{
+  CGPoint *instanceAnchorPoints = _instanceAnchorPoints;
+
+  return instanceAnchorPoints;
+}
+
+- (void)setInstanceAnchorPoints:(CGPoint *)instanceAnchorPoints
+{
+  free(_instanceAnchorPoints);
+  _instanceAnchorPoints = NULL;
+
+  if (instanceAnchorPoints != NULL) {
+    _instanceAnchorPoints = calloc(sizeof(CGPoint), self.instanceCount);
+    memcpy(_instanceAnchorPoints, instanceAnchorPoints, self.instanceCount * sizeof(CGPoint));
+  }
+
+  [self setNeedsLayout];
+}
+
+- (CGRect *)instanceBounds
+{
+    CGRect *instanceBounds = _instanceBounds;
+
+    return instanceBounds;
+}
+
+- (void)setInstanceBounds:(CGRect *)instanceBounds
+{
+    free(_instanceBounds);
+    _instanceBounds = NULL;
+
+    if (instanceBounds != NULL) {
+        _instanceBounds = calloc(sizeof(CGRect), self.instanceCount);
+        memcpy(_instanceBounds, instanceBounds, self.instanceCount * sizeof(CGRect));
+    }
+
+    [self setNeedsLayout];
+}
+
+- (CALayer *)contentLayer
+{
+    CALayer *contentLayer = _contentLayer;
+
+    return contentLayer;
+}
+
+- (void)setContentLayer:(CALayer *)contentLayer
+{
+    if (contentLayer != _contentLayer) {
+        if (_contentLayer != nil) {
+            [_contentLayer removeFromSuperlayer];
+        }
+
+        _contentLayer = contentLayer;
+
+        if (_contentLayer != nil) {
+            [_wrapperLayer addSublayer:_contentLayer];
+        }
+    }
+}
+
+- (CAReplicatorLayer *)wrapperLayer
+{
+    CAReplicatorLayer *wrapperLayer = _wrapperLayer;
+
+    return wrapperLayer;
+}
+
+- (void)setWrapperLayer:(CAReplicatorLayer *)wrapperLayer
+{
+    if (wrapperLayer != _wrapperLayer) {
+        if (_contentLayer != nil) {
+            [_contentLayer removeFromSuperlayer];
+        }
+
+        if (_wrapperLayer != nil) {
+            [_wrapperLayer removeFromSuperlayer];
+        }
+
+        _wrapperLayer = wrapperLayer;
+
+        if (_wrapperLayer != nil) {
+            _wrapperLayer.masksToBounds = YES;
+            _wrapperLayer.instanceCount = 2;
+            CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+            CGColorRef hiddenColor = CGColorCreate(colorSpace, (CGFloat []){ 1.0, 1.0, 1.0, 0.0 });
+            _wrapperLayer.instanceColor = hiddenColor;
+            CGColorRelease(hiddenColor);
+            CGColorSpaceRelease(colorSpace);
+            _wrapperLayer.instanceAlphaOffset = 1.0;
+            [self addSublayer:_wrapperLayer];
+        }
+
+        if (_contentLayer != nil) {
+            [_wrapperLayer addSublayer:_contentLayer];
+        }
+
+        [self setNeedsLayout];
+    }
+}
+
+#pragma mark - Internal Methods
+
+- (CGRect)_boundsAtIndex:(NSUInteger)index
+{
+    CGRect bounds = CGRectZero;
+
+    if (_instanceBounds != NULL) {
+        bounds = _instanceBounds[index];
+    }
+
+    return bounds;
+}
+
+- (CATransform3D)_transformAtIndex:(NSUInteger)index
+{
+    CATransform3D transform = CATransform3DIdentity;
+
+    if (_instanceTransforms != NULL) {
+        transform = _instanceTransforms[index];
+    }
+
+    return transform;
+}
+
+- (CGPoint)_positionAtIndex:(NSUInteger)index
+{
+  CGPoint position = CGPointZero;
+
+  if (_instancePositions != NULL) {
+    position = _instancePositions[index];
+  }
+
+  return position;
+}
+
+- (CGPoint)_anchorPointAtIndex:(NSUInteger)index
+{
+  CGPoint anchorPoint = CGPointMake(0.0, 0.0);
+
+  if (_instanceAnchorPoints != NULL) {
+    anchorPoint = _instanceAnchorPoints[index];
+  }
+
+  return anchorPoint;
+}
+
+- (void)_updateMeshAnimations
+{
+    [_wrapperLayer removeAllAnimations];
+
+    super.instanceDelay = -STCMeshLayerTotalInstanceDelay / self.instanceCount;
+
+    CAKeyframeAnimation *boundsAnimation = [CAKeyframeAnimation animationWithKeyPath:@"bounds"];
+    boundsAnimation.calculationMode = kCAAnimationDiscrete;
+    boundsAnimation.duration = STCMeshLayerTotalInstanceDelay;
+    boundsAnimation.removedOnCompletion = NO;
+    NSMutableArray *boundsValues = [NSMutableArray array];
+    for (NSUInteger i = 0; i < self.instanceCount; i++) {
+        CGRect bounds = [self _boundsAtIndex:i];
+        NSValue *boundsValue = [NSValue valueWithBytes:&bounds objCType:@encode(CGRect)];
+        [boundsValues addObject:boundsValue];
+    }
+    boundsAnimation.values = boundsValues;
+    [_wrapperLayer addAnimation:boundsAnimation forKey:STCMeshLayerBoundsAnimationKey];
+
+    CAKeyframeAnimation *transformAnimation = [CAKeyframeAnimation animationWithKeyPath:@"transform"];
+    transformAnimation.calculationMode = kCAAnimationDiscrete;
+    transformAnimation.duration = STCMeshLayerTotalInstanceDelay;
+    transformAnimation.removedOnCompletion = NO;
+    NSMutableArray *transformValues = [NSMutableArray array];
+    for (NSUInteger i = 0; i < self.instanceCount; i++) {
+        CATransform3D transform = [self _transformAtIndex:i];
+        NSValue *transformValue = [NSValue valueWithCATransform3D:transform];
+        [transformValues addObject:transformValue];
+    }
+    transformAnimation.values = transformValues;
+    [_wrapperLayer addAnimation:transformAnimation forKey:STCMeshLayerTransformAnimationKey];
+
+    CAKeyframeAnimation *positionAnimation = [CAKeyframeAnimation animationWithKeyPath:@"position"];
+    positionAnimation.calculationMode = kCAAnimationDiscrete;
+    positionAnimation.duration = STCMeshLayerTotalInstanceDelay;
+    positionAnimation.removedOnCompletion = NO;
+    NSMutableArray *positionValues = [NSMutableArray array];
+    for (NSUInteger i = 0; i < self.instanceCount; i++) {
+      CGPoint position = [self _positionAtIndex:i];
+      NSValue *positionValue = [NSValue valueWithBytes:&position objCType:@encode(CGPoint)];
+      [positionValues addObject:positionValue];
+    }
+    positionAnimation.values = positionValues;
+    [_wrapperLayer addAnimation:positionAnimation forKey:STCMeshLayerPositionAnimationKey];
+
+    CAKeyframeAnimation *anchorPointAnimation = [CAKeyframeAnimation animationWithKeyPath:@"anchorPoint"];
+    anchorPointAnimation.calculationMode = kCAAnimationDiscrete;
+    anchorPointAnimation.duration = STCMeshLayerTotalInstanceDelay;
+    anchorPointAnimation.removedOnCompletion = NO;
+    NSMutableArray *anchorPointValues = [NSMutableArray array];
+    for (NSUInteger i = 0; i < self.instanceCount; i++) {
+      CGPoint anchorPoint = [self _anchorPointAtIndex:i];
+      NSValue *anchorPointValue = [NSValue valueWithBytes:&anchorPoint objCType:@encode(CGPoint)];
+      [anchorPointValues addObject:anchorPointValue];
+    }
+    anchorPointAnimation.values = anchorPointValues;
+    [_wrapperLayer addAnimation:anchorPointAnimation forKey:STCMeshLayerAnchorPointAnimationKey];
+
+    CAKeyframeAnimation *timeAnimation = [CAKeyframeAnimation animationWithKeyPath:@"instanceDelay"];
+    timeAnimation.calculationMode = kCAAnimationDiscrete;
+    timeAnimation.duration = STCMeshLayerTotalInstanceDelay;
+    timeAnimation.removedOnCompletion = NO;
+    NSMutableArray *timeValues = [NSMutableArray array];
+    for (NSUInteger i = 0; i < self.instanceCount; i++) {
+        CFTimeInterval delay = -super.instanceDelay * i;
+        [timeValues addObject:@(delay)];
+    }
+    timeAnimation.values = timeValues;
+    [_wrapperLayer addAnimation:timeAnimation forKey:STCMeshLayerInstanceDelayAnimationKey];
+}
+
+@end

submodules/TelegramUI/Components/SpaceWarpView/STCMeshView/Sources/STCMeshView.m

@@ -0,0 +1,126 @@
+/**
+ Copyright (c) 2014-present, Facebook, Inc.
+ All rights reserved.
+
+ This source code is licensed under the BSD-style license found in the
+ LICENSE file in the root directory of this source tree. An additional grant
+ of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <STCMeshView/STCMeshView.h>
+#import <STCMeshView/STCMeshLayer.h>
+
+@interface _STCMeshViewReplicatorView : UIView
+
+@property (nonatomic, readonly, retain) CAReplicatorLayer  *layer;
+
+@end
+
+@implementation _STCMeshViewReplicatorView
+
+- (CAReplicatorLayer *)layer
+{
+    return (CAReplicatorLayer *)[super layer];
+}
+
++ (Class)layerClass
+{
+    return [CAReplicatorLayer class];
+}
+
+@end
+
+@implementation STCMeshView {
+    _STCMeshViewReplicatorView *_wrapperView;
+}
+
+- (STCMeshLayer *)layer
+{
+    return (STCMeshLayer *)[super layer];
+}
+
++ (Class)layerClass
+{
+    return [STCMeshLayer class];
+}
+
+- (NSInteger)instanceCount
+{
+    return self.layer.instanceCount;
+}
+
+- (void)setInstanceCount:(NSInteger)instanceCount
+{
+    self.layer.instanceCount = instanceCount;
+}
+
+- (CATransform3D *)instanceTransforms
+{
+    return self.layer.instanceTransforms;
+}
+
+- (void)setInstanceTransforms:(CATransform3D *)instanceTransforms
+{
+    self.layer.instanceTransforms = instanceTransforms;
+}
+
+- (CGRect *)instanceBounds
+{
+    return self.layer.instanceBounds;
+}
+
+- (void)setInstanceBounds:(CGRect *)instanceBounds
+{
+    self.layer.instanceBounds = instanceBounds;
+}
+
+- (CGPoint *)instancePositions
+{
+    return self.layer.instancePositions;
+}
+
+- (void)setInstancePositions:(CGPoint *)instancePositions
+{
+    self.layer.instancePositions = instancePositions;
+}
+
+- (CGPoint *)instanceAnchorPoints
+{
+  return self.layer.instanceAnchorPoints;
+}
+
+- (void)setInstanceAnchorPoints:(CGPoint *)instanceAnchorPoints
+{
+  self.layer.instanceAnchorPoints = instanceAnchorPoints;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if ((self = [super initWithFrame:frame])) {
+        _wrapperView = [[_STCMeshViewReplicatorView alloc] init];
+        [self addSubview:_wrapperView];
+        self.layer.wrapperLayer = _wrapperView.layer;
+
+        self.contentView = [[UIView alloc] init];
+    }
+
+    return self;
+}
+
+- (void)setContentView:(UIView *)contentView
+{
+    if (contentView != _contentView) {
+        if (_contentView != nil) {
+            [_contentView removeFromSuperview];
+        }
+
+        if (contentView != nil) {
+            [_wrapperView addSubview:contentView];
+        }
+
+        _contentView = contentView;
+        self.layer.contentLayer = _contentView.layer;
+    }
+}
+
+@end