@rafaelaugusto/jolt 0.1.0-beta.1 → 0.1.0-beta.11

package/platforms/ios/src/JoltImageEffect.mm

@@ -0,0 +1,242 @@
+#import "JoltImageEffect.h"
+#import <MetalKit/MetalKit.h>
+#import <simd/simd.h>
+
+static const char *JoltImageShader = R"METAL(
+#include <metal_stdlib>
+using namespace metal;
+struct Vertex {float4 position [[position]]; float2 uv;};
+struct Params {float2 size; float2 origin; float2 displacement; float progress; float amplitude; float radius; float seed; float mode;};
+vertex Vertex joltVertex(uint id [[vertex_id]]) {
+    float2 p[4]={float2(-1,-1),float2(1,-1),float2(-1,1),float2(1,1)};
+    float2 uv[4]={float2(0,1),float2(1,1),float2(0,0),float2(1,0)};
+    return {float4(p[id],0,1),uv[id]};
+}
+fragment float4 joltImage(Vertex in [[stage_in]], constant Params &u [[buffer(0)]],
+                         texture2d<float> source [[texture(0)]], texture2d<float> destination [[texture(1)]]) {
+    constexpr sampler s(coord::normalized,address::clamp_to_edge,filter::linear);
+    float2 p=in.uv*u.size,q=p;
+    if(u.mode<1.5) {
+        float2 v=p-u.origin; float d=length(v);
+        float edge=clamp(min(min(p.x,u.size.x-p.x),min(p.y,u.size.y-p.y))/max(u.amplitude*2.,1.),0.,1.);
+        if(u.mode<.5) {
+            float wave=d-u.progress*length(u.size);
+            float a=sin(wave/max(u.radius*.12,1.))*exp(-pow(wave/max(u.radius,1.),2.))*u.amplitude*sin(u.progress*3.14159265);
+            q-=v/max(d,1.)*a*edge;
+        } else q-=u.displacement*exp(-d*d/max(u.radius*u.radius,1.))*edge;
+        return source.sample(s,q/u.size);
+    }
+    if(u.progress<=0.) return source.sample(s,in.uv);
+    if(u.progress>=1.) return destination.sample(s,in.uv);
+    float n=fract(sin(dot(floor(p/3.),float2(12.9898,78.233))+u.seed)*43758.5453);
+    float a=smoothstep(n-.08,n+.08,u.progress*1.16-.08);
+    return mix(source.sample(s,in.uv),destination.sample(s,in.uv),a);
+}
+)METAL";
+
+typedef struct {
+    vector_float2 size, origin, displacement;
+    float progress, amplitude, radius, seed, mode;
+} JoltImageParams;
+
+@interface JoltImageEffect () <MTKViewDelegate, UIGestureRecognizerDelegate>
+@property(nonatomic, weak) UIImageView *image;
+@property(nonatomic, strong) UIImage *original;
+@property(nonatomic, strong) MTKView *surface;
+@property(nonatomic, strong) id<MTLCommandQueue> queue;
+@property(nonatomic, strong) id<MTLRenderPipelineState> pipeline;
+@property(nonatomic, strong) id<MTLTexture> sourceTexture, destinationTexture;
+@property(nonatomic, strong) UIPanGestureRecognizer *pan;
+@property(nonatomic, copy) void (^listener)(BOOL,double);
+@property(nonatomic) BOOL originalInteraction, disposed, playing, settling;
+@property(nonatomic, readwrite) BOOL paused;
+@property(nonatomic, readwrite) double progress;
+@property(nonatomic, readwrite) NSUInteger frames;
+@property(nonatomic, readwrite) double longestFrame;
+@property(nonatomic, readwrite) NSUInteger textureBytes;
+@property(nonatomic) double duration, goal, anchor, startProgress, remaining, previousFrame;
+@property(nonatomic) vector_float2 settleStart;
+@property(nonatomic) JoltImageParams params;
+@end
+
+@implementation JoltImageEffect
++ (instancetype)createWithView:(UIImageView *)view destination:(UIImage *)destination mode:(NSInteger)mode
+                       originX:(double)x originY:(double)y amplitude:(double)amplitude radius:(double)radius
+                      duration:(double)duration seed:(double)seed listener:(void (^)(BOOL,double))listener {
+    if(!view.image.CGImage || view.image.images.count || view.image.renderingMode==UIImageRenderingModeAlwaysTemplate || !view.window) return nil;
+    CGFloat scale=view.window.screen.scale;
+    NSUInteger w=(NSUInteger)ceil(view.bounds.size.width*scale),h=(NSUInteger)ceil(view.bounds.size.height*scale);
+    if(!w || !h || w*h>4194304 || (mode==2 && !destination.CGImage)) return nil;
+    id<MTLDevice> device=MTLCreateSystemDefaultDevice();
+    if(!device) return nil;
+    static id<MTLRenderPipelineState> cached;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        NSError *error=nil;
+        id<MTLLibrary> library=[device newLibraryWithSource:[NSString stringWithUTF8String:JoltImageShader] options:nil error:&error];
+        MTLRenderPipelineDescriptor *descriptor=[MTLRenderPipelineDescriptor new];
+        descriptor.vertexFunction=[library newFunctionWithName:@"joltVertex"];
+        descriptor.fragmentFunction=[library newFunctionWithName:@"joltImage"];
+        descriptor.colorAttachments[0].pixelFormat=MTLPixelFormatBGRA8Unorm;
+        if(library) cached=[device newRenderPipelineStateWithDescriptor:descriptor error:&error];
+        if(error) NSLog(@"Jolt image shader unavailable: %@",error.localizedDescription);
+    });
+    if(!cached) return nil;
+    JoltImageEffect *effect=[JoltImageEffect new];
+    effect.image=view; effect.original=view.image; effect.originalInteraction=view.userInteractionEnabled;
+    effect.listener=listener; effect.pipeline=cached; effect.queue=[device newCommandQueue];
+    effect.duration=duration/1000.; effect.goal=1; effect.paused=YES;
+    effect.params=(JoltImageParams){ {(float)w,(float)h}, {(float)(x*scale),(float)(y*scale)}, {0,0}, 0,
+        (float)(amplitude*scale),(float)(radius*scale),(float)seed,(float)mode };
+    effect.sourceTexture=[effect texture:view.image device:device width:w height:h];
+    effect.destinationTexture=mode==2?[effect texture:destination device:device width:w height:h]:effect.sourceTexture;
+    if(!effect.sourceTexture || !effect.destinationTexture) return nil;
+    effect.textureBytes=w*h*4*(mode==2?2:1);
+    MTKView *surface=[[MTKView alloc] initWithFrame:view.bounds device:device];
+    surface.opaque=NO; surface.backgroundColor=UIColor.clearColor;
+    surface.clearColor=MTLClearColorMake(0,0,0,0);
+    surface.userInteractionEnabled=NO; surface.accessibilityElementsHidden=YES;
+    surface.colorPixelFormat=MTLPixelFormatBGRA8Unorm;
+    surface.autoResizeDrawable=NO; surface.drawableSize=CGSizeMake(w,h);
+    surface.preferredFramesPerSecond=MIN(120,view.window.screen.maximumFramesPerSecond);
+    surface.paused=YES; surface.enableSetNeedsDisplay=YES;
+    surface.delegate=effect; effect.surface=surface;
+    [view addSubview:surface];
+    // Draw the identity frame before suppressing the original raster.
+    [surface draw]; view.image=nil;
+    if(mode==1) {
+        effect.pan=[[UIPanGestureRecognizer alloc] initWithTarget:effect action:@selector(drag:)];
+        effect.pan.delegate=effect; effect.pan.cancelsTouchesInView=NO;
+        view.userInteractionEnabled=YES; [view addGestureRecognizer:effect.pan];
+    }
+    return effect;
+}
+- (id<MTLTexture>)texture:(UIImage *)image device:(id<MTLDevice>)device width:(NSUInteger)w height:(NSUInteger)h {
+    if(!image.CGImage) return nil;
+    NSMutableData *data=[NSMutableData dataWithLength:w*h*4];
+    CGColorSpaceRef space=CGColorSpaceCreateDeviceRGB();
+    CGContextRef context=CGBitmapContextCreate(data.mutableBytes,w,h,8,w*4,space,kCGImageAlphaPremultipliedLast|kCGBitmapByteOrder32Big);
+    CGColorSpaceRelease(space);
+    if(!context) return nil;
+    CGContextTranslateCTM(context,0,h); CGContextScaleCTM(context,1,-1);
+    CGFloat iw=image.size.width,ih=image.size.height;
+    UIViewContentMode mode=self.image.contentMode;
+    CGFloat factor=mode==UIViewContentModeScaleAspectFill?MAX(w/iw,h/ih):MIN(w/iw,h/ih);
+    BOOL unscaled=mode==UIViewContentModeCenter || mode==UIViewContentModeTopLeft;
+    CGFloat dw=mode==UIViewContentModeScaleToFill?w:unscaled?iw*self.image.window.screen.scale:iw*factor;
+    CGFloat dh=mode==UIViewContentModeScaleToFill?h:unscaled?ih*self.image.window.screen.scale:ih*factor;
+    CGFloat left=mode==UIViewContentModeTopLeft?0:(w-dw)/2,top=mode==UIViewContentModeTopLeft?0:(h-dh)/2;
+    UIGraphicsPushContext(context); [image drawInRect:CGRectMake(left,top,dw,dh)]; UIGraphicsPopContext();
+    CGContextRelease(context);
+    MTLTextureDescriptor *descriptor=[MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm width:w height:h mipmapped:NO];
+    descriptor.usage=MTLTextureUsageShaderRead;
+    id<MTLTexture> texture=[device newTextureWithDescriptor:descriptor];
+    [texture replaceRegion:MTLRegionMake2D(0,0,w,h) mipmapLevel:0 withBytes:data.bytes bytesPerRow:w*4];
+    return texture;
+}
+- (void)play:(double)endpoint {
+    if(self.disposed || self.params.mode==1) return;
+    self.goal=endpoint; self.startProgress=self.progress; self.remaining=MAX(.001,self.duration*fabs(endpoint-self.progress));
+    self.anchor=CACurrentMediaTime(); self.playing=YES; self.settling=NO; self.paused=NO;
+    self.previousFrame=0; self.surface.enableSetNeedsDisplay=NO; self.surface.paused=NO;
+}
+- (void)pause {
+    if(self.disposed) return;
+    [self advance:CACurrentMediaTime()]; self.paused=YES;
+    self.surface.paused=YES; self.surface.enableSetNeedsDisplay=YES;
+}
+- (void)resume {
+    if(self.disposed || !self.paused) return;
+    if(self.params.mode==1) {
+        self.paused=NO;
+        if(self.settling && self.playing) {
+            self.settleStart=self.params.displacement;self.anchor=CACurrentMediaTime();
+            self.remaining=MIN(.6,self.duration);self.previousFrame=0;
+            self.surface.enableSetNeedsDisplay=NO;self.surface.paused=NO;
+        }
+        return;
+    }
+    [self play:self.goal];
+}
+- (void)seek:(double)value {
+    if(self.disposed || self.params.mode==1) return;
+    BOOL hold=self.paused; self.progress=value;
+    JoltImageParams p=self.params;p.progress=value;self.params=p;
+    [self.surface draw];
+    if(!hold) [self play:self.goal];
+}
+- (void)finish:(double)endpoint {
+    if(self.disposed || self.params.mode==1) return;
+    self.progress=endpoint; self.playing=NO;
+    self.surface.paused=YES;
+    if(self.listener) self.listener(YES,endpoint);
+}
+- (void)stop {
+    [self detach:YES];
+}
+- (void)stopPreservingImage {
+    [self detach:NO];
+}
+- (void)detach:(BOOL)restoreImage {
+    if(self.disposed) return;
+    self.disposed=YES; self.surface.paused=YES; self.surface.delegate=nil;
+    [self.surface removeFromSuperview]; self.surface=nil;
+    if(self.pan) { [self.image removeGestureRecognizer:self.pan];self.image.userInteractionEnabled=self.originalInteraction;self.pan=nil; }
+    if(restoreImage && !self.image.image) self.image.image=self.original;
+    self.sourceTexture=nil;self.destinationTexture=nil;self.original=nil;self.queue=nil;
+    self.textureBytes=0; self.listener=nil;
+}
+- (void)advance:(double)now {
+    if(!self.playing || self.paused || self.disposed) return;
+    double t=MIN(1,MAX(0,(now-self.anchor)/self.remaining));
+    JoltImageParams p=self.params;
+    if(self.settling) p.displacement=self.settleStart*(float)(exp(-8*t)*(1-t));
+    else {self.progress=self.startProgress+(self.goal-self.startProgress)*t;p.progress=self.progress;}
+    self.params=p;
+    if(t>=1) {
+        self.playing=NO;self.surface.paused=YES;self.surface.enableSetNeedsDisplay=YES;
+        if(!self.settling && self.listener) self.listener(YES,self.progress);
+    }
+}
+- (void)drawInMTKView:(MTKView *)view {
+    if(self.disposed) return;
+    double now=CACurrentMediaTime();
+    if(self.previousFrame>0 && self.playing) self.longestFrame=MAX(self.longestFrame,now-self.previousFrame);
+    self.previousFrame=now;self.frames++;
+    [self advance:now];
+    if(self.disposed) return;
+    MTLRenderPassDescriptor *pass=view.currentRenderPassDescriptor;
+    id<CAMetalDrawable> drawable=view.currentDrawable;
+    if(!pass || !drawable) return;
+    id<MTLCommandBuffer> command=[self.queue commandBuffer];
+    id<MTLRenderCommandEncoder> encoder=[command renderCommandEncoderWithDescriptor:pass];
+    [encoder setRenderPipelineState:self.pipeline];
+    JoltImageParams params=self.params;
+    [encoder setFragmentBytes:&params length:sizeof(params) atIndex:0];
+    [encoder setFragmentTexture:self.sourceTexture atIndex:0];
+    [encoder setFragmentTexture:self.destinationTexture atIndex:1];
+    [encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+    [encoder endEncoding]; [command presentDrawable:drawable]; [command commit];
+}
+- (void)mtkView:(MTKView *)view drawableSizeWillChange:(CGSize)size {}
+- (void)drag:(UIPanGestureRecognizer *)gesture {
+    if(self.disposed || self.paused) return;
+    CGFloat scale=self.image.window.screen.scale;
+    JoltImageParams p=self.params;
+    if(gesture.state==UIGestureRecognizerStateBegan) {
+        self.playing=NO;self.surface.paused=YES;self.surface.enableSetNeedsDisplay=YES;
+        CGPoint position=[gesture locationInView:self.image],translation=[gesture translationInView:self.image];
+        p.origin=(vector_float2){(float)((position.x-translation.x)*scale),(float)((position.y-translation.y)*scale)};
+    }
+    if(gesture.state==UIGestureRecognizerStateBegan || gesture.state==UIGestureRecognizerStateChanged) {
+        CGPoint delta=[gesture translationInView:self.image];
+        double length=hypot(delta.x,delta.y)*scale;
+        double factor=length==0?0:p.amplitude*tanh(length/MAX(p.amplitude,1))/length;
+        p.displacement=(vector_float2){(float)(delta.x*scale*factor),(float)(delta.y*scale*factor)};
+        self.params=p;[self.surface draw];
+    } else if(gesture.state==UIGestureRecognizerStateEnded || gesture.state==UIGestureRecognizerStateCancelled || gesture.state==UIGestureRecognizerStateFailed) {
+        self.settleStart=p.displacement;self.anchor=CACurrentMediaTime();self.remaining=MIN(.6,self.duration);
+        self.playing=YES;self.settling=YES;self.surface.enableSetNeedsDisplay=NO;self.surface.paused=NO;
+    }
+}
+@end

package/platforms/ios/src/JoltInteractiveAnimation.h

@@ -0,0 +1,18 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+
+/** Native sampled playback for opt-in interactive views. No UIKit method replacement. */
+@interface JoltInteractiveAnimation : NSObject
++ (instancetype)startView:(UIView *)view layers:(NSArray<CALayer *> *)layers keyPath:(NSString *)keyPath
+                  values:(NSArray<NSNumber *> *)values times:(NSArray<NSNumber *> *)times
+                duration:(double)duration delay:(double)delay repeat:(double)repeat
+                 reverse:(BOOL)reverse finalValue:(double)finalValue
+               startedAt:(double)startedAt completion:(void (^)(BOOL))completion;
++ (void)syncView:(UIView *)view excluding:(nullable NSString *)keyPath;
++ (nullable NSNumber *)valueForView:(UIView *)view keyPath:(NSString *)keyPath;
++ (NSUInteger)activeCount;
+@property(nonatomic, readonly) double elapsed;
+- (void)control:(double)elapsed paused:(BOOL)paused;
+- (void)cancel;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltInteractiveAnimation.m

@@ -0,0 +1,123 @@
+#import "JoltInteractiveAnimation.h"
+#import <QuartzCore/QuartzCore.h>
+
+@interface JoltInteractiveAnimation ()
+@property(nonatomic, weak) UIView *view;
+@property(nonatomic, copy) NSArray<CALayer *> *layers;
+@property(nonatomic, copy) NSString *keyPath;
+@property(nonatomic, copy) NSArray<NSNumber *> *values;
+@property(nonatomic, copy) NSArray<NSNumber *> *times;
+@property(nonatomic) double duration, delay, repeats, anchor, offset, finalValue;
+@property(nonatomic) BOOL reverse, paused, stopped;
+@property(nonatomic, copy, nullable) void (^completion)(BOOL);
+@end
+
+@implementation JoltInteractiveAnimation
+static NSMapTable<UIView *, NSMutableDictionary<NSString *, JoltInteractiveAnimation *> *> *views;
+static NSMutableSet<JoltInteractiveAnimation *> *playing;
+static CADisplayLink *displayLink;
+
++ (void)initialize {
+    if (self != [JoltInteractiveAnimation class]) return;
+    views = [NSMapTable weakToStrongObjectsMapTable];
+    playing = [NSMutableSet new];
+}
++ (void)schedule {
+    if (playing.count && !displayLink) {
+        displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+        if (@available(iOS 15.0, *)) {
+            float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+            displayLink.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+        }
+        [displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    } else if (!playing.count && displayLink) {
+        [displayLink invalidate]; displayLink = nil;
+    }
+}
++ (void)tick:(CADisplayLink *)link {
+    for (JoltInteractiveAnimation *track in playing.allObjects) {
+        if (track.stopped || track.paused) continue;
+        if (!track.view) { [track finish:NO]; continue; }
+        double elapsed = track.elapsed;
+        [track apply:elapsed];
+        if (isfinite(track.repeats) && elapsed >= track.delay + track.duration * (track.repeats + 1))
+            [track finish:YES];
+    }
+}
++ (instancetype)startView:(UIView *)view layers:(NSArray<CALayer *> *)layers keyPath:(NSString *)keyPath
+                  values:(NSArray<NSNumber *> *)values times:(NSArray<NSNumber *> *)times
+                duration:(double)duration delay:(double)delay repeat:(double)repeat
+                 reverse:(BOOL)reverse finalValue:(double)finalValue
+               startedAt:(double)startedAt completion:(void (^)(BOOL))completion {
+    JoltInteractiveAnimation *track = [self new];
+    track.view = view; track.layers = layers; track.keyPath = keyPath; track.values = values; track.times = times;
+    track.duration = MAX(1, duration); track.delay = delay; track.repeats = repeat;
+    track.reverse = reverse; track.finalValue = finalValue;
+    track.anchor = startedAt; track.completion = completion;
+    NSMutableDictionary *properties = [views objectForKey:view];
+    if (!properties) { properties = [NSMutableDictionary new]; [views setObject:properties forKey:view]; }
+    JoltInteractiveAnimation *previous = properties[keyPath];
+    [previous cancel];
+    // Cancelling the last property can remove the dictionary from the weak map.
+    [views setObject:properties forKey:view];
+    properties[keyPath] = track;
+    [track apply:track.elapsed];
+    [playing addObject:track]; [self schedule];
+    return track;
+}
+- (double)elapsed { return self.offset + (self.paused ? 0 : CACurrentMediaTime() * 1000 - self.anchor); }
+- (double)value:(double)elapsed {
+    double total = self.delay + self.duration * (self.repeats + 1);
+    if (isfinite(total) && elapsed >= total) return self.finalValue;
+    double time = MAX(0, elapsed - self.delay);
+    double iteration = floor(time / self.duration);
+    double progress = fmod(time, self.duration) / self.duration;
+    if (self.reverse && fmod(iteration, 2) >= 1) progress = 1 - progress;
+    NSUInteger low = 0, high = self.times.count - 1;
+    while (low + 1 < high) {
+        NSUInteger middle = (low + high) / 2;
+        if (self.times[middle].doubleValue <= progress) low = middle; else high = middle;
+    }
+    double start = self.times[low].doubleValue, end = self.times[high].doubleValue;
+    double fraction = end > start ? MIN(1, MAX(0, (progress - start) / (end - start))) : 1;
+    return self.values[low].doubleValue + (self.values[high].doubleValue - self.values[low].doubleValue) * fraction;
+}
+- (void)apply:(double)elapsed {
+    UIView *view = self.view;
+    if (!view || self.stopped) return;
+    double value = [self value:elapsed];
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    if ([self.keyPath isEqualToString:@"opacity"]) view.alpha = value;
+    for (CALayer *layer in self.layers) [layer setValue:@(value) forKeyPath:self.keyPath];
+    [CATransaction commit];
+}
+- (void)control:(double)elapsed paused:(BOOL)paused {
+    if (self.stopped) return;
+    self.offset = elapsed; self.anchor = CACurrentMediaTime() * 1000; self.paused = paused;
+    [self apply:elapsed];
+    if (paused) [playing removeObject:self]; else [playing addObject:self];
+    [[self class] schedule];
+}
+- (void)finish:(BOOL)completed {
+    if (self.stopped) return;
+    self.stopped = YES;
+    [playing removeObject:self];
+    UIView *view = self.view;
+    NSMutableDictionary *properties = view ? [views objectForKey:view] : nil;
+    if (properties[self.keyPath] == self) [properties removeObjectForKey:self.keyPath];
+    if (view && !properties.count) [views removeObjectForKey:view];
+    void (^callback)(BOOL) = self.completion; self.completion = nil;
+    [[self class] schedule];
+    if (callback) callback(completed);
+}
+- (void)cancel { [self finish:NO]; }
++ (void)syncView:(UIView *)view excluding:(NSString *)keyPath {
+    for (JoltInteractiveAnimation *track in [views objectForKey:view].allValues)
+        if (![track.keyPath isEqualToString:keyPath]) [track apply:track.elapsed];
+}
++ (NSNumber *)valueForView:(UIView *)view keyPath:(NSString *)keyPath {
+    JoltInteractiveAnimation *track = [views objectForKey:view][keyPath];
+    return track ? [view.layer valueForKeyPath:keyPath] : nil;
+}
++ (NSUInteger)activeCount { return playing.count; }
+@end

package/platforms/ios/src/JoltPhotoZoom.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltPhotoZoom : NSObject
++ (instancetype)attachImage:(UIImageView *)image viewport:(UIView *)viewport
+                    minimum:(double)minimum maximum:(double)maximum doubleTap:(double)doubleTap
+                    dismiss:(BOOL)dismiss reduced:(BOOL)reduced
+                   backdrop:(nullable UIView *)backdrop chrome:(nullable UIView *)chrome
+                  onDismiss:(void (^)(double,double,double,double,double))onDismiss
+                  onSettled:(void (^)(double,double,double))onSettled;
+@property(nonatomic, readonly) double x;
+@property(nonatomic, readonly) double y;
+@property(nonatomic, readonly) double scale;
+@property(nonatomic, readonly) double dismissProgress;
+@property(nonatomic, readonly) BOOL dismissPending;
+- (void)zoom:(double)scale focusX:(double)x focusY:(double)y animated:(BOOL)animated;
+- (void)reset:(BOOL)animated;
+- (void)requestDismiss;
+- (void)setReduced:(BOOL)reduced;
+- (void)setActive:(BOOL)active;
+- (void)layout;
+- (void)stop;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltPhotoZoom.m

@@ -0,0 +1,229 @@
+#import "JoltPhotoZoom.h"
+#import <QuartzCore/QuartzCore.h>
+
+static double JoltClamp(double v,double lo,double hi){return MAX(lo,MIN(hi,v));}
+static double JoltRubber(double v,double lo,double hi,double size){
+    double edge=JoltClamp(v,lo,hi),d=v-edge;
+    return edge+copysign(size*(1-1/(fabs(d)*.55/MAX(size,1)+1)),d);
+}
+
+@interface JoltPhotoZoom () <UIGestureRecognizerDelegate>
+@property(nonatomic,weak) UIImageView *image;
+@property(nonatomic,weak) UIView *viewport,*backdrop,*chrome;
+@property(nonatomic,strong) UIPinchGestureRecognizer *pinch;
+@property(nonatomic,strong) UIPanGestureRecognizer *pan;
+@property(nonatomic,strong) UITapGestureRecognizer *tap;
+@property(nonatomic,strong) CADisplayLink *clock;
+@property(nonatomic,copy) void (^onDismiss)(double,double,double,double,double);
+@property(nonatomic,copy) void (^onSettled)(double,double,double);
+@property(nonatomic) CGAffineTransform original;
+@property(nonatomic) BOOL originalInteraction,originalClip,reduced,active,disposed,dismiss,closing;
+@property(nonatomic) double minimum,maximum,doubleTap,backdropAlpha,chromeAlpha;
+@property(nonatomic,readwrite) double x,y,scale,dismissProgress;
+@property(nonatomic,readwrite) BOOL dismissPending;
+@property(nonatomic) CGPoint anchor,lastFocus,lastPan,initialTranslation;
+@property(nonatomic) CGPoint rawPan;
+@property(nonatomic) double pinchFloor;
+@property(nonatomic) CGRect content;
+@property(nonatomic) CGSize viewportSize,imageSize;
+@property(nonatomic) NSInteger mode,touches;
+@property(nonatomic) double vx,vy,startTime,startX,startY,startScale,startProgress,targetX,targetY,targetScale;
+@end
+
+@implementation JoltPhotoZoom
++ (instancetype)attachImage:(UIImageView *)image viewport:(UIView *)viewport
+                    minimum:(double)minimum maximum:(double)maximum doubleTap:(double)doubleTap
+                    dismiss:(BOOL)dismiss reduced:(BOOL)reduced backdrop:(UIView *)backdrop chrome:(UIView *)chrome
+                  onDismiss:(void (^)(double,double,double,double,double))onDismiss
+                  onSettled:(void (^)(double,double,double))onSettled {
+    JoltPhotoZoom *z=[JoltPhotoZoom new];
+    z.image=image;z.viewport=viewport;z.backdrop=backdrop;z.chrome=chrome;
+    z.minimum=minimum;z.maximum=maximum;z.doubleTap=doubleTap;z.dismiss=dismiss;z->_reduced=reduced;z.active=YES;
+    z.onDismiss=onDismiss;z.onSettled=onSettled;
+    z.original=image.transform;z.originalInteraction=viewport.userInteractionEnabled;z.originalClip=viewport.clipsToBounds;
+    z.backdropAlpha=backdrop?backdrop.alpha:1;z.chromeAlpha=chrome?chrome.alpha:1;z.scale=minimum;
+    z.pan=[[UIPanGestureRecognizer alloc] initWithTarget:z action:@selector(panned:)];
+    z.pinch=[[UIPinchGestureRecognizer alloc] initWithTarget:z action:@selector(pinched:)];
+    z.tap=[[UITapGestureRecognizer alloc] initWithTarget:z action:@selector(tapped:)];
+    z.tap.numberOfTapsRequired=2;z.pan.delegate=z;z.pinch.delegate=z;z.tap.delegate=z;
+    [viewport addGestureRecognizer:z.pan];[viewport addGestureRecognizer:z.pinch];[viewport addGestureRecognizer:z.tap];
+    viewport.userInteractionEnabled=YES;viewport.clipsToBounds=YES;
+    [z measure];[z apply];
+    return z;
+}
+- (void)measure {
+    self.viewportSize=self.viewport.bounds.size;self.imageSize=self.image.bounds.size;
+    CGSize intrinsic=self.image.image.size;
+    double iw=self.imageSize.width,ih=self.imageSize.height,dw=intrinsic.width,dh=intrinsic.height;
+    if(dw<=0 || dh<=0){dw=iw;dh=ih;}
+    UIViewContentMode fit=self.image.contentMode;
+    double factor=fit==UIViewContentModeScaleAspectFill?MAX(iw/dw,ih/dh):MIN(iw/dw,ih/dh);
+    if(fit==UIViewContentModeScaleToFill){dw=iw;dh=ih;}
+    else if(fit!=UIViewContentModeCenter && fit!=UIViewContentModeTopLeft){dw*=factor;dh*=factor;}
+    CGPoint pivot=CGPointMake(self.image.layer.anchorPoint.x*iw,self.image.layer.anchorPoint.y*ih);
+    self.anchor=CGPointMake(self.image.layer.position.x+self.original.tx,self.image.layer.position.y+self.original.ty);
+    double ox=fit==UIViewContentModeTopLeft?0:(iw-dw)/2,oy=fit==UIViewContentModeTopLeft?0:(ih-dh)/2;
+    double left=MAX(0,ox),top=MAX(0,oy),right=MIN(iw,ox+dw),bottom=MIN(ih,oy+dh);
+    self.content=CGRectMake((left-pivot.x)*self.original.a,(top-pivot.y)*self.original.d,(right-left)*self.original.a,(bottom-top)*self.original.d);
+}
+- (CGRect)boundsFor:(double)scale {
+    double loX=self.viewportSize.width-self.anchor.x-CGRectGetMaxX(self.content)*scale;
+    double hiX=-self.anchor.x-CGRectGetMinX(self.content)*scale;
+    double loY=self.viewportSize.height-self.anchor.y-CGRectGetMaxY(self.content)*scale;
+    double hiY=-self.anchor.y-CGRectGetMinY(self.content)*scale;
+    if(loX>hiX)loX=hiX=(loX+hiX)/2;
+    if(loY>hiY)loY=hiY=(loY+hiY)/2;
+    return CGRectMake(loX,loY,hiX-loX,hiY-loY);
+}
+- (void)apply {
+    self.image.transform=CGAffineTransformMake(self.original.a*self.scale,0,0,self.original.d*self.scale,self.original.tx+self.x,self.original.ty+self.y);
+    self.backdrop.alpha=self.backdropAlpha*(1-self.dismissProgress);
+    self.chrome.alpha=self.chromeAlpha*(1-self.dismissProgress);
+}
+- (void)zoom:(double)value focusX:(double)fx focusY:(double)fy animated:(BOOL)animated {
+    if(self.disposed || self.dismissPending)return;
+    [self cancelAnimation];double next=JoltClamp(value,self.minimum,self.maximum);
+    double x=fx-self.anchor.x-(fx-self.anchor.x-self.x)*next/self.scale;
+    double y=fy-self.anchor.y-(fy-self.anchor.y-self.y)*next/self.scale;
+    CGRect b=[self boundsFor:next];
+    [self springX:JoltClamp(x,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(y,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:next vx:0 vy:0 animated:animated close:NO];
+}
+- (void)reset:(BOOL)animated {
+    if(self.disposed)return;
+    self.dismissPending=NO;self.mode=0;CGRect b=[self boundsFor:self.minimum];
+    [self springX:JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:self.minimum vx:0 vy:0 animated:animated close:NO];
+}
+- (void)requestDismiss {
+    if(self.disposed || self.dismissPending || !self.dismiss)return;
+    CGRect b=[self boundsFor:self.minimum];
+    [self springX:JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:self.minimum vx:0 vy:0 animated:YES close:YES];
+}
+- (void)setReduced:(BOOL)reduced { _reduced=reduced;if(reduced){if(self.dismissPending)[self reset:NO];else [self settle:NO];} }
+- (void)setActive:(BOOL)active {
+    _active=active;self.pan.enabled=active;self.pinch.enabled=active;self.tap.enabled=active;
+    if(!active){[self cancelAnimation];self.dismissPending=NO;[self reset:NO];}
+}
+- (void)layout {
+    if(self.disposed)return;
+    if(CGSizeEqualToSize(self.viewportSize,self.viewport.bounds.size) && CGSizeEqualToSize(self.imageSize,self.image.bounds.size))return;
+    [self cancelAnimation];self.dismissPending=NO;[self measure];self.vx=0;self.vy=0;self.mode=0;[self settle:NO];
+}
+- (void)stop {
+    if(self.disposed)return;
+    self.disposed=YES;[self cancelAnimation];
+    [self.viewport removeGestureRecognizer:self.pan];[self.viewport removeGestureRecognizer:self.pinch];[self.viewport removeGestureRecognizer:self.tap];
+    self.viewport.userInteractionEnabled=self.originalInteraction;self.viewport.clipsToBounds=self.originalClip;
+    self.image.transform=self.original;self.backdrop.alpha=self.backdropAlpha;self.chrome.alpha=self.chromeAlpha;
+    self.onDismiss=nil;self.onSettled=nil;
+}
+- (void)cancelAnimation { [self.clock invalidate];self.clock=nil;self.closing=NO; }
+- (void)springX:(double)x y:(double)y scale:(double)scale vx:(double)vx vy:(double)vy animated:(BOOL)animated close:(BOOL)close {
+    [self cancelAnimation];
+    if(!animated || self.reduced){
+        self.x=x;self.y=y;self.scale=scale;self.dismissProgress=0;[self apply];
+        if(close)[self emitDismiss:0];else if(self.onSettled)self.onSettled(x,y,scale);
+        return;
+    }
+    self.startX=self.x;self.startY=self.y;self.startScale=self.scale;self.startProgress=self.dismissProgress;
+    self.targetX=x;self.targetY=y;self.targetScale=scale;self.vx=vx;self.vy=vy;self.closing=close;
+    self.startTime=CACurrentMediaTime();self.clock=[CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    self.clock.preferredFramesPerSecond=MIN(120,self.viewport.window.screen.maximumFramesPerSecond);
+    [self.clock addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)tick:(CADisplayLink *)clock {
+    double t=MIN(.55,MAX(0,CACurrentMediaTime()-self.startTime)),decay=exp(-16*t);
+    self.x=self.targetX+((self.startX-self.targetX)+(self.vx+16*(self.startX-self.targetX))*t)*decay;
+    self.y=self.targetY+((self.startY-self.targetY)+(self.vy+16*(self.startY-self.targetY))*t)*decay;
+    self.scale=self.targetScale+(self.startScale-self.targetScale)*(1+16*t)*decay;
+    self.dismissProgress=self.startProgress*(1+16*t)*decay;
+    if(t>=.55){self.x=self.targetX;self.y=self.targetY;self.scale=self.targetScale;self.dismissProgress=0;}
+    [self apply];
+    if(t>=.55){BOOL close=self.closing;[self cancelAnimation];if(close)[self emitDismiss:0];else if(self.onSettled)self.onSettled(self.x,self.y,self.scale);}
+}
+- (void)settle:(BOOL)animated {
+    if(self.disposed)return;
+    double s=JoltClamp(self.scale,self.minimum,self.maximum);CGRect b=[self boundsFor:s];
+    double x=JoltClamp(self.x+self.vx*.12,CGRectGetMinX(b),CGRectGetMaxX(b));
+    double y=JoltClamp(self.y+self.vy*.12,CGRectGetMinY(b),CGRectGetMaxY(b));
+    if(self.mode==2){s=self.minimum;b=[self boundsFor:s];x=JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b));y=JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b));}
+    [self springX:x y:y scale:s vx:self.vx vy:self.vy animated:animated close:NO];
+}
+- (void)emitDismiss:(double)velocity {
+    if(self.disposed || self.dismissPending)return;
+    self.dismissPending=YES;
+    if(self.onDismiss)self.onDismiss(self.x,self.y,self.scale,velocity,self.dismissProgress);
+}
+- (void)pinched:(UIPinchGestureRecognizer *)gesture {
+    if(self.disposed || self.dismissPending)return;
+    CGPoint focus=[gesture locationInView:self.viewport];
+    if(gesture.state==UIGestureRecognizerStateBegan){
+        [self cancelAnimation];self.mode=1;self.pinchFloor=MIN(self.minimum,self.scale);self.lastFocus=focus;gesture.scale=1;
+    } else if(gesture.state==UIGestureRecognizerStateChanged){
+        double next=JoltClamp(self.scale*gesture.scale,self.pinchFloor,self.maximum);
+        self.x=focus.x-self.anchor.x-(self.lastFocus.x-self.anchor.x-self.x)*next/self.scale;
+        self.y=focus.y-self.anchor.y-(self.lastFocus.y-self.anchor.y-self.y)*next/self.scale;
+        self.scale=next;self.lastFocus=focus;gesture.scale=1;
+        self.dismissProgress=JoltClamp((self.minimum-self.scale)/(self.minimum*.15),0,1);
+        [self rebasePan];[self apply];
+    } else if(gesture.state==UIGestureRecognizerStateEnded || gesture.state==UIGestureRecognizerStateCancelled){
+        self.lastPan=[self.pan translationInView:self.viewport];self.touches=self.pan.numberOfTouches;
+        self.vx=0;self.vy=0;
+        if(self.pan.state!=UIGestureRecognizerStateChanged && self.pan.state!=UIGestureRecognizerStateBegan)[self settle:YES];
+    }
+}
+- (void)panned:(UIPanGestureRecognizer *)gesture {
+    if(self.disposed || self.dismissPending)return;
+    CGPoint translation=[gesture translationInView:self.viewport];
+    if(gesture.state==UIGestureRecognizerStateBegan){
+        [self cancelAnimation];self.vx=0;self.vy=0;self.lastPan=CGPointZero;self.touches=gesture.numberOfTouches;
+        [self rebasePan];
+        self.mode=self.scale<=self.minimum+.001 && self.pinch.state!=UIGestureRecognizerStateBegan && self.pinch.state!=UIGestureRecognizerStateChanged?2:1;
+    }
+    if(gesture.state==UIGestureRecognizerStateBegan || gesture.state==UIGestureRecognizerStateChanged){
+        if(self.pinch.state==UIGestureRecognizerStateBegan || self.pinch.state==UIGestureRecognizerStateChanged || self.touches!=gesture.numberOfTouches){
+            self.lastPan=translation;self.touches=gesture.numberOfTouches;[self rebasePan];return;
+        }
+        double dx=translation.x-self.lastPan.x,dy=translation.y-self.lastPan.y;
+        self.lastPan=translation;
+        if(self.mode==2){
+            self.x+=dx*.4;self.y+=dy;self.dismissProgress=JoltClamp(fabs(self.y)/MAX(self.viewportSize.height*.5,1),0,1);
+            self.scale=self.minimum*(1-self.dismissProgress*.15);
+        }else{
+            CGRect b=[self boundsFor:self.scale];
+            self.rawPan=CGPointMake(self.rawPan.x+dx,self.rawPan.y+dy);
+            self.x=JoltRubber(self.rawPan.x,CGRectGetMinX(b),CGRectGetMaxX(b),self.viewportSize.width);
+            self.y=JoltRubber(self.rawPan.y,CGRectGetMinY(b),CGRectGetMaxY(b),self.viewportSize.height);
+        }
+        [self apply];
+    }else if(gesture.state==UIGestureRecognizerStateEnded || gesture.state==UIGestureRecognizerStateCancelled || gesture.state==UIGestureRecognizerStateFailed){
+        CGPoint velocity=[gesture velocityInView:self.viewport];self.vx=velocity.x;self.vy=velocity.y;
+        BOOL commit=gesture.state==UIGestureRecognizerStateEnded && self.mode==2 &&
+            (self.dismissProgress>.35 || (fabs(velocity.y)>1000 && velocity.y*self.y>0));
+        if(commit)[self emitDismiss:velocity.y];
+        else if(self.pinch.state!=UIGestureRecognizerStateChanged && self.pinch.state!=UIGestureRecognizerStateBegan)[self settle:YES];
+    }
+}
+- (void)tapped:(UITapGestureRecognizer *)gesture {
+    if(gesture.state!=UIGestureRecognizerStateEnded || self.dismissPending)return;
+    CGPoint point=[gesture locationInView:self.viewport];
+    [self zoom:self.scale>self.minimum+.01?self.minimum:MIN(self.maximum,self.doubleTap) focusX:point.x focusY:point.y animated:YES];
+}
+- (void)rebasePan {
+    CGRect b=[self boundsFor:self.scale];
+    double ex=JoltClamp(self.x,CGRectGetMinX(b),CGRectGetMaxX(b)),ey=JoltClamp(self.y,CGRectGetMinY(b),CGRectGetMaxY(b));
+    double dx=self.x-ex,dy=self.y-ey;
+    self.rawPan=CGPointMake(ex+dx/(.55*MAX(.001,1-fabs(dx)/MAX(1,self.viewportSize.width))),
+                           ey+dy/(.55*MAX(.001,1-fabs(dy)/MAX(1,self.viewportSize.height))));
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gesture {
+    if(self.disposed || !self.active || self.dismissPending)return NO;
+    if(gesture==self.pan && self.scale<=self.minimum+.001){
+        CGPoint velocity=[self.pan velocityInView:self.viewport];
+        return self.dismiss && fabs(velocity.y)>fabs(velocity.x)*1.2;
+    }
+    return YES;
+}
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)one shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)other {
+    return (one==self.pan && other==self.pinch)||(one==self.pinch && other==self.pan);
+}
+@end

package/platforms/ios/src/module.modulemap

@@ -0,0 +1,6 @@
+module JoltMotion {
+    header "JoltImageEffect.h"
+    header "JoltPhotoZoom.h"
+    header "JoltInteractiveAnimation.h"
+    export *
+}