dazscript-framework 1.0.34 → 1.0.36

package/package.json

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

package/src/helpers/figure-helper.ts

@@ -0,0 +1,23 @@
+export const resolveFigureNode = (node: DzNode | null): DzSkeleton | null => {
+    if (!node) return null
+    if (node.inherits('DzSkeleton')) return node as DzSkeleton
+    return node.getSkeleton?.() ?? null
+}
+
+export const getFigureResolutionLevel = (figure: DzNode): number | null => {
+    const property = getFigureResolutionProperty(figure)
+    return property ? property.getValue() : null
+}
+
+export const setFigureResolutionLevel = (figure: DzNode, resolution: number): boolean => {
+    const property = getFigureResolutionProperty(figure)
+    if (!property) return false
+
+    property.setValue(resolution)
+    return true
+}
+
+const getFigureResolutionProperty = (figure: DzNode): DzEnumProperty | null => {
+    const shape = figure.getObject()?.getCurrentShape()
+    return shape?.findProperty('lodlevel') as DzEnumProperty | null
+}

package/src/helpers/material-helper.ts

@@ -0,0 +1,43 @@
+export type SimpleMaterialOptions = {
+    color: Color
+    opacity: number
+    name?: string
+}
+
+export const applySingleMaterial = (node: DzNode, options: SimpleMaterialOptions): boolean => {
+    const shape = node.getObject()?.getCurrentShape()
+    if (!shape) return false
+
+    if (shape.getNumMaterials() < 1) {
+        shape.createMaterial(options.name ?? 'Material')
+    }
+
+    let applied = false
+    for (let i = 0; i < shape.getNumMaterials(); i++) {
+        const material = shape.getMaterial(i)
+        if (!material) continue
+        applyMaterialValues(material, options)
+        applied = true
+    }
+
+    return applied
+}
+
+const applyMaterialValues = (material: DzMaterial, options: SimpleMaterialOptions): void => {
+    const anyMaterial = material as any
+    if (options.name && typeof anyMaterial.setName === 'function') {
+        anyMaterial.setName(options.name)
+    }
+
+    material.setDiffuseColor(options.color)
+    material.setBaseOpacity(clampOpacity(options.opacity))
+
+    if (typeof anyMaterial.setOpacity === 'function') {
+        anyMaterial.setOpacity(clampOpacity(options.opacity))
+    }
+}
+
+const clampOpacity = (opacity: number): number => {
+    if (!isFinite(opacity) || isNaN(opacity)) return 0.25
+    return Math.max(0, Math.min(1, opacity))
+}

package/src/helpers/obj-file-helper.ts

@@ -0,0 +1,112 @@
+export type SilentObjExportOptions = {
+    selectedOnly?: boolean
+    selectedRootsOnly?: boolean
+    includeParented?: boolean
+    writeUvs?: boolean
+    writeNormals?: boolean
+    writeObjects?: boolean
+    writeGroups?: boolean
+    writeMaterials?: boolean
+    writeMaterialLibrary?: boolean
+    groupByGeometry?: boolean
+    groupByNodes?: boolean
+    groupBySurfaces?: boolean
+}
+
+export type ObjFileResult = {
+    ok: boolean
+    path: string
+    result: string
+}
+
+export const createSilentObjExportSettings = (options: SilentObjExportOptions = {}): DzFileIOSettings => {
+    const settings = createObjAxisSettings()
+    settings.setBoolValue('IgnoreInvisible', false)
+    settings.setBoolValue('WeldSeams', false)
+    settings.setBoolValue('RemoveUnusedVerts', false)
+    settings.setBoolValue('WriteVT', options.writeUvs ?? true)
+    settings.setBoolValue('WriteVN', options.writeNormals ?? false)
+    settings.setBoolValue('WriteO', options.writeObjects ?? true)
+    settings.setBoolValue('WriteG', options.writeGroups ?? true)
+    settings.setBoolValue('GroupGeom', options.groupByGeometry ?? true)
+    settings.setBoolValue('GroupNodes', options.groupByNodes ?? false)
+    settings.setBoolValue('GroupSurfaces', options.groupBySurfaces ?? true)
+    settings.setBoolValue('GroupSingle', false)
+    settings.setBoolValue('WriteUsemtl', options.writeMaterials ?? true)
+    settings.setBoolValue('WriteMtllib', options.writeMaterialLibrary ?? false)
+    settings.setBoolValue('CollectMaps', false)
+    settings.setBoolValue('ConvertMaps', false)
+    settings.setBoolValue('SelectedOnly', options.selectedOnly ?? true)
+    settings.setBoolValue('SelectedRootsOnly', options.selectedRootsOnly ?? true)
+    settings.setBoolValue('PrimaryRootOnly', false)
+    settings.setBoolValue('IncludeParented', options.includeParented ?? false)
+    settings.setBoolValue('TriangulateNgons', false)
+    settings.setBoolValue('CollapseUVTiles', false)
+    settings.setBoolValue('ShowIndividualSettings', true)
+    settings.setIntValue('FloatPrecision', 6)
+    settings.setIntValue('RunSilent', 1)
+    return settings
+}
+
+export const createMinimalSilentObjExportSettings = (): DzFileIOSettings =>
+    createSilentObjExportSettings({
+        writeUvs: false,
+        writeNormals: false,
+        writeObjects: false,
+        writeGroups: false,
+        writeMaterials: false,
+        writeMaterialLibrary: false,
+        groupByGeometry: false,
+        groupByNodes: false,
+        groupBySurfaces: false,
+        selectedOnly: true,
+        selectedRootsOnly: true,
+        includeParented: false
+    })
+
+export const createSilentObjImportSettings = (): DzFileIOSettings => {
+    const settings = createObjAxisSettings()
+    settings.setBoolValue('IncludeVT', false)
+    settings.setBoolValue('IncludeG', false)
+    settings.setBoolValue('IncludeUsemtl', false)
+    settings.setBoolValue('IncludeMtllib', false)
+    settings.setBoolValue('ShowIndividualSettings', true)
+    settings.setIntValue('RunSilent', 1)
+    return settings
+}
+
+export const exportObjSilent = (path: string, settings: DzFileIOSettings = createMinimalSilentObjExportSettings()): ObjFileResult => {
+    const exporter = (App.getExportMgr() as any).findExporterByClassName('DzObjExporter')
+    if (!exporter) return { ok: false, path, result: 'DzObjExporter not found' }
+
+    try {
+        const result = exporter.writeFile(path, settings)
+        return { ok: true, path, result: String(result) }
+    } finally {
+        exporter.deleteLater?.()
+    }
+}
+
+export const importObjSilent = (path: string, settings: DzFileIOSettings = createSilentObjImportSettings()): ObjFileResult => {
+    const importer = (App.getImportMgr() as any).findImporterByClassName('DzObjImporter')
+    if (!importer) return { ok: false, path, result: 'DzObjImporter not found' }
+
+    try {
+        const result = importer.readFile(path, settings)
+        return { ok: true, path, result: String(result) }
+    } finally {
+        importer.deleteLater?.()
+    }
+}
+
+const createObjAxisSettings = (): DzFileIOSettings => {
+    const settings = new DzFileIOSettings()
+    settings.setFloatValue('Scale', 243.84)
+    settings.setStringValue('LatAxis', 'X')
+    settings.setStringValue('VertAxis', 'Y')
+    settings.setStringValue('DepthAxis', 'Z')
+    settings.setBoolValue('InvertLat', false)
+    settings.setBoolValue('InvertVert', false)
+    settings.setBoolValue('InvertDepth', false)
+    return settings
+}

package/src/helpers/primitive-helper.ts

@@ -0,0 +1,67 @@
+export type PrimitiveKind = 'Sphere' | 'Cube' | 'Cone' | 'Plane' | 'Torus' | 'Cylinder'
+
+export type CreatePrimitiveOptions = {
+    kind: PrimitiveKind
+    name?: string
+    label?: string
+    size?: number
+}
+
+export type CreatePrimitiveResult = {
+    ok: boolean
+    node: DzNode | null
+    message: string
+}
+
+declare const Geometry: DzGeometryUtil | undefined
+
+export const createPrimitive = (options: CreatePrimitiveOptions): CreatePrimitiveResult => {
+    const geometryUtil = getGeometryUtil()
+    if (!geometryUtil) {
+        return { ok: false, node: null, message: 'Global Geometry utility is not available' }
+    }
+
+    const primitiveType = getPrimitiveType(geometryUtil, options.kind)
+    if (primitiveType === null) {
+        return { ok: false, node: null, message: `Unsupported primitive kind: ${options.kind}` }
+    }
+
+    const settings = new DzSettings()
+    geometryUtil.getDefaultPrimitiveOptions(primitiveType, settings)
+
+    if (typeof options.size === 'number' && isFinite(options.size) && options.size > 0) {
+        settings.setFloatValue('size', options.size)
+    }
+
+    const node = geometryUtil.createPrimitive(settings)
+    if (!node) {
+        return { ok: false, node: null, message: `DzGeometryUtil did not create a ${options.kind}` }
+    }
+
+    if (options.name) node.setName(options.name)
+    if (options.label) node.setLabel(options.label)
+    if (!isNodeInScene(node)) Scene.addNode(node)
+
+    return { ok: true, node, message: '' }
+}
+
+const getGeometryUtil = (): DzGeometryUtil | null =>
+    typeof Geometry !== 'undefined' ? Geometry : null
+
+const getPrimitiveType = (geometryUtil: DzGeometryUtil, kind: PrimitiveKind): number | null => {
+    const primitiveTypes = geometryUtil as any
+    if (kind === 'Sphere') return primitiveTypes.Sphere
+    if (kind === 'Cube') return primitiveTypes.Cube
+    if (kind === 'Cone') return primitiveTypes.Cone
+    if (kind === 'Plane') return primitiveTypes.Plane
+    if (kind === 'Torus') return primitiveTypes.Torus
+    if (kind === 'Cylinder') return primitiveTypes.Cylinder
+    return null
+}
+
+const isNodeInScene = (node: DzNode): boolean => {
+    for (let i = 0; i < Scene.getNumNodes(); i++) {
+        if (Scene.getNode(i) === node) return true
+    }
+    return false
+}

package/src/helpers/scene-helper.ts

@@ -2,6 +2,7 @@ import { scene } from '@dsf/core/global'
 import { contains, distinct, group } from './array-helper'
 import { getRoot, isFigure } from './node-helper'
 import { getPaneNodeEditor, getParametersPane, getParametersPaneNodeEditor } from './pane-helper'
+import { startsWith } from './string-helper'
 
 export const getSelectedOf = <T>(typeName: string): DzNode[] => {
     let nodes: DzNode[] = []
@@ -143,3 +144,37 @@ export const timeToFrame = (time: DzTime): number => {
 export const frameToTime = (frame: number): DzTime => {
     return new DzTime(scene.getTimeStep().valueOf() * frame)
 }
+
+export const collectSceneNodeIds = (): number[] => {
+    const ids: number[] = []
+    for (let i = 0; i < Scene.getNumNodes(); i++) {
+        ids.push(Scene.getNode(i).elementID)
+    }
+    return ids
+}
+
+export const getNodesAddedAfter = (beforeIds: number[]): DzNode[] => {
+    const nodes: DzNode[] = []
+    for (let i = 0; i < Scene.getNumNodes(); i++) {
+        const node = Scene.getNode(i)
+        if (beforeIds.indexOf(node.elementID) < 0) nodes.push(node)
+    }
+    return nodes
+}
+
+export const removeNodesByNameOrLabelPrefix = (prefix: string): number => {
+    const nodes: DzNode[] = []
+
+    for (let i = 0; i < Scene.getNumNodes(); i++) {
+        const node = Scene.getNode(i)
+        if (startsWith(String(node.getName()), prefix) || startsWith(String(node.getLabel()), prefix)) {
+            nodes.push(node)
+        }
+    }
+
+    for (let i = 0; i < nodes.length; i++) {
+        Scene.removeNode(nodes[i])
+    }
+
+    return nodes.length
+}

package/src/helpers/scene-node-helper.ts

@@ -0,0 +1 @@
+export { collectSceneNodeIds, getNodesAddedAfter, removeNodesByNameOrLabelPrefix } from './scene-helper'

package/src/helpers/string-helper.ts

@@ -14,6 +14,10 @@ export const contains = (source: string, search: string | string[]): boolean =>
     return source.indexOf(search) >= 0
 }
 
+export const startsWith = (source: string, search: string): boolean => {
+    return source.substr(0, search.length) === search
+}
+
 export const remove = (source: string, search: string): string => {
     return source.replace(search, "")
 }