ag-psd 15.2.0 → 15.3.0

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v15.3.0
+- Added support for smart layer puppet filter (`placedLayer.filter`)
+
 ## v15.2.0
 - Added handling missing `font` in text layer style by assuming first font on the list
 

package/dist/additionalInfo.js

@@ -864,6 +864,173 @@ addHandler('PlLd', hasKey('placedLayer'), function (reader, target, left) {
     var type = isQuilt ? 'quiltWarp' : 'warp';
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', type, encodeWarp(placed.warp || {}), type);
 });
+function uint8ToFloat32(array) {
+    return new Float32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+function uint8ToUint32(array) {
+    return new Uint32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+function toUint8(array) {
+    return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+}
+function arrayToPoints(array) {
+    var points = [];
+    for (var i = 0; i < array.length; i += 2) {
+        points.push({ x: array[i], y: array[i + 1] });
+    }
+    return points;
+}
+function pointsToArray(points) {
+    var array = [];
+    for (var i = 0; i < points.length; i++) {
+        array.push(points[i].x, points[i].y);
+    }
+    return array;
+}
+function uin8ToPoints(array) {
+    return arrayToPoints(uint8ToFloat32(array));
+}
+function hrznVrtcToPoint(desc) {
+    return {
+        x: (0, descriptor_1.parseUnits)(desc.Hrzn),
+        y: (0, descriptor_1.parseUnits)(desc.Vrtc),
+    };
+}
+function pointToHrznVrtc(point) {
+    return {
+        Hrzn: (0, descriptor_1.unitsValue)(point.x, 'x'),
+        Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
+    };
+}
+function parseFilterFX(desc) {
+    return {
+        enabled: desc.enab,
+        validAtPosition: desc.validAtPosition,
+        maskEnabled: desc.filterMaskEnable,
+        maskLinked: desc.filterMaskLinked,
+        maskExtendWithWhite: desc.filterMaskExtendWithWhite,
+        list: desc.filterFXList.map(function (f) { return ({
+            id: f.filterID,
+            name: f['Nm  '],
+            opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
+            blendMode: descriptor_1.BlnM.decode(f.blendOptions['Md  ']),
+            enabled: f.enab,
+            hasOptions: f.hasoptions,
+            foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
+            backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
+            filter: {
+                rigidType: f.Fltr.rigidType,
+                bounds: [
+                    { x: f.Fltr.PuX0, y: f.Fltr.PuY0, },
+                    { x: f.Fltr.PuX1, y: f.Fltr.PuY1, },
+                    { x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
+                    { x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
+                ],
+                puppetShapeList: f.Fltr.puppetShapeList.map(function (p) { return ({
+                    rigidType: p.rigidType,
+                    // TODO: VrsM
+                    // TODO: VrsN
+                    originalVertexArray: uin8ToPoints(p.originalVertexArray),
+                    deformedVertexArray: uin8ToPoints(p.deformedVertexArray),
+                    indexArray: Array.from(uint8ToUint32(p.indexArray)),
+                    pinOffsets: arrayToPoints(p.pinOffsets),
+                    posFinalPins: arrayToPoints(p.posFinalPins),
+                    pinVertexIndices: p.pinVertexIndices,
+                    selectedPin: p.selectedPin,
+                    pinPosition: arrayToPoints(p.PinP),
+                    pinRotation: p.PnRt,
+                    pinOverlay: p.PnOv,
+                    pinDepth: p.PnDp,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            shapeOperation: c.shapeOperation.split('.')[1],
+                            paths: c.SbpL.map(function (t) { return ({
+                                closed: t.Clsp,
+                                points: t['Pts '].map(function (pt) { return ({
+                                    anchor: hrznVrtcToPoint(pt.Anch),
+                                    forward: hrznVrtcToPoint(pt['Fwd ']),
+                                    backward: hrznVrtcToPoint(pt['Bwd ']),
+                                    smooth: pt.Smoo,
+                                }); }),
+                            }); }),
+                        }); }),
+                    },
+                }); }),
+            },
+        }); }),
+    };
+}
+function serializeFilterFX(filter) {
+    return {
+        enab: filter.enabled,
+        validAtPosition: filter.validAtPosition,
+        filterMaskEnable: filter.maskEnabled,
+        filterMaskLinked: filter.maskLinked,
+        filterMaskExtendWithWhite: filter.maskExtendWithWhite,
+        filterFXList: filter.list.map(function (f) { return ({
+            'Nm  ': f.name,
+            blendOptions: {
+                Opct: (0, descriptor_1.unitsPercent)(f.opacity),
+                'Md  ': descriptor_1.BlnM.encode(f.blendMode),
+            },
+            enab: f.enabled,
+            hasoptions: f.hasOptions,
+            FrgC: (0, descriptor_1.serializeColor)(f.foregroundColor),
+            BckC: (0, descriptor_1.serializeColor)(f.backgroundColor),
+            Fltr: {
+                'null': ['Ordn.Trgt'],
+                rigidType: f.filter.rigidType,
+                puppetShapeList: f.filter.puppetShapeList.map(function (p) { return ({
+                    rigidType: p.rigidType,
+                    VrsM: 1,
+                    VrsN: 0,
+                    originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
+                    deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
+                    indexArray: toUint8(new Uint32Array(p.indexArray)),
+                    pinOffsets: pointsToArray(p.pinOffsets),
+                    posFinalPins: pointsToArray(p.posFinalPins),
+                    selectedPin: p.selectedPin,
+                    pinVertexIndices: p.pinVertexIndices,
+                    PinP: pointsToArray(p.pinPosition),
+                    PnRt: p.pinRotation,
+                    PnOv: p.pinOverlay,
+                    PnDp: p.pinDepth,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            shapeOperation: "shapeOperation.".concat(c.shapeOperation),
+                            SbpL: c.paths.map(function (path) { return ({
+                                Clsp: path.closed,
+                                'Pts ': path.points.map(function (pt) { return ({
+                                    Anch: pointToHrznVrtc(pt.anchor),
+                                    'Fwd ': pointToHrznVrtc(pt.forward),
+                                    'Bwd ': pointToHrznVrtc(pt.backward),
+                                    Smoo: pt.smooth,
+                                }); }),
+                            }); }),
+                        }); }),
+                    },
+                }); }),
+                PuX0: f.filter.bounds[0].x,
+                PuX1: f.filter.bounds[1].x,
+                PuX2: f.filter.bounds[2].x,
+                PuX3: f.filter.bounds[3].x,
+                PuY0: f.filter.bounds[0].y,
+                PuY1: f.filter.bounds[1].y,
+                PuY2: f.filter.bounds[2].y,
+                PuY3: f.filter.bounds[3].y,
+            },
+            filterID: f.id,
+        }); }),
+    };
+}
 addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     if ((0, psdReader_1.readSignature)(reader) !== 'soLD')
         throw new Error("Invalid SoLd type");
@@ -874,6 +1041,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     // console.log('SoLd', require('util').inspect(desc, false, 99, true));
     // console.log('SoLd.warp', require('util').inspect(desc.warp, false, 99, true));
     // console.log('SoLd.quiltWarp', require('util').inspect(desc.quiltWarp, false, 99, true));
+    // desc.filterFX!.filterFXList[0].Fltr.puppetShapeList[0].meshBoundaryPath.pathComponents[0].SbpL[0]['Pts '] = [];
+    // console.log('filterFX', require('util').inspect(desc.filterFX, false, 99, true));
     target.placedLayer = {
         id: desc.Idnt,
         placed: desc.placed,
@@ -898,6 +1067,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         target.placedLayer.comp = desc.comp;
     if (desc.compInfo)
         target.placedLayer.compInfo = desc.compInfo;
+    if (desc.filterFX)
+        target.placedLayer.filter = parseFilterFX(desc.filterFX);
     (0, psdReader_1.skipBytes)(reader, left()); // HACK
 }, function (writer, target) {
     var _a, _b;
@@ -908,6 +1079,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
             Wdth: placed.width || 0,
             Hght: placed.height || 0, // TODO: find size ?
         }, Rslt: placed.resolution ? (0, descriptor_1.unitsValue)(placed.resolution, 'resolution') : { units: 'Density', value: 72 } });
+    if (placed.filter)
+        desc.filterFX = serializeFilterFX(placed.filter);
     if (placed.warp && isQuiltWarp(placed.warp)) {
         var quiltWarp = encodeWarp(placed.warp);
         desc.quiltWarp = quiltWarp;
@@ -2019,4 +2192,85 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target)
     (0, psdWriter_1.writeUint8)(writer, target.transparencyShapesLayer ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
+/*addHandler(
+    'FEid',
+    hasKey('filterEffects'),
+    (reader, _target) => {
+        const version = readInt32(reader);
+        if (version < 1 || version > 3) throw new Error(`Invalid filterEffects version ${version}`);
+
+        if (readUint32(reader)) throw new Error('filterEffects: 64 bit length is not supported');
+        const length = readUint32(reader);
+        const end = reader.offset + length;
+
+        while (reader.offset < end) {
+            console.log('bytes to go', end - reader.offset, 'at', reader.offset.toString(16));
+            //
+            const id = readPascalString(reader, 1);
+            const effectVersion = readInt32(reader);
+            if (effectVersion !== 1) throw new Error(`Invalid filterEffect version ${effectVersion}`);
+            if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
+            const effectLength = readUint32(reader);
+            const endOfEffect = reader.offset + effectLength;
+            const top = readInt32(reader);
+            const left = readInt32(reader);
+            const bottom = readInt32(reader);
+            const right = readInt32(reader);
+            const depth = readInt32(reader);
+            const maxChannels = readInt32(reader);
+            const channels: any[] = [];
+
+            for (let i = 0; i < (maxChannels + 2); i++) {
+                const exists = readInt32(reader);
+                if (exists) {
+                    if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
+                    const channelLength = readUint32(reader);
+                    const compressionMode = readUint16(reader);
+                    const data = readBytes(reader, channelLength - 2);
+                    channels.push({ channelLength, compressionMode, data: data?.length + ' bytes' });
+                    // if (c < 3 || c == 25) e_ = _F.Cn(!0, rL, m, b.rect.F, b.rect.V, X, rp);
+                    // if (c == 0) _c.S = e_;
+                    // if (c == 1) _c.v = e_;
+                    // if (c == 2) _c.e = e_;
+                    // if (c == 25) _c.w = e_;
+                } else {
+                    channels.push(undefined);
+                }
+            }
+
+            console.log('left at the end', endOfEffect - reader.offset);
+            if (endOfEffect > reader.offset) {
+                if (readUint8(reader)) {
+                    const compressionMode = readUint16(reader);
+                    const data = endOfEffect > reader.offset ? readBytes(reader, endOfEffect - reader.offset) : undefined;
+                    console.log('extra data', { compressionMode, data: data?.length + ' bytes' });
+                } else {
+                    console.log('no extra');
+                }
+            }
+
+            console.log('effect', {
+                id,
+                effectVersion,
+                effectLength,
+                top,
+                left,
+                bottom,
+                right,
+                depth,
+                maxChannels,
+                channels,
+            });
+
+            console.log('bytes left after effect', endOfEffect - reader.offset);
+            // if (length % 4) skipBytes(reader, 4 - length % 4);
+        }
+
+        console.log({ version, length });
+    },
+    (_writer, _target) => {
+    },
+);
+
+addHandlerAlias('FXid', 'FEid');*/
 //# sourceMappingURL=additionalInfo.js.map