ag-psd 15.3.1 → 16.0.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v16.0.0
+- Added support for different color modes in text layer colors
+- Added option for other smart layer filter types
+
 ## v15.3.0
 - Added support for smart layer puppet filter (`placedLayer.filter`)
 

package/dist/additionalInfo.js

@@ -887,7 +887,7 @@ function pointsToArray(points) {
     }
     return array;
 }
-function uin8ToPoints(array) {
+function uint8ToPoints(array) {
     return arrayToPoints(uint8ToFloat32(array));
 }
 function hrznVrtcToPoint(desc) {
@@ -902,6 +902,56 @@ function pointToHrznVrtc(point) {
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
+function parseFilterFXFilter(Fltr) {
+    if ('puppetShapeList' in Fltr) {
+        return {
+            rigidType: Fltr.rigidType,
+            bounds: [
+                { x: Fltr.PuX0, y: Fltr.PuY0, },
+                { x: Fltr.PuX1, y: Fltr.PuY1, },
+                { x: Fltr.PuX2, y: Fltr.PuY2, },
+                { x: Fltr.PuX3, y: Fltr.PuY3, },
+            ],
+            puppetShapeList: Fltr.puppetShapeList.map(function (p) { return ({
+                rigidType: p.rigidType,
+                // TODO: VrsM
+                // TODO: VrsN
+                originalVertexArray: uint8ToPoints(p.originalVertexArray),
+                deformedVertexArray: uint8ToPoints(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,
+                            }); }),
+                        }); }),
+                    }); }),
+                },
+            }); }),
+        };
+    }
+    else {
+        return {};
+    }
+}
 function parseFilterFX(desc) {
     return {
         enabled: desc.enab,
@@ -918,52 +968,65 @@ function parseFilterFX(desc) {
             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,
-                                }); }),
-                            }); }),
-                        }); }),
-                    },
-                }); }),
-            },
+            filter: parseFilterFXFilter(f.Fltr),
         }); }),
     };
 }
+function serializeFltr(filter) {
+    if ('puppetShapeList' in filter) {
+        return {
+            'null': ['Ordn.Trgt'],
+            rigidType: filter.rigidType,
+            puppetShapeList: 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: filter.bounds[0].x,
+            PuX1: filter.bounds[1].x,
+            PuX2: filter.bounds[2].x,
+            PuX3: filter.bounds[3].x,
+            PuY0: filter.bounds[0].y,
+            PuY1: filter.bounds[1].y,
+            PuY2: filter.bounds[2].y,
+            PuY3: filter.bounds[3].y,
+        };
+    }
+    else {
+        return {
+            LqMe: new Uint8Array(),
+        };
+    }
+}
 function serializeFilterFX(filter) {
     return {
         enab: filter.enabled,
@@ -981,52 +1044,7 @@ function serializeFilterFX(filter) {
             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,
-            },
+            Fltr: serializeFltr(f.filter),
             filterID: f.id,
         }); }),
     };