Check for unsupported renderer (#111)

Author: vladavoX

plainly-aescripts/src/index.ts

@@ -12,27 +12,46 @@ import './shims';
 import {
   getInstalledFontsByFamilyNameAndStyleName,
   getInstalledFontsByPostScriptName,
+  selectComp,
   selectLayer,
-  unselectAllLayers,
 } from './utils';
-import { fixAllIssues, validateProject } from './validation';
+import { fixAllCapsIssues, fixAllIssues, validateProject } from './validation';
+import { fixUnsupported3DRendererIssues } from './validation/compValidators';
 
-const PlainlyAE = () => ({
-  selectFolder,
+const collectFunctions = {
   collectFiles,
+  selectFolder,
+  relinkFootage,
+};
+
+const projectFunctions = {
   setProjectData,
   getProjectData,
   removeProjectData,
   getProjectPath,
   saveProject,
   getAfterEffectsVersion,
-  relinkFootage,
   getInstalledFontsByPostScriptName,
   getInstalledFontsByFamilyNameAndStyleName,
+};
+
+const utilsFunctions = {
+  selectLayer,
+  selectComp,
+};
+
+const validateFunctions = {
   validateProject,
   fixAllIssues,
-  unselectAllLayers,
-  selectLayer,
+  fixAllCapsIssues,
+  fixUnsupported3DRendererIssues,
+};
+
+const PlainlyAE = () => ({
+  ...collectFunctions,
+  ...projectFunctions,
+  ...utilsFunctions,
+  ...validateFunctions,
 });
 
 if ($['com.plainlyvideos.after-effects-plugin.Panel']) {

plainly-aescripts/src/utils.ts

@@ -149,6 +149,7 @@ function unselectAllLayers(): void {
  * selectLayer('1234');
  */
 function selectLayer(layerId: string): void {
+  unselectAllLayers();
   const layer = app.project.layerByID(parseInt(layerId, 10));
   if (layer) {
     // open the comp that contains the layer, so it is visible to the user in timeline
@@ -161,6 +162,46 @@ function selectLayer(layerId: string): void {
   }
 }
 
+/**
+ * Deselects all compositions in the active project.
+ *
+ * Iterates through all `CompItem` instances in `app.project` and sets their `selected` property to `false`.
+ *
+ * @returns {void}
+ */
+function unselectedAllComps(): void {
+  const comps = getAllComps(app.project);
+  for (let i = 0; i < comps.length; i++) {
+    const comp = comps[i];
+    comp.selected = false;
+  }
+}
+
+/**
+ * Selects a composition in the active project by its numeric ID.
+ *
+ * Uses `app.project.itemByID` after parsing the provided string to base-10 integer. If a composition
+ * with the given ID exists, it is opened in a viewer and its `selected` property is set to `true`;
+ * otherwise the function exits silently.
+ *
+ * @param {string} compId - The string representation of the composition's numeric ID (e.g. value from `CompItem.id`).
+ * @returns {void}
+ * @example
+ * // Select a composition whose id is 5678
+ * selectComp('5678');
+ */
+function selectComp(compId: string): void {
+  unselectedAllComps();
+  const comp = app.project.itemByID(parseInt(compId, 10));
+  if (comp instanceof CompItem) {
+    const viewer = comp.openInViewer();
+    comp.selected = true;
+    if (viewer?.active === false) {
+      viewer.setActive();
+    }
+  }
+}
+
 export {
   getAllComps,
   getFolderPath,
@@ -169,6 +210,6 @@ export {
   getTextLayersByComp,
   isWin,
   pathJoin,
-  unselectAllLayers,
   selectLayer,
+  selectComp,
 };

plainly-aescripts/src/validation/compValidators.ts

@@ -0,0 +1,62 @@
+import type { CompIssues, RendererTypeName } from 'plainly-types';
+import { ProjectIssueType } from '.';
+
+enum RendererType {
+  CLASSIC_3D = 'ADBE Advanced 3d',
+  ADVANCED_3D = 'ADBE Calder',
+  CINEMA_4D = 'ADBE Ernst',
+}
+
+function getRendererName(renderer: string): RendererTypeName {
+  if (renderer === RendererType.CLASSIC_3D) return 'Classic 3D';
+  if (renderer === RendererType.ADVANCED_3D) return 'Advanced 3D';
+  if (renderer === RendererType.CINEMA_4D) return 'Cinema 4D';
+  return 'Unknown Renderer';
+}
+
+function validateComps(comps: CompItem[]): CompIssues[] {
+  const compIssues: CompIssues[] = [];
+
+  for (let i = 0; i < comps.length; i++) {
+    const comp = comps[i];
+    const renderer = comp.renderer;
+    if (renderer !== RendererType.CLASSIC_3D) {
+      compIssues.push({
+        type: ProjectIssueType.Unsupported3DRenderer,
+        compId: comp.id.toString(),
+        compName: comp.name,
+        renderer: getRendererName(renderer),
+      });
+    }
+  }
+
+  return compIssues;
+}
+
+function fixUnsupported3DRendererIssue(compId: string): void {
+  const comp = app.project.itemByID(parseInt(compId, 10));
+  if (!(comp && comp instanceof CompItem)) {
+    return;
+  }
+
+  comp.renderer = RendererType.CLASSIC_3D;
+}
+
+function fixUnsupported3DRendererIssues(compIds: string[]) {
+  app.beginUndoGroup('fix unsupported 3d renderer');
+
+  for (const compId of compIds) {
+    const comp = app.project.itemByID(parseInt(compId, 10));
+    if (comp && comp instanceof CompItem) {
+      comp.renderer = RendererType.CLASSIC_3D;
+    }
+  }
+
+  app.endUndoGroup();
+}
+
+export {
+  validateComps,
+  fixUnsupported3DRendererIssue,
+  fixUnsupported3DRendererIssues,
+};

plainly-aescripts/src/validation/index.ts

@@ -1,13 +1,23 @@
-import { checkTextLayers, fixAllCapsIssue } from './textValidators';
-import { type AnyProjectIssue, ProjectIssueType } from './types';
+import type { AnyProjectIssue } from 'plainly-types';
+import { getAllComps } from '../utils';
+import { fixUnsupported3DRendererIssue, validateComps } from './compValidators';
+import {
+  fixAllCapsIssue,
+  fixAllCapsIssues,
+  validateTextLayers,
+} from './textValidators';
+
+enum ProjectIssueType {
+  AllCaps = 'AllCaps',
+  Unsupported3DRenderer = 'Unsupported3DRenderer',
+}
 
 function validateProject(): string {
-  const textIssues = checkTextLayers();
-  let issues: AnyProjectIssue[] = [];
+  const comps = getAllComps(app.project);
 
-  if (textIssues.length > 0) {
-    issues = issues.concat(textIssues);
-  }
+  const textIssues = validateTextLayers(comps);
+  const compIssues = validateComps(comps);
+  const issues: AnyProjectIssue[] = [...textIssues, ...compIssues];
 
   if (issues.length > 0) {
     return JSON.stringify(issues);
@@ -17,14 +27,19 @@ function validateProject(): string {
 }
 
 function fixAllIssues(issues: AnyProjectIssue[]) {
+  app.beginUndoGroup('fix all');
+
   for (let i = 0; i < issues.length; i++) {
     const issue = issues[i];
     if (issue.type === ProjectIssueType.AllCaps) {
       fixAllCapsIssue(issue.layerId);
     }
+    if (issue.type === ProjectIssueType.Unsupported3DRenderer) {
+      fixUnsupported3DRendererIssue(issue.compId);
+    }
   }
 
-  validateProject();
+  app.endUndoGroup();
 }
 
-export { validateProject, fixAllIssues };
+export { validateProject, fixAllIssues, fixAllCapsIssues, ProjectIssueType };

plainly-aescripts/src/validation/textValidators.ts

@@ -1,9 +1,9 @@
-import { getAllComps, getTextLayersByComp } from '../utils';
-import { ProjectIssueType, type TextLayerIssues } from './types';
+import type { TextLayerIssues } from 'plainly-types';
+import { getTextLayersByComp } from '../utils';
+import { ProjectIssueType } from '.';
 
-function checkTextLayers(): TextLayerIssues[] {
-  const comps = getAllComps(app.project);
-  const textLayers: TextLayerIssues[] = [];
+function validateTextLayers(comps: CompItem[]): TextLayerIssues[] {
+  const textLayersIssues: TextLayerIssues[] = [];
 
   for (let i = 0; i < comps.length; i++) {
     const comp = comps[i];
@@ -24,11 +24,10 @@ function checkTextLayers(): TextLayerIssues[] {
       // this checks only the first character of the text layer
       // IMPORTANT: with this method, on older versions (< 24.3), we can't fix, but we can at least report it
       if (textDocument.allCaps) {
-        textLayers.push({
+        textLayersIssues.push({
           type: ProjectIssueType.AllCaps,
           layerId: layer.id.toString(),
           layerName: layer.name,
-          text: true,
         });
         continue;
       }
@@ -52,11 +51,10 @@ function checkTextLayers(): TextLayerIssues[] {
             cRange.fontCapsOption === FontCapsOption.FONT_ALL_CAPS
           ) {
             hasCharacterAllCaps = true;
-            textLayers.push({
+            textLayersIssues.push({
               type: ProjectIssueType.AllCaps,
               layerId: layer.id.toString(),
               layerName: layer.name,
-              text: true,
             });
             break;
           }
@@ -73,17 +71,16 @@ function checkTextLayers(): TextLayerIssues[] {
         range.isRangeValid &&
         range.fontCapsOption === FontCapsOption.FONT_ALL_CAPS
       ) {
-        textLayers.push({
+        textLayersIssues.push({
           type: ProjectIssueType.AllCaps,
           layerId: layer.id.toString(),
           layerName: layer.name,
-          text: true,
         });
       }
     }
   }
 
-  return textLayers;
+  return textLayersIssues;
 }
 
 /**
@@ -138,10 +135,28 @@ function fixAllCapsIssue(layerId: string) {
   updateLayerTextDocument(layer, newValue);
 }
 
+/**
+ * Fixes all caps issues for multiple text layers in a single undo group.
+ *
+ * **NOTE**: Works only on `After Effects 24.3` and later due to the use of `characterRange` method and `fontCapsOption`.
+ *
+ * @param layerIds Array of layer IDs to fix
+ * @returns The name of the undo group created, or undefined if no fixes were applied
+ */
+function fixAllCapsIssues(layerIds: string[]) {
+  app.beginUndoGroup('fix all caps');
+
+  for (const layerId of layerIds) {
+    fixAllCapsIssue(layerId);
+  }
+
+  app.endUndoGroup();
+}
+
 function updateLayerTextDocument(layer: TextLayer, newValue: TextDocument) {
   const originalLayerName = layer.name;
   layer.sourceText.setValue(newValue);
   layer.name = originalLayerName; // Preserve original layer name
 }
 
-export { checkTextLayers, fixAllCapsIssue };
+export { validateTextLayers, fixAllCapsIssue, fixAllCapsIssues };

plainly-aescripts/src/validation/types.ts

@@ -25,7 +25,8 @@
     "lucide-react": "^0.544.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-hooks-global-state": "^2.1.0"
+    "react-hooks-global-state": "^2.1.0",
+    "semver": "^7.7.4"
   },
   "devDependencies": {
     "@babel/core": "^7.28.6",
@@ -42,6 +43,7 @@
     "@types/node": "^20.17.6",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
+    "@types/semver": "^7.7.1",
     "autoprefixer": "^10.4.20",
     "babel-jest": "^30.2.0",
     "babel-loader": "^9.2.1",