dazscript-framework 0.1.0

package/helpers/node-helper.ts

@@ -0,0 +1,216 @@
+import { app, sceneHelper } from '@dsf/lib/global';
+import { TreeNode } from 'shared/models/tree-node';
+import { group } from './array-helper';
+import { entries } from './record-helper';
+
+export const isBone = (node: DzNode): boolean => {
+    return node.iskindof('DzBone')
+}
+
+export const isFigure = (node: DzNode): boolean => {
+    return node.iskindof('DzSkeleton')
+}
+
+/**
+ * Returns the root of a node
+ * @param node
+ * @returns The root of the node, if the node is part of a figure, return the figure (skeleton) otherwise return the node itself
+ */
+export const getRoot = (node: DzNode): DzNode => {
+    if (node && node.className() === "DzBone" && node.getSkeleton)
+        return node.getSkeleton();
+    else
+        return node;
+}
+
+export const getFigure = (node: DzNode): DzSkeleton | null => {
+    return node.getSkeleton?.() ?? null
+}
+
+/**
+ * Find a property by the given name or internal name
+ * @param node the node to search on
+ * @param name the name or internal name of the property
+ * @returns The first property with the given name or internal name, or NULL.
+ */
+export const findProperty = <T extends DzProperty = DzProperty>(node: DzNode, name: string): T | null => {
+    return sceneHelper.findPropertyOnNode(name, node) as T
+        ?? sceneHelper.findPropertyOnNodeByInternalName(name, node) as T
+}
+
+/**
+ * Get all properties associated with the node.
+ * @param node The node to get the properties from.
+ * @param includeModifiers Whether or not to include the properties of DzModifiers.
+ * @returns All properties associated with the node.
+ */
+export const getProperties = (node: DzNode, includeModifiers: boolean = false): DzProperty[] => {
+    return sceneHelper.getPropertiesOnNode(node, includeModifiers)
+}
+
+export const getChildren = (node: DzNode, recursive: boolean, includeParented?: boolean, includeFittedTo?: boolean) => {
+    return node.getNodeChildren(recursive ?? false).filter(n =>
+        includeParented || isBodyPartOf(n, node.getSkeleton())
+        && (includeFittedTo || !isFitting(getFigure(n), node)))
+}
+
+/**
+ * Returns true if the specified node is a body part of a figure
+ * @param node
+ * @param figure
+ * @returns
+ */
+export const isBodyPartOf = (node: DzNode, figure: DzSkeleton): boolean => {
+    return isBone(node) && isChildOf(node, figure) && node.getSkeleton()?.getLabel() == figure.getSkeleton()?.getLabel()
+}
+
+/**
+ * Returns true if the specified node is parented or a body part of a figure
+ * @param node
+ * @param figure
+ * @returns
+ */
+export const isChildOf = (node: DzNode, figure: DzNode): boolean => {
+    return node.isNodeDescendantOf(figure, true)
+}
+
+/**
+ * Get the fitting target of the node
+ * @param node
+ * @returns the fitting target (skeleton) of the node or null
+ */
+export const getFittingTarget = (node: DzNode): DzSkeleton | null => {
+    return getRoot(node).getSkeleton()?.getFollowTarget()
+}
+
+/**
+* Returns true if the node is fitted to another node (eg: it's a clothing item)
+* @param figure
+* @param target if specified, check if the node is fitted to the target node, otherwise check if the node is fitted to any other node
+* @returns true if the node is fitted to another node
+*/
+export const isFitting = (figure: DzSkeleton, target?: DzNode): boolean => {
+    return target
+        ? figure?.getFollowTarget() == target
+        : figure?.getFollowTarget() != null
+}
+
+export const isClothingType = (node: DzNode): boolean => {
+    if (!isFigure(node)) return false
+    const figure = getFigure(node)!
+    const assetMgr = app.getAssetMgr()
+    const type = assetMgr.getTypeForNode(figure)
+    return assetMgr.isClothingType(type) || type === 'Follower'
+}
+
+export const isHairType = (node: DzNode): boolean => {
+    if (!isFigure(node)) return false
+    const figure = getFigure(node)!
+    const assetMgr = app.getAssetMgr()
+    const type = assetMgr.getTypeForNode(figure)
+    return assetMgr.isHairType(type)
+}
+
+export const isGeoShell = (node: DzNode): boolean => {
+    return node.inherits('DzGeometryShellNode')
+}
+
+export const getTransforms = (node: DzNode, include: { rotations?: boolean, translations?: boolean, scale?: boolean }) => {
+    let transforms: DzFloatProperty[] = []
+
+    if (include.rotations === true) transforms = getRotations(node)
+    if (include.translations === true) transforms = transforms.concat(getTranslations(node))
+    if (include.scale === true) transforms = transforms.concat(getScales(node))
+
+    return transforms
+}
+
+export const getRotations = (node: DzNode): DzFloatProperty[] => {
+    if (!node) return [];
+
+    const xRotate = sceneHelper.findPropertyOnNode('XRotate', node) as DzFloatProperty
+    const yRotate = sceneHelper.findPropertyOnNode('YRotate', node) as DzFloatProperty
+    const zRotate = sceneHelper.findPropertyOnNode('ZRotate', node) as DzFloatProperty
+
+    return [xRotate, yRotate, zRotate];
+}
+
+export const getTranslations = (node: DzNode): DzFloatProperty[] => {
+    return !node ? [] : [node.getXPosControl(), node.getYPosControl(), node.getZPosControl()];
+}
+
+export const getScales = (node: DzNode): DzFloatProperty[] => {
+    return [node.getXScaleControl(), node.getYScaleControl(), node.getZScaleControl(), node.getScaleControl()];
+}
+
+export const getPropertiesTree = <T = DzProperty>(node: DzNode, map?: (property: DzProperty) => T, filter?: (property: DzProperty) => boolean): TreeNode<T>[] => {
+    let items = entries(group(sceneHelper.getPropertiesOnNode(node), (p) => p.getPath())).map(x => ({ path: x[0], properties: x[1] }))
+
+    const root = new TreeNode<T>('root', '')
+    const pathMap: { [key: string]: TreeNode<T> } = { '': root }
+
+    items.forEach(element => {
+        const paths = element.path.split('/')
+        let currentPath = ''
+
+        paths.forEach((path, index) => {
+            currentPath += `${index === 0 ? '' : '/'}${path}`
+            if (!pathMap[currentPath]) {
+                const newNode = new TreeNode<T>(path, currentPath)
+                pathMap[currentPath] = newNode
+
+                if (index !== 0) {
+                    const parentPath = currentPath.substring(0, currentPath.lastIndexOf('/'))
+                    const parentNode = pathMap[parentPath]
+                    parentNode?.addChild(newNode)
+                    newNode.parent = parentNode
+                }
+            }
+        })
+
+        element.properties.forEach(property => {
+            const currentNode = pathMap[property.getPath()]
+            const newNode = new TreeNode<T>(
+                property.getLabel(),
+                property.getPath(),
+                map?.(property) ?? property as T
+            )
+
+            currentNode?.addChild(newNode)
+            newNode.parent = currentNode
+        })
+    })
+
+    const rootChildren = pathMap[''].children
+    return rootChildren && rootChildren.length > 0 ? rootChildren : root.children
+}
+
+export const getPropertiesPathsTree = (node: DzNode): TreeNode<string>[] => {
+    let items = entries(group(sceneHelper.getPropertiesOnNode(node), (p) => p.getPath())).map(x => ({ path: x[0], properties: x[1] }))
+
+    const root = new TreeNode<string>('root', '')
+    const pathMap: { [key: string]: TreeNode<string> } = { '': root }
+
+    items.forEach(element => {
+        const paths = element.path.split('/')
+        let currentPath = ''
+
+        paths.forEach((path, index) => {
+            currentPath += `${index === 0 ? '' : '/'}${path}`
+            if (!pathMap[currentPath]) {
+                const newNode = new TreeNode<string>(path, currentPath)
+                pathMap[currentPath] = newNode
+
+                if (index !== 0) {
+                    const parentPath = currentPath.substring(0, currentPath.lastIndexOf('/'))
+                    const parentNode = pathMap[parentPath]
+                    parentNode?.addChild(newNode)
+                    newNode.parent = parentNode
+                }
+            }
+        })
+    })
+
+    const rootChildren = pathMap[''].children
+    return rootChildren && rootChildren.length > 0 ? rootChildren : root.children
+}

package/helpers/number-helper.ts

@@ -0,0 +1,11 @@
+export const tryParse = (input: string): { valid: boolean, value: number } => {
+    const parsedValue = Number(input);
+    if (isNaN(parsedValue)) {
+        return { valid: false, value: 0 }
+    }
+    return { valid: true, value: parsedValue }
+}
+
+export const clamp = (value: number, min: number, max: number): number => {
+    return Math.min(Math.max(value, min), max);
+}

package/helpers/numeric-property-helper.ts

@@ -0,0 +1,92 @@
+import { scene } from '@dsf/lib/global';
+import { PropertyKey, PropertyKeys } from '@dsf/models/frame-keys';
+import { isNumeric, toFloat } from './property-helper';
+import { timeToFrame } from './scene-helper';
+
+/**
+ * Adjust the value of the property based on the contribution of property controllers.
+ * @param property the property to adjust
+ * @param value the 'final' value desired for the property
+ * @param time the animation time to adjust the property at or current time if not specified
+ * @param interpolation the animation interpolation of DzProperty
+ * @deprecated use adjust instead
+ */
+export const adjustFn = (property: DzFloatProperty | DzIntProperty, value: number, interpolation?: number, time?: DzTime) => {
+    return () => {
+        interpolation = interpolation ?? DzProperty.InterpConstant
+        time = time ?? scene.getTime()
+        property.setValue(time, property.adjustValue(time, value), interpolation)
+    };
+}
+
+/**
+ * Adjust the value of the property based on the contribution of property controllers.
+ * @param property the property to adjust
+ * @param value the 'final' value desired for the property
+ * @param time the animation time to adjust the property at or current time if not specified
+ * @param interpolation the animation interpolation of DzProperty
+ */
+export const adjust = (property: DzFloatProperty | DzIntProperty, value: number, interpolation?: number, time?: DzTime) => {
+    interpolation = interpolation ?? DzProperty.InterpConstant
+    time = time ?? scene.getTime()
+
+    adjustFn(property, value, interpolation, time)()
+}
+
+export const nudge = (property: DzFloatProperty | DzIntProperty, value: number, interpolation?: number, time?: DzTime) => {
+    interpolation = interpolation ?? DzProperty.InterpConstant
+    time = time ?? scene.getTime()
+
+    const sensitivity = property.getSensitivity()
+    adjust(property, property.getValue() + value * sensitivity, interpolation, time)
+    //property.setValue(time, property.getValue() + value * sensitivity, interpolation)
+}
+
+export const clamp = (property: DzFloatProperty | DzIntProperty, interpolation?: number, time?: DzTime) => {
+    interpolation = interpolation ?? DzProperty.InterpConstant
+    time = time ?? scene.getTime()
+
+    property.setIsClamped(true)
+
+    if (property.getRawValue() > property.getMax()) {
+        property.setValue(time, property.getMax(), interpolation)
+    }
+    else if (property.getRawValue() < property.getMin()) {
+        property.setValue(time, property.getMin(), interpolation)
+    }
+
+}
+
+export const setInterpolation = (property: DzProperty, keyIndex: number, interpolationType: number) => {
+    toFloat(property)?.setKeyInterpolation(keyIndex, interpolationType)
+}
+
+/**
+ * Gets a collection of numeric property keys
+ * @param property the property to get the keys from
+ * @returns an array of keys
+ */
+export const getKeys = (property: DzNumericProperty): PropertyKeys => {
+    if (!isNumeric(property)) throw Error(`The property "${property.getLabel()}" is not numeric`)
+
+    const keys: PropertyKey[] = []
+
+    for (let i = 0; i < property.getNumKeys(); i++) {
+        const key = new PropertyKey()
+        key.index = i
+        key.time = property.getKeyTime(i)
+        key.value = property.getDoubleValue(key.time)
+        key.frame = timeToFrame(key.time)
+        keys.push(key)
+    }
+
+    const keyCollection = new PropertyKeys(keys);
+
+    // This would make frame the index, but it would not be zero based and
+    // could lead to trouble
+    // keys.forEach((key) => {
+    //     keyCollection[key.frame] = key
+    // })
+
+    return keyCollection
+}

package/helpers/object-helper.ts

@@ -0,0 +1,3 @@
+export const keys = (o: {}): string[] => {
+    return Object.keys(o)
+}

package/helpers/pane-helper.ts

@@ -0,0 +1,21 @@
+import { mainWindow } from '@dsf/lib/global'
+
+const findPane = <T extends DzPane>(className: string): T => {
+    return mainWindow.getPaneMgr().findPane(className) as T
+}
+
+export const getSmartContentPane = (): DzSmartContentPane => {
+    return <DzSmartContentPane>findPane("DzSmartContentPane")
+}
+
+export const getSurfacesPane = (): DzSurfacesPane => {
+    return findPane<DzSurfacesPane>("DzSurfacesPane")
+}
+
+export const getAuxViewPort = (): DzAuxViewportPane => {
+    return findPane<DzAuxViewportPane>("DzAuxViewportPane")
+}
+
+export const getParametersPane = (): DzParametersPane => {
+    return findPane<DzParametersPane>("DzParametersPane")
+}

package/helpers/progress-helper.ts

@@ -0,0 +1,34 @@
+/**
+ * Displays a progress dialog to the user if one is not already being displayed and starts a progress tracking operation.
+ * @param info The string to display in the progress dialog as the current description of the operation.
+ * @param items The items to process
+ * @param callback The function to run for every item
+ * @param isCancellable  If true, the user is given the option to cancel the operation.
+ * @param showTimeElapsed If true, the amount of time since the progress operation was started will be displayed in the dialog.
+ * @param totalSteps The number of progress steps for the operation to be complete.
+ */
+export const progress = <T>(info: string, items: T[], callback: (item: T) => boolean | void, isCancellable: boolean = true, showTimeElapsed: boolean = true, totalSteps?: number) => {
+    totalSteps = totalSteps ?? items.length;
+
+    startProgress(info, totalSteps, isCancellable, showTimeElapsed);
+
+    for (let item of items) {
+        if (isCancellable) {
+            if (progressIsCancelled()) {
+                break;
+            } else {
+                // This is too slow
+                //if(progress) processEvents();
+            }
+        }
+
+        //============
+        if (callback && callback(item) === false)
+            return
+        //============
+
+        stepProgress(1);
+    }
+
+    finishProgress();
+}

package/helpers/property-helper.ts

@@ -0,0 +1,53 @@
+import { sceneHelper } from '@dsf/lib/global'
+
+/**
+ * Sets the DzPropertyGroup path (and appropriate geometryregion_dz) for the given property.
+ * @param property  The property to change the path of.
+ * @param path The new path for the given property.
+ */
+export const setPath = (property: DzProperty, path: string) => {
+    sceneHelper.setPropertyPath(property, path)
+}
+
+/**
+ * Get the internal name of property (or its alias target), or “Unknown”.
+ * @param property
+ * @returns The internal name of property (or its alias target), or “Unknown”.
+ */
+export const getName = (property: DzProperty): string => {
+    return sceneHelper.getInternalName(property)
+}
+
+/**
+ * Unlocks a property temporarily and executes the specified callback while it's unlocked
+ * @param property the property to unlock
+ * @param then the callback to exectue while the property is unlocked
+ */
+export const unlock = (property: DzProperty, then: (property: DzProperty) => void) => {
+    let locked = property.isLocked()
+    if (locked) property.lock(true)
+    then(property)
+    if (locked) property.lock(false)
+}
+
+export const isNumeric = (property: DzProperty): boolean => {
+    return property.inherits('DzNumericProperty')
+}
+
+export const cast = <T extends DzProperty>(property: DzProperty, type: 'DzNumericProperty' | 'DzFloatProperty' | 'DzIntProperty'): T | null => {
+    return property.inherits(type)
+        ? property as T
+        : null
+}
+
+export const toNumeric = (property: DzProperty): DzFloatProperty | DzIntProperty | null => {
+    return toFloat(property) ?? toInt(property)
+}
+
+export const toFloat = (property: DzProperty): DzFloatProperty | null => {
+    return cast<DzFloatProperty>(property, 'DzFloatProperty')
+}
+
+export const toInt = (property: DzProperty): DzIntProperty | null => {
+    return cast<DzIntProperty>(property, 'DzIntProperty')
+}

package/helpers/record-helper.ts

@@ -0,0 +1,16 @@
+function objectEntries(obj: any) {
+    const ownProps = Object.keys(obj);
+    let i = ownProps.length;
+    const result = new Array(i); // preallocate the Array
+    while (i--) {
+        result[i] = [ownProps[i], obj[ownProps[i]]];
+    }
+    return result;
+};
+
+export function entries<K extends string, T>(
+    record: Record<K, T[]>
+): Array<[K, T[]]> {
+    return (objectEntries(record) as Array<[K, T[]]>);
+}
+

package/helpers/scene-helper.ts

@@ -0,0 +1,96 @@
+import { scene } from '@dsf/lib/global'
+import { contains, distinct } from './array-helper'
+import { getRoot } from './node-helper'
+import { getParametersPane } from './pane-helper'
+
+export const getSelectedOf = <T>(typeName: string): DzNode[] => {
+    let nodes = []
+    for (let node of scene.getSelectedNodeList()) {
+        if (!node.inherits(typeName)) continue
+        nodes.push(node)
+    }
+    return nodes
+}
+
+export const getSelectedNode = (): DzNode | null => {
+    if (scene.getNumSelectedNodes() === 0) return null
+    return scene.getPrimarySelection()
+}
+
+export const getTopParent = (node: DzNode): DzNode => {
+    var parent = node.getNodeParent();
+    return parent ? getTopParent(parent) : node;
+}
+
+export const getNodes = (): DzNode[] => {
+    return scene.getNodeList()
+}
+
+export const getFigures = (): DzSkeleton[] => {
+    return distinct(getNodes().map(n => n.getSkeleton?.()), (n => n?.getLabel().valueOf())).filter(n => n !== null)
+}
+
+/**
+ * Get the selected figure
+ * @returns the figure skeleton, or null if there is no current selection or the selected node is not part of a figure
+ */
+export const getSelectedFigure = (): DzSkeleton | null => {
+    return getSelectedNode()?.getSkeleton?.()
+}
+
+/**
+ * Given the selected nodes in the scene, return the figures they are part of
+ * @returns the selected figures
+ */
+export const getSelectedFigures = (callback: (figure: DzSkeleton) => void | boolean = () => true): DzSkeleton[] => {
+    let nodes: DzSkeleton[] = []
+    for (let node of scene.getSelectedNodeList()) {
+        let skeleton = node.getSkeleton?.()
+        if (!skeleton || contains(nodes, node)) continue
+        nodes.push(skeleton)
+        if (!!callback?.(skeleton)) break
+    }
+    return nodes
+}
+
+export const getSelectedNodes = (): DzNode[] => {
+    return scene.getSelectedNodeList()
+}
+
+export const getSelectedRoot = (): DzNode => {
+    return getRoot(getSelectedNode())
+}
+
+export const getSelectedRoots = (): DzNode[] => {
+    return distinct(getSelectedNodes().map(n => getRoot(n)))
+}
+
+export const getSelectedProperties = (): DzProperty[] => {
+    return getParametersPane()?.getNodeEditor()?.getPropertySelections(true) ?? []
+}
+
+export const getSelectedPropertiesOfType = <TProperty extends DzProperty>(type: string): TProperty[] => {
+    return getSelectedProperties().filter(p => p.inherits(type)) as TProperty[]
+}
+
+export const clearSelection = () => {
+    for (let node of scene.getSelectedNodeList()) {
+        node.select(false)
+    }
+}
+
+export const currentTime = (): DzTime => {
+    return scene.getTime()
+}
+
+export const getCurrentFrame = (): number => {
+    return scene.getTime().valueOf() / scene.getTimeStep().valueOf()
+}
+
+export const getLastFrame = (): number => {
+    return scene.getAnimRange().end / scene.getTimeStep().valueOf()
+}
+
+export const timeToFrame = (time: DzTime): number => {
+    return time.valueOf() / scene.getTimeStep().valueOf()
+}

package/helpers/script-helper.ts

@@ -0,0 +1,16 @@
+export const getScriptPath = (): string => {
+    var fileName = getScriptFileName();
+    var fileInfo = new DzFileInfo(fileName);
+
+    let path: string;
+
+    if (typeof (fileInfo.canonicalPath) == "function") {
+        path = fileInfo.canonicalPath();
+    } else {
+        path = fileInfo.path();
+    }
+
+    fileInfo.deleteLater();
+
+    return path;
+}

package/helpers/skeleton-helper.ts

@@ -0,0 +1,27 @@
+
+export const getModifiers = (figure: DzSkeleton): DzModifier[] => {
+    let modifiers: DzModifier[] = []
+    let obj = figure.getObject()
+
+    for (let i = 0; i < obj.getNumModifiers(); i++) {
+        modifiers.push(obj.getModifier(i))
+    }
+
+    return modifiers
+}
+
+export const getMirrorNodes = (figure: DzSkeleton, nodes: DzNode[]): DzNode[] => {
+    let mirrorNodes: DzNode[] = []
+
+    nodes.forEach((node) => {
+        const name = node.getName().valueOf()
+        let prefix = name[0]
+        if (prefix !== 'r' && prefix !== 'l') return
+        prefix = prefix === 'r' ? 'l' : 'r'
+        const mirrorName = `${prefix}${name.substring(1)}`
+        const mirrorNode = figure.findNodeChild(mirrorName, true)
+        if (mirrorNode) mirrorNodes.push(mirrorNode)
+    })
+
+    return mirrorNodes
+}

package/helpers/splitter-helper.ts

@@ -0,0 +1,9 @@
+export const restoreState = (splitter: DzSplitter, state: string) => {
+    if (!state) return
+    let base64Array = new ByteArray(state)
+    splitter.restoreState(base64Array.fromBase64(base64Array))
+}
+
+export const getState = (splitter: DzSplitter): string => {
+    return splitter.saveState().toBase64().convertToString()
+}

package/helpers/string-helper.ts

@@ -0,0 +1,28 @@
+export const isNumeric = (value: string | number): boolean => {
+    return ((value != null) &&
+        (value !== '') &&
+        !isNaN(Number(value.toString())))
+}
+
+export const contains = (source: string, search: string | string[]): boolean => {
+    if (Array.isArray(search)) {
+        for (const s of search) {
+            if (source.indexOf(s) >= 0) return true
+        }
+        return false
+    }
+    return source.indexOf(search) >= 0
+}
+
+export const remove = (source: string, search: string): string => {
+    return source.replace(search, "")
+}
+
+export const count = (source: string, search: string): number => {
+    return source.split(search).length - 1
+}
+
+export const isGUID = (str: string): boolean => {
+    const GUIDPattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+    return GUIDPattern.test(str);
+}

package/helpers/surface-helper.ts

@@ -0,0 +1,6 @@
+import { getSurfacesPane } from './pane-helper'
+
+export const getSelectedSurfacePropertiesOfType = <TProperty extends DzProperty>(className: string): TProperty[] => {
+    return getSurfacesPane().getNodeEditor().getPropertySelections(true)
+        .filter(p => p.inherits(className)) as TProperty[]
+}

package/helpers/undo-helper.ts

@@ -0,0 +1,7 @@
+const acceptUndoFor = (caption: string, callback: () => void) => {
+    beginUndo()
+    callback?.()
+    acceptUndo(caption)
+}
+
+export { acceptUndoFor as acceptUndo }

package/helpers/viewport-helper.ts

@@ -0,0 +1,9 @@
+import { mainWindow } from '@dsf/lib/global'
+
+export const selectUniversalRotateTool = (coordinateSpace?: number): DzUniversalRotateTool => {
+    const viewportMgr = mainWindow.getViewportMgr()
+    const tool = viewportMgr.findTool('DzUniversalRotateTool') as DzUniversalRotateTool
+    viewportMgr.setActiveTool(tool)
+    if (coordinateSpace) tool.setCoordinateSpace(coordinateSpace)
+    return tool
+}