dazscript-framework 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dazscript-framework",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",

package/src/dialog/builders/list-view-builder.ts

@@ -461,9 +461,11 @@ const build = <TItem, TData>(context: ListViewBuilderContext<TItem, TData>): DzL
         })
     }
 
-    listView.contextMenuRequested.scriptConnect((item: DzListViewItem, pos: Point) => {
-        context.contextMenu?.(listView, item, pos).exec(pos.cursorPos(), 0)
-    })
+    if (context.contextMenu) {
+        listView.contextMenuRequested.scriptConnect((item: DzListViewItem, pos: Point) => {
+            context.contextMenu(listView, item, pos).exec(pos.cursorPos(), 0)
+        })
+    }
 
     return listView
 }

package/src/helpers/transform-bake-helper.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('./numeric-property-helper', () => ({ adjust: vi.fn() }))
+vi.mock('@dsf/core/global', () => ({
+    sceneHelper: {
+        getInternalName: vi.fn(),
+        getNode: vi.fn(),
+        getUniqueMorphName: vi.fn(),
+        setInternalName: vi.fn(),
+        setPropertyPath: vi.fn()
+    }
+}))
+
+const { adjust } = await import('./numeric-property-helper')
+const { bakeRotations, bakeScale, bakeTranslations, bakeTransforms, collectTransformBakePlan } = await import('./transform-bake-helper')
+
+type TestProperty = {
+    name: string
+    path: string
+    value: number
+    outputs: TestProperty[]
+    getName: () => string
+    getPath: () => string
+    getValue: () => number
+    getNumSlaveControllers: () => number
+    getSlaveController: (index: number) => { getOwner: () => TestProperty }
+    getNumControllers: () => number
+    getController: () => null
+    inherits: (type: string) => boolean
+}
+
+const property = (name: string, path = '/Pose Controls'): TestProperty => {
+    const testProperty: TestProperty = {
+        name,
+        path,
+        value: 7,
+        outputs: [],
+        getName: () => testProperty.name,
+        getPath: () => testProperty.path,
+        getValue: () => testProperty.value,
+        getNumSlaveControllers: () => testProperty.outputs.length,
+        getSlaveController: (index: number) => ({ getOwner: () => testProperty.outputs[index] }),
+        getNumControllers: () => 0,
+        getController: () => null,
+        inherits: (type: string) => type === 'DzNumericProperty' || type === 'DzFloatProperty'
+    }
+
+    return testProperty
+}
+
+const link = (driver: TestProperty, output: TestProperty): void => {
+    driver.outputs.push(output)
+}
+
+beforeEach(() => {
+    vi.clearAllMocks()
+})
+
+describe('transform bake helper', () => {
+    it('plans recursive output reset and selected rotation capture', () => {
+        const master = property('body_ctrl_rHandGrasp')
+        const middle = property('body_ctrl_rFingersGrasp')
+        const rotation = property('ZRotate', '/General/Transforms/Rotation')
+        const corrective = property('Value', '/Hidden/Base Correctives/Hands')
+        link(master, middle)
+        link(middle, rotation)
+        link(rotation, corrective)
+
+        const plan = collectTransformBakePlan(master, { rotations: true })
+
+        expect(plan.resetProperties).toEqual([master, middle, rotation, corrective])
+        expect(plan.capturedProperties).toEqual([rotation])
+    })
+
+    it('bakes selected transforms by capturing final values, zeroing chain, then restoring captures', () => {
+        const master = property('master')
+        const rotation = property('XRotate', '/General/Transforms/Rotation')
+        rotation.value = 45
+        link(master, rotation)
+
+        bakeTransforms(master, { rotations: true })
+
+        expect(adjust).toHaveBeenNthCalledWith(1, master, 0)
+        expect(adjust).toHaveBeenNthCalledWith(2, rotation, 0)
+        expect(adjust).toHaveBeenNthCalledWith(3, rotation, 45)
+    })
+
+    it('filters translations and scale independently', () => {
+        const master = property('master')
+        const translation = property('XTranslate', '/General/Transforms/Translation')
+        const rotation = property('XRotate', '/General/Transforms/Rotation')
+        const scale = property('XScale', '/General/Transforms/Scale')
+        link(master, translation)
+        link(master, rotation)
+        link(master, scale)
+
+        expect(collectTransformBakePlan(master, { translations: true }).capturedProperties).toEqual([translation])
+        expect(collectTransformBakePlan(master, { rotations: true }).capturedProperties).toEqual([rotation])
+        expect(collectTransformBakePlan(master, { scale: true }).capturedProperties).toEqual([scale])
+    })
+
+    it('exposes focused bake helpers', () => {
+        const master = property('master')
+        const translation = property('YTranslate', '/General/Transforms/Translation')
+        const rotation = property('YRotate', '/General/Transforms/Rotation')
+        const scale = property('YScale', '/General/Transforms/Scale')
+        link(master, translation)
+        link(master, rotation)
+        link(master, scale)
+
+        bakeRotations(master)
+        expect(adjust).toHaveBeenLastCalledWith(rotation, 7)
+
+        vi.clearAllMocks()
+        bakeTranslations(master)
+        expect(adjust).toHaveBeenLastCalledWith(translation, 7)
+
+        vi.clearAllMocks()
+        bakeScale(master)
+        expect(adjust).toHaveBeenLastCalledWith(scale, 7)
+    })
+})

package/src/helpers/transform-bake-helper.ts

@@ -0,0 +1,172 @@
+import { adjust } from './numeric-property-helper'
+import { getPropertyOutputs } from './property-helper'
+
+export type TransformBakeOptions = {
+    rotations?: boolean
+    translations?: boolean
+    scale?: boolean
+    maxDepth?: number
+}
+
+export type TransformBakePlan = {
+    resetProperties: DzProperty[]
+    capturedProperties: TransformBakeProperty[]
+}
+
+type TransformBakeProperty = DzFloatProperty | DzIntProperty | DzBoolProperty
+
+type CapturedPropertyValue = {
+    property: TransformBakeProperty
+    value: number
+}
+
+const DEFAULT_MAX_DEPTH = 10
+
+const hasProperty = (properties: DzProperty[], property: DzProperty): boolean => {
+    for (let index = 0; index < properties.length; index++) {
+        if (properties[index] === property) return true
+    }
+
+    return false
+}
+
+const isTransformBakeProperty = (property: DzProperty): property is TransformBakeProperty => {
+    return property.inherits('DzFloatProperty') || property.inherits('DzIntProperty') || property.inherits('DzBoolProperty')
+}
+
+const getPropertyName = (property: DzProperty): string => {
+    const getName = (property as any).getName
+    if (typeof getName === 'function') return String(getName.call(property))
+
+    return String((property as any).name ?? '')
+}
+
+const getPropertyPath = (property: DzProperty): string => {
+    const getPath = (property as any).getPath
+    if (typeof getPath === 'function') return String(getPath.call(property))
+
+    return ''
+}
+
+const isRotationProperty = (property: DzProperty): boolean => {
+    const name = getPropertyName(property)
+    return getPropertyPath(property) === '/General/Transforms/Rotation'
+        || name === 'XRotate'
+        || name === 'YRotate'
+        || name === 'ZRotate'
+}
+
+const isTranslationProperty = (property: DzProperty): boolean => {
+    const name = getPropertyName(property)
+    return getPropertyPath(property) === '/General/Transforms/Translation'
+        || name === 'XTranslate'
+        || name === 'YTranslate'
+        || name === 'ZTranslate'
+}
+
+const isScaleProperty = (property: DzProperty): boolean => {
+    const name = getPropertyName(property)
+    return getPropertyPath(property) === '/General/Transforms/Scale'
+        || name === 'Scale'
+        || name === 'XScale'
+        || name === 'YScale'
+        || name === 'ZScale'
+}
+
+const shouldCaptureProperty = (property: DzProperty, options: TransformBakeOptions): boolean => {
+    return (options.rotations === true && isRotationProperty(property))
+        || (options.translations === true && isTranslationProperty(property))
+        || (options.scale === true && isScaleProperty(property))
+}
+
+const collectRecursiveOutputProperties = (property: DzProperty, maxDepth: number): DzProperty[] => {
+    const outputs: DzProperty[] = []
+    const queue: DzProperty[] = [property]
+    const depths: number[] = [0]
+
+    for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+        const driver = queue[queueIndex]
+        const depth = depths[queueIndex]
+        if (depth >= maxDepth) continue
+
+        const relations = getPropertyOutputs(driver)
+        for (let relationIndex = 0; relationIndex < relations.length; relationIndex++) {
+            const output = relations[relationIndex].property
+            if (!output) continue
+            if (hasProperty(outputs, output)) continue
+
+            outputs.push(output)
+            if (!hasProperty(queue, output)) {
+                queue.push(output)
+                depths.push(depth + 1)
+            }
+        }
+    }
+
+    return outputs
+}
+
+export const collectTransformBakePlan = (property: DzProperty, options: TransformBakeOptions): TransformBakePlan => {
+    const outputs = collectRecursiveOutputProperties(property, options.maxDepth ?? DEFAULT_MAX_DEPTH)
+    const capturedProperties: TransformBakeProperty[] = []
+
+    for (let index = 0; index < outputs.length; index++) {
+        const output = outputs[index]
+        if (!isTransformBakeProperty(output)) continue
+        if (!shouldCaptureProperty(output, options)) continue
+
+        capturedProperties.push(output)
+    }
+
+    return {
+        resetProperties: [property].concat(outputs),
+        capturedProperties
+    }
+}
+
+const captureValues = (properties: TransformBakeProperty[]): CapturedPropertyValue[] => {
+    const values: CapturedPropertyValue[] = []
+
+    for (let index = 0; index < properties.length; index++) {
+        const property = properties[index]
+        values.push({ property, value: (property as any).getValue() })
+    }
+
+    return values
+}
+
+const resetProperties = (properties: DzProperty[]): void => {
+    for (let index = 0; index < properties.length; index++) {
+        const property = properties[index]
+        if (!isTransformBakeProperty(property)) continue
+
+        adjust(property, 0)
+    }
+}
+
+const restoreValues = (values: CapturedPropertyValue[]): void => {
+    for (let index = 0; index < values.length; index++) {
+        const captured = values[index]
+        adjust(captured.property, captured.value)
+    }
+}
+
+export const bakeTransforms = (property: DzProperty, options: TransformBakeOptions): void => {
+    const plan = collectTransformBakePlan(property, options)
+    const capturedValues = captureValues(plan.capturedProperties)
+
+    resetProperties(plan.resetProperties)
+    restoreValues(capturedValues)
+}
+
+export const bakeRotations = (property: DzProperty): void => {
+    bakeTransforms(property, { rotations: true })
+}
+
+export const bakeTranslations = (property: DzProperty): void => {
+    bakeTransforms(property, { translations: true })
+}
+
+export const bakeScale = (property: DzProperty): void => {
+    bakeTransforms(property, { scale: true })
+}