5a5fe3bb95
* Make machine command type names more explicit * Prepare "change tool" event for command bar * Make it so that state machine events can each map to multiple command configs * Make commands with all skippable args possible * Add back the tools to the command bar * A snapshot a day keeps the bugs away! 📷🐛 (OS: ubuntu) * Update to use new `groupId` property name * A snapshot a day keeps the bugs away! 📷🐛 (OS: ubuntu) * Oops didn't save this other instance of `ownerMachine` * Add a playwright test --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
1600 lines
54 KiB
TypeScript
1600 lines
54 KiB
TypeScript
import {
|
|
PathToNode,
|
|
VariableDeclaration,
|
|
VariableDeclarator,
|
|
parse,
|
|
recast,
|
|
} from 'lang/wasm'
|
|
import { Axis, Selection, Selections, updateSelections } from 'lib/selections'
|
|
import { assign, createMachine } from 'xstate'
|
|
import { SidebarType } from 'components/ModelingSidebar/ModelingPanes'
|
|
import {
|
|
isNodeSafeToReplacePath,
|
|
getNodePathFromSourceRange,
|
|
} from 'lang/queryAst'
|
|
import {
|
|
kclManager,
|
|
sceneInfra,
|
|
sceneEntitiesManager,
|
|
engineCommandManager,
|
|
editorManager,
|
|
} from 'lib/singletons'
|
|
import {
|
|
horzVertInfo,
|
|
applyConstraintHorzVert,
|
|
} from 'components/Toolbar/HorzVert'
|
|
import {
|
|
applyConstraintHorzVertAlign,
|
|
horzVertDistanceInfo,
|
|
} from 'components/Toolbar/SetHorzVertDistance'
|
|
import { angleBetweenInfo } from 'components/Toolbar/SetAngleBetween'
|
|
import { angleLengthInfo } from 'components/Toolbar/setAngleLength'
|
|
import {
|
|
applyConstraintEqualLength,
|
|
setEqualLengthInfo,
|
|
} from 'components/Toolbar/EqualLength'
|
|
import {
|
|
addStartProfileAt,
|
|
deleteFromSelection,
|
|
extrudeSketch,
|
|
} from 'lang/modifyAst'
|
|
import { getNodeFromPath } from '../lang/queryAst'
|
|
import {
|
|
applyConstraintEqualAngle,
|
|
equalAngleInfo,
|
|
} from 'components/Toolbar/EqualAngle'
|
|
import {
|
|
applyRemoveConstrainingValues,
|
|
removeConstrainingValuesInfo,
|
|
} from 'components/Toolbar/RemoveConstrainingValues'
|
|
import { intersectInfo } from 'components/Toolbar/Intersect'
|
|
import {
|
|
absDistanceInfo,
|
|
applyConstraintAxisAlign,
|
|
} from 'components/Toolbar/SetAbsDistance'
|
|
import { Models } from '@kittycad/lib/dist/types/src'
|
|
import { ModelingCommandSchema } from 'lib/commandBarConfigs/modelingCommandConfig'
|
|
import { err, trap } from 'lib/trap'
|
|
import { DefaultPlaneStr, getFaceDetails } from 'clientSideScene/sceneEntities'
|
|
import { Vector3 } from 'three'
|
|
import { quaternionFromUpNForward } from 'clientSideScene/helpers'
|
|
import { uuidv4 } from 'lib/utils'
|
|
import { Coords2d } from 'lang/std/sketch'
|
|
import { deleteSegment } from 'clientSideScene/ClientSideSceneComp'
|
|
import { executeAst } from 'lang/langHelpers'
|
|
import toast from 'react-hot-toast'
|
|
|
|
export const MODELING_PERSIST_KEY = 'MODELING_PERSIST_KEY'
|
|
|
|
export type SetSelections =
|
|
| {
|
|
selectionType: 'singleCodeCursor'
|
|
selection?: Selection
|
|
}
|
|
| {
|
|
selectionType: 'otherSelection'
|
|
selection: Axis
|
|
}
|
|
| {
|
|
selectionType: 'completeSelection'
|
|
selection: Selections
|
|
updatedPathToNode?: PathToNode
|
|
}
|
|
| {
|
|
selectionType: 'mirrorCodeMirrorSelections'
|
|
selection: Selections
|
|
}
|
|
|
|
export type MouseState =
|
|
| {
|
|
type: 'idle'
|
|
}
|
|
| {
|
|
type: 'isHovering'
|
|
on: any
|
|
}
|
|
| {
|
|
type: 'isDragging'
|
|
on: any
|
|
}
|
|
| {
|
|
type: 'timeoutEnd'
|
|
pathToNodeString: string
|
|
}
|
|
|
|
export interface SketchDetails {
|
|
sketchPathToNode: PathToNode
|
|
zAxis: [number, number, number]
|
|
yAxis: [number, number, number]
|
|
origin: [number, number, number]
|
|
}
|
|
|
|
export interface SegmentOverlay {
|
|
windowCoords: Coords2d
|
|
angle: number
|
|
group: any
|
|
pathToNode: PathToNode
|
|
visible: boolean
|
|
}
|
|
|
|
export interface SegmentOverlays {
|
|
[pathToNodeString: string]: SegmentOverlay
|
|
}
|
|
|
|
export type SegmentOverlayPayload =
|
|
| {
|
|
type: 'set-one'
|
|
pathToNodeString: string
|
|
seg: SegmentOverlay
|
|
}
|
|
| {
|
|
type: 'delete-one'
|
|
pathToNodeString: string
|
|
}
|
|
| { type: 'clear' }
|
|
| {
|
|
type: 'set-many'
|
|
overlays: SegmentOverlays
|
|
}
|
|
|
|
interface Store {
|
|
videoElement?: HTMLVideoElement
|
|
buttonDownInStream: number | undefined
|
|
didDragInStream: boolean
|
|
streamDimensions: { streamWidth: number; streamHeight: number }
|
|
openPanes: SidebarType[]
|
|
}
|
|
|
|
export type SketchTool = 'line' | 'tangentialArc' | 'rectangle' | 'none'
|
|
|
|
export type ModelingMachineEvent =
|
|
| {
|
|
type: 'Enter sketch'
|
|
data?: {
|
|
forceNewSketch?: boolean
|
|
}
|
|
}
|
|
| { type: 'Sketch On Face' }
|
|
| {
|
|
type: 'Select default plane'
|
|
data: {
|
|
zAxis: [number, number, number]
|
|
yAxis: [number, number, number]
|
|
} & (
|
|
| {
|
|
type: 'defaultPlane'
|
|
plane: DefaultPlaneStr
|
|
planeId: string
|
|
}
|
|
| {
|
|
type: 'extrudeFace'
|
|
position: [number, number, number]
|
|
sketchPathToNode: PathToNode
|
|
extrudePathToNode: PathToNode
|
|
cap: 'start' | 'end' | 'none'
|
|
faceId: string
|
|
}
|
|
)
|
|
}
|
|
| {
|
|
type: 'Set selection'
|
|
data: SetSelections
|
|
}
|
|
| {
|
|
type: 'Delete selection'
|
|
}
|
|
| { type: 'Sketch no face' }
|
|
| { type: 'Toggle gui mode' }
|
|
| { type: 'Cancel' }
|
|
| { type: 'CancelSketch' }
|
|
| { type: 'Add start point' }
|
|
| { type: 'Make segment horizontal' }
|
|
| { type: 'Make segment vertical' }
|
|
| { type: 'Constrain horizontal distance' }
|
|
| { type: 'Constrain ABS X' }
|
|
| { type: 'Constrain ABS Y' }
|
|
| { type: 'Constrain vertical distance' }
|
|
| { type: 'Constrain angle' }
|
|
| { type: 'Constrain perpendicular distance' }
|
|
| { type: 'Constrain horizontally align' }
|
|
| { type: 'Constrain vertically align' }
|
|
| { type: 'Constrain snap to X' }
|
|
| { type: 'Constrain snap to Y' }
|
|
| { type: 'Constrain length' }
|
|
| { type: 'Constrain equal length' }
|
|
| { type: 'Constrain parallel' }
|
|
| { type: 'Constrain remove constraints'; data?: PathToNode }
|
|
| { type: 'Re-execute' }
|
|
| { type: 'Export'; data: ModelingCommandSchema['Export'] }
|
|
| { type: 'Extrude'; data?: ModelingCommandSchema['Extrude'] }
|
|
| {
|
|
type: 'Add rectangle origin'
|
|
data: [x: number, y: number]
|
|
}
|
|
| {
|
|
type: 'done.invoke.animate-to-face' | 'done.invoke.animate-to-sketch'
|
|
data: SketchDetails
|
|
}
|
|
| { type: 'Set mouse state'; data: MouseState }
|
|
| { type: 'Set context'; data: Partial<Store> }
|
|
| {
|
|
type: 'Set Segment Overlays'
|
|
data: SegmentOverlayPayload
|
|
}
|
|
| {
|
|
type: 'Delete segment'
|
|
data: PathToNode
|
|
}
|
|
| {
|
|
type: 'code edit during sketch'
|
|
}
|
|
| {
|
|
type: 'Convert to variable'
|
|
data: {
|
|
pathToNode: PathToNode
|
|
variableName: string
|
|
}
|
|
}
|
|
| {
|
|
type: 'change tool'
|
|
data: {
|
|
tool: SketchTool
|
|
}
|
|
}
|
|
| { type: 'Finish rectangle' }
|
|
|
|
export type MoveDesc = { line: number; snippet: string }
|
|
|
|
export const PERSIST_MODELING_CONTEXT = 'persistModelingContext'
|
|
interface PersistedModelingContext {
|
|
openPanes: Store['openPanes']
|
|
}
|
|
|
|
type PersistedKeys = keyof PersistedModelingContext
|
|
export const PersistedValues: PersistedKeys[] = ['openPanes']
|
|
|
|
const persistedContext: Partial<PersistedModelingContext> = (typeof window !==
|
|
'undefined' &&
|
|
JSON.parse(localStorage.getItem(PERSIST_MODELING_CONTEXT) || '{}')) || {
|
|
openPanes: ['code'],
|
|
}
|
|
|
|
export const modelingMachine = createMachine(
|
|
{
|
|
/** @xstate-layout N4IgpgJg5mDOIC5QFkD2EwBsCWA7KAxAMICGuAxlgNoAMAuoqAA6qzYAu2qujIAHogC0ANhoAWAHQB2GgE4ATLNEAOAKwBGAMyzNAGhABPRFNWaJmscOXyp61aplWAvk-1oMOfAQDKYdgAJYLDByTm5aBiQQFjYwniiBBEFlK2l1Gil5UxpreTEpfSMEeTyJYU0reW1hVRTxYRc3dCw8Ql8AgFtUAFcgwPYSdjAI3hiOLnjQROTlGgl5ZUWxDK0ZVVlCxE1VOfXxGlUq2R1NKUaQdxavdv9ybiG+dhGosbjeRJpNhBpzy882vz+XxQDpgXABADyADcwAAnTAkAywZ7MVjjbjvRCfQxY37Nf4SbAQTBgAgAUXBcMCAGs-OQABYo6Jot4JITyYRSCTqDk6NSadSyMTyL6abQSZQ6KX2CwaM6uC741qE4mkilDWE0umM9SRVGxCaYpJ5OZidSiOw5TQ5DJfZbyCQKKQ1HlWLTKc14jzKokk8mPWHdDBM16GtlJexcxQHYSyVRiWrqL7qS3zFKSuPiIVmr1XKAqv1kvgsWFPeijFlhqbsxZpk0ldRiIW1L5SWxlEwWGqzGwJ3ME32kgAiwSGgWCoQmIcrGPDgiOEq0nMy9lkUjEiy+cdkEnEWXXsnUks0eX7yu8tPYDOIZEomAv2unBtn1YQPLF8zEFg5qmErryyaCnMNDCJY2wOFIsg0JoZ74BID5XvSBAjiSY5BCCYJlnqzLPpM-DGCYjqKIcyhNjIix6DiCAJlyxzLDKOygSBsH5gh153Bg-iQBw-gQN0sKtFqiFPuieGJFoCgSPGkFSIsSgJvkW7ijGcmiLYgpiCx8GXgy2nagAkqqBDICQtLjhh4L+DCpbYOQJCYCJrKvlomjKOYR7WH+oGSsIybCg6eS1E2syLAsMEKn8546fSemIYZfomWZ6GgpZ9KoAJABe9z2Y5Vb4W+J7qNIYgJso2w6OUoHJiepqHocey2DQNDqFpbExW18WkkQ3CwOwsIkHg-hpZl2WYLx2C9bewzli8M5iYgWjNdyskLGVdiycoXwmqou7NSe+TbOtDQRUqcFtbFDKdcQPV9QNuBWXCnB2WNEATQMFDTdhoYvvlWjmruixlc18iCqYYhbQsDr5E1cgHGKLUnd6Z3RRd9JXd1uC9f1g0AIIAELeP4AAauU-eJYoOg4Fg6GaIN-qoW1KGYUEcuI1ryM1yitSjHVGRjWN3f4+OEwAmqT80FSe5iyY2chKPV4NUdaa4dqstSkRtx1NEjrE89F6M3dj91kFAJLi0aEm7IKsxrFBG4ilRWT-RzJU0BzJ6kSV3PaqjBuY7dg0kvg7CMjN+qiRbrmSDsdjKM6f2kZRRQcjYaSHP5HOLHY3uIb7fOG4LTBwkXuCveQ3QIpqr2TR95vhjyhHlIcUGhZksibY71hmMINSZBzTVNvIOe6bzfr8wH93DdgWXgvZmAGP49nYFAuB185yuOtm5SeTY9jJvVn7mpkTUVFaw-tfr+f+0bD02c98+LzgK9r79J7CFJVhqJBa4cl+yblNHbYwgSjbmglUc+ecx4F0GrAXAJAmD+HYKgYmL9yaiHMMcWS651jpGsFtA4RV1C2CbDkD0h55TazzKjSBXVoH3VgfAxByCxZhxwhHeup95g8kUMAoha4xRbTsO-JsCYY46B2LICBo9aHX0FmAAAjt0ey-gg5QBDqghaFg5g1AyImFI3CNhUSIeKU4f48gUz-JpRGVDzrSOurIwaTASD9UwCSByrDvoS1WJIc0WQlCNUbFoZMcZ372CCs1UCWgrGUIJLYy+UCHH3VhGALoMJbh0PYMiDxc0LbEWKonfIOjd7JjKjuJQvZoaHgFAjGJUUfZ2IAEpgEEGAPgIRuhDA0W+BwO1YztxqpUpMRjxCSFMSYcpIFfwUMVDrahdiOJgC4q9AIfEBL4CEgyLpEkHR-kPEQuObNBTJhPruZ0TdfziI0FI+JMjrIBCQVZZx2ASAACMzbZNwpHY4EoMieSFIKcoDsiiFXfkAyxHN1jRJmTYvWBkjIMhNospBqB3FfRyeGLIbsJTRgUHsfhQKFp2AdBkUQbtFBlW3hAnGAB3AaAQp4zwGC9N6U1-B4AAGaoAIBAbgYBCS4ChKgWkEgYDsEEAy0aggOWoC6VUDQUku6hUzpYBmjthRuUgikfIJVsiNipbSniErZ7MprpQNluBOUEDhLCdKEgmAInYJy2EHQRV+HFelaekrpWyu2AFHYrl24cjsIY5O2g5jt1AnkYBiwDjTMisjH2NK6W3yeso6u70zXSu5by-lgrhWisEHc2y9kpUWplR89hr45U7hsKcQGG4QIEuKIoB01h0jOmWAoIh+rk1FueuNU1iys3WttfawYTqXUFr7SW71FanL5WrY6M0UhTFTLkIrZOTtuQpmFD3UCYpwq1ITbnJNPFhbE3NZanluA+V4DzXygtrzYCCD4KWzlPrygSjXO3DIFgSohsQIodsORgHLHIpyIe1jYko1PQEc9RNL1cpHbCO1DqJ2urFU+l9b7y1os+Riio0dYwpA5sQohjMsjmBGW2VyGQdBxtOrrRNBq4ME38CLRD2ab25qFQ+t1WGDA4Y-WYJsxiSrpHMQUJWJKJAlXyOuNQUF24MdmedWDQs2MceHbCG1KGx2OvSpO-jLzn2CdnXhytC7CPckqutfIIMciimMbuOwG4ai9iPj2niJsSScevbegVvGMOCB8808zFZ8NVus1+dSpxlh4Mdr+HacdAXxgFIeU8UG6knpY4vfAvntO6dQ+OwzwXQtCbnXlRIVQagSmWOkHuzV45bUOO-A4UoEw-mIV5gIqiQ5+ZzXeoLBa+v0gqxZ+d1WKiUysKcH8OxMhbVjJIJqh4zTlDbA4HrKiwRqPpJx5DxWDPOuC6N8bEXLNTc-TVsUPcmwWEbEt+VKgBSnA0NYaC22i6whLmXCuziB0ZqHWWrjAX73Be+792y-3YSCHTVNc7s1ItWfSLuIU1oBTQXsORzuFh3JtxyCYLbWXj26XU5DsEf3K6A9ZYV0daHSsFop6XaHlc4cso+oj8Ok3AOY7R1+aC6RwI4+TrJUFRDoxx0jBAgAMngJFqAUUEARfgBXKLZWiFCaVNsR5AVbgWFJH8chGs2GarL+XTCUUSH0rgDgBBZVhUdOuJsvcNBhS+LGOYR5Cnw1cnN83N7LeYGt7b9g9vdQXZ582w8TueSkVAjFjkrYlBO9jOaQqrlZIB7V8HgAcsggACqgPAmSCA4wgBAfoziAgsBLxrqCVGjgnm0JKVVRQIOyfphBFc37s9B4kPn-wReS+wBvB9VFkeqsLR8jZilsaHALFbKjkqHMiHqxbhAm3dutkgW7nTD7dQxfJjyFDKJ-qKjK036H8PE2p9vjlruDkFEUwLEcNVJq0hqkyHtKYNQECAAqiK4IzyY0zi5ATCyu9IiKQeXSpwIE5gCYMYCgJKtoVEJgbkoEMgzo1okEOQqgEC3QpcyCk0pYbUEIuAoOPGwqOM3g-+gghBPKggJB7AZBq8lWZMmif4CqbYIMpU6wQorY8q5oCkX8GsQoECTSoQoWQekB0ByKE+SOl2Ww6QXu8Y1g64DcKQUmRQEmO4f4rcOwagv4EhIQ70psOeEgsGgkQQdwpc6SsIN6sIBAAAYngBNPtsklIflp9JPhwQgN+DsqYOkJYAQhoBuogHHA6PtEKEGsEeuCYV4eYf3lYesh6lAHgGXhXv4J4WYb5mkXgLAfVtIM3KIrGDgW3sYKjhkAcAsIKMcNNgkbkRYa4bbrAPSJAP4JIU0fbuwV4jIHMMRBVOsB6MAr5FREzI6EeEoLDKBAoBAuQCSGQIEA6qSFspYEVBoaYP0VUCUBUW+DyEVHGIKFoqShUDUtCtBsxsmrYXckwo8gJK8n6P5lQXxmKjcY9IIEgoWk8o8WFmWj6iUJ+JgSULstaGMcCiUG5I2OYquuaHMSTkxjltcdwLcQ8lCD8W8qSIdvpuhgWu8aWJ8agN8Q8ZiVzmwlHlUKcGUEuDIOkCoeCVsBUBqm3LuimGQlCvGoiWTrlrYQLINMkqkosryRPKXs8UNsKowcKUbIIAKagDCIIFKXdFhL4RLDsUVCUboWVAKAyW+FqWkA3CmLUITucZydQupoqYNEakyvPJQeKXypKXQu6iNMavPD6huJ-ooHWqRJDOEQVKjrMVBJBBoJYvgQiWaTyXQimsWq4gYLaYFhKUSRabgIWo9NGa6b0UaHKsIpDDYJKBUn5DkOYFYLYNsE1EeGKNtkmUNB6oynPAvEvCvHGeDg6Ykk6Z6i6YJg2Wwbfn4ZSXoRoDsPFgpPvEQl+vUEeHkKIZWZGdOjGY-MvBQWKfGfaYmY6bOfPCFk-N2SqZmYVFJFBNCRuHYEMjoX+GYMrFMYcNsBYNOYkoEHAggg8kTE2UFi2XycmQwkwISS+m6VyDrmnvUeCvgiVLuJUH0nYKWSaYxuGciXeZ+XcSLC+QmQqY6Z+d+QYD6qYGUL8oPInBjoItsPMG6EfEaSmLee+VxIosoqNkhSuSha2QokopgIIKNj6spGpIoGuFLnsRLjtMbp1rgRTIehcdltybBRRU4i4m4rRRIG+RPIIJJXPNQBmQRr+LuMKPHNBHdiusEvkNyGVCDHCUIjeWGedEQFAarv4P-orpgD0T2aqRoS5mKCIg4BJknAtHIBsXFj-FxT5BAuZdAdZUrlQBHooRSWtsVIPHuGaLiscjHiugeG3BtEoP5RZTAFZTZfbvIPZUaAKE2NyBBE1OYqIDoHFV5YlUBnJBydBWZWlYskFbZVQJoDleGBUG2GUHGGoGaNBEzDxZ5Z-hVb5SlaZdFP4LgMguyiQJQD4BOCsmAJNRXDXgiDel0vOFisKDoACkYWQjqZyGYGcj-E1EqpImGWQNgB0IMIJA8mOjejJWdRdUMN+ZNZQF0lTNheUoUsbpuFRD3EVJihtPoiupBkevmPdZdesg8q0m9NYdFHdbbg9c0l8bANFK9aOcAiEkcEQtgqKAcEWVUsGZkL4sdAqONRgPAFEJyTuXOLGKEpyPwqREFNoQtByLJu2uUOBL-u3FpIOFTa+CIO6VMvTaVIpFRFnFJNaB6EEVUM1CdSDajLzb9M1L0vvpnGpCkARfubMGEUVacEeNcnCiSAreJIgbJs5RBDUP+sftBADGsCQmuBuMJaaWprllaWmhzpmmWkbQtHVFJM6HGLYBVNoL6SaH9XsnkM2NqdtrOTTh9Ihl7W+AoDWtuMgUQuaG7BDLUE7jDA4MKOsMTnLc7cmvBnHWFXfhpAMYKO2t6WuIzMsLJm7H+G7F2p9iNVcWeppiXdzmXVKGUAnhJmoCBAoDjeuMtO6EeApiuqGQXTBrltIdKvHRpA6Gcm7OPVKGoC1qOX7XTRRD3NYNtqNp3eSd3VSaYHGCVNaG7NsB3MnKBDtAlR6KDPYGbq3UiTxMzlTgDvDrHfPaXX4UBMzPtOmGoAZXsTYA3j3L+GVF+N7gcH3vIfHSDDsPMHIBft+glV8LUDtL2AKIZQoDTXAzZSHhwAg9bMg4HWg6cK2EtC-uaJKJaOQgQ1buNc6vZAg-GJIGeeUX+JXUvqaMKE1uvjkIw3noXsXuCOTV3b2TsKaJXT+KROkHvGge2CCfRmBLGIoFfsQ7-V4g1tIB6D-oKKzDqSmA3iBGBJGIJQAUAZwMomAUwvHXNitogfJnASBh7uKHurEQ4CErLSJaTjFAwcQQMKQdFOQQvSuu-JyI2JEkfOnVRGEvXW2BuAZUDNVapijF0dIfA9o7lSBEVHHK5lkBzBzDqQ4O-O7L+HtWYqBI0Vk4QykVAOOLYZXncA4XCA4+kDuAU-GEU27CBF8A-RKCkNUqIL+PdrU94ckSxoJPkXhJ4rlYEmUNsOgYPeUbw6cjUWQoBcDX41yTFJk5M-IRIC0e4R0Qc+YR03jvYIZWEinI5uMfASkFBCeJkOoTUPMYsfQisQva7B2JKCYJkOtieR5ZkI6Lvvdi41PbszBTxPifcsguiSSYbTk-XM846IRkyTyPw02ieIoPMJgjwXTLfeRRPNkSknKUKRkhI0fX-XQ7uM3mSs6KYCUCUiDOi2LiuvRCDI7TVTPeJaS67TGQvXS2AuzDYDUPtMfu3BKNgccIeDTXvS-WJbCzOamffEUJI14iKwyyUEy5K0YssO-M6D1TYNLcWSSzfIKw-F2cKzHqK3Wj-JyNfQtIxNurGDsMy9cypjCm3QEFWeufWVuba0VPa7JI6862+BaOLWMyuk1D3Cuha4LPBU+QvWixVE7HWm7L+PglLIoPkLUMAtaH2EqzFOaZGcm8wqm9bemxoJm1kDqdy1GG2HRCMScIm4NIxdRbtiHMG-S5SWG5kE68mI4NLH+JBKIEeeIO2-dIpa4lgFWwFLMPDHHHHJBE2scTtJ2qRFrRK8xCWxIAFZZQ1Qg4O1JNrrYMM+u8eQNWRJVX5SW2NRNVNWAPHfOK5FJBcqtHHPw8C9RLVjgkoEzLdnJlpGDZwBDcgjdS+yi85J+oGhuNgVTBGh7ocI6CkP6l+BBDs6aWB1dcglDb1DDdqPHT3PMCuBTK81jRG9qQVWzMArYGOy4C4EAA */
|
|
id: 'Modeling',
|
|
|
|
tsTypes: {} as import('./modelingMachine.typegen').Typegen0,
|
|
predictableActionArguments: true,
|
|
preserveActionOrder: true,
|
|
|
|
context: {
|
|
tool: null as Models['SceneToolType_type'] | null,
|
|
selection: [] as string[],
|
|
selectionRanges: {
|
|
otherSelections: [],
|
|
codeBasedSelections: [],
|
|
} as Selections,
|
|
sketchDetails: {
|
|
sketchPathToNode: [],
|
|
zAxis: [0, 0, 1],
|
|
yAxis: [0, 1, 0],
|
|
origin: [0, 0, 0],
|
|
} as null | SketchDetails,
|
|
sketchPlaneId: '' as string,
|
|
sketchEnginePathId: '' as string,
|
|
moveDescs: [] as MoveDesc[],
|
|
mouseState: { type: 'idle' } as MouseState,
|
|
segmentOverlays: {} as SegmentOverlays,
|
|
segmentHoverMap: {} as { [pathToNodeString: string]: number },
|
|
store: {
|
|
buttonDownInStream: undefined,
|
|
didDragInStream: false,
|
|
streamDimensions: { streamWidth: 1280, streamHeight: 720 },
|
|
openPanes: persistedContext.openPanes || ['code'],
|
|
} as Store,
|
|
},
|
|
|
|
schema: {
|
|
events: {} as ModelingMachineEvent,
|
|
},
|
|
|
|
states: {
|
|
idle: {
|
|
on: {
|
|
'Enter sketch': [
|
|
{
|
|
target: 'animating to existing sketch',
|
|
cond: 'Selection is on face',
|
|
},
|
|
'Sketch no face',
|
|
],
|
|
|
|
Extrude: {
|
|
target: 'idle',
|
|
cond: 'has valid extrude selection',
|
|
actions: ['AST extrude'],
|
|
internal: true,
|
|
},
|
|
|
|
Export: {
|
|
target: 'idle',
|
|
internal: true,
|
|
cond: 'Has exportable geometry',
|
|
actions: 'Engine export',
|
|
},
|
|
|
|
'Delete selection': {
|
|
target: 'idle',
|
|
cond: 'has valid selection for deletion',
|
|
actions: ['AST delete selection'],
|
|
internal: true,
|
|
},
|
|
},
|
|
|
|
entry: 'reset client scene mouse handlers',
|
|
},
|
|
|
|
Sketch: {
|
|
states: {
|
|
SketchIdle: {
|
|
on: {
|
|
'Make segment vertical': {
|
|
cond: 'Can make selection vertical',
|
|
target: 'Await constrain vertically',
|
|
},
|
|
|
|
'Make segment horizontal': {
|
|
cond: 'Can make selection horizontal',
|
|
target: 'Await constrain horizontally',
|
|
},
|
|
|
|
'Constrain horizontal distance': {
|
|
target: 'Await horizontal distance info',
|
|
cond: 'Can constrain horizontal distance',
|
|
},
|
|
|
|
'Constrain vertical distance': {
|
|
target: 'Await vertical distance info',
|
|
cond: 'Can constrain vertical distance',
|
|
},
|
|
|
|
'Constrain ABS X': {
|
|
target: 'Await ABS X info',
|
|
cond: 'Can constrain ABS X',
|
|
},
|
|
|
|
'Constrain ABS Y': {
|
|
target: 'Await ABS Y info',
|
|
cond: 'Can constrain ABS Y',
|
|
},
|
|
|
|
'Constrain angle': {
|
|
target: 'Await angle info',
|
|
cond: 'Can constrain angle',
|
|
},
|
|
|
|
'Constrain length': {
|
|
target: 'Await length info',
|
|
cond: 'Can constrain length',
|
|
},
|
|
|
|
'Constrain perpendicular distance': {
|
|
target: 'Await perpendicular distance info',
|
|
cond: 'Can constrain perpendicular distance',
|
|
},
|
|
|
|
'Constrain horizontally align': {
|
|
cond: 'Can constrain horizontally align',
|
|
target: 'Await constrain horizontally align',
|
|
},
|
|
|
|
'Constrain vertically align': {
|
|
cond: 'Can constrain vertically align',
|
|
target: 'Await constrain vertically align',
|
|
},
|
|
|
|
'Constrain snap to X': {
|
|
cond: 'Can constrain snap to X',
|
|
target: 'Await constrain snap to X',
|
|
},
|
|
|
|
'Constrain snap to Y': {
|
|
cond: 'Can constrain snap to Y',
|
|
target: 'Await constrain snap to Y',
|
|
},
|
|
|
|
'Constrain equal length': {
|
|
cond: 'Can constrain equal length',
|
|
target: 'Await constrain equal length',
|
|
},
|
|
|
|
'Constrain parallel': {
|
|
target: 'Await constrain parallel',
|
|
cond: 'Can canstrain parallel',
|
|
},
|
|
|
|
'Constrain remove constraints': {
|
|
cond: 'Can constrain remove constraints',
|
|
target: 'Await constrain remove constraints',
|
|
},
|
|
|
|
'Re-execute': {
|
|
target: 'SketchIdle',
|
|
internal: true,
|
|
actions: ['set sketchMetadata from pathToNode'],
|
|
},
|
|
|
|
'code edit during sketch': 'clean slate',
|
|
|
|
'Convert to variable': {
|
|
target: 'Await convert to variable',
|
|
cond: 'Can convert to variable',
|
|
},
|
|
|
|
'change tool': {
|
|
target: 'Change Tool',
|
|
},
|
|
},
|
|
|
|
entry: 'setup client side sketch segments',
|
|
},
|
|
|
|
'Await horizontal distance info': {
|
|
invoke: {
|
|
src: 'Get horizontal info',
|
|
id: 'get-horizontal-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await vertical distance info': {
|
|
invoke: {
|
|
src: 'Get vertical info',
|
|
id: 'get-vertical-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await ABS X info': {
|
|
invoke: {
|
|
src: 'Get ABS X info',
|
|
id: 'get-abs-x-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await ABS Y info': {
|
|
invoke: {
|
|
src: 'Get ABS Y info',
|
|
id: 'get-abs-y-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await angle info': {
|
|
invoke: {
|
|
src: 'Get angle info',
|
|
id: 'get-angle-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await length info': {
|
|
invoke: {
|
|
src: 'Get length info',
|
|
id: 'get-length-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Await perpendicular distance info': {
|
|
invoke: {
|
|
src: 'Get perpendicular distance info',
|
|
id: 'get-perpendicular-distance-info',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
onError: 'SketchIdle',
|
|
},
|
|
},
|
|
|
|
'Line tool': {
|
|
exit: [],
|
|
|
|
states: {
|
|
Init: {
|
|
always: [
|
|
{
|
|
target: 'normal',
|
|
cond: 'has made first point',
|
|
actions: 'set up draft line',
|
|
},
|
|
'No Points',
|
|
],
|
|
},
|
|
|
|
normal: {},
|
|
|
|
'No Points': {
|
|
entry: 'setup noPoints onClick listener',
|
|
|
|
on: {
|
|
'Add start point': {
|
|
target: 'normal',
|
|
actions: 'set up draft line without teardown',
|
|
},
|
|
|
|
Cancel: '#Modeling.Sketch.undo startSketchOn',
|
|
},
|
|
},
|
|
},
|
|
|
|
initial: 'Init',
|
|
|
|
on: {
|
|
'change tool': {
|
|
target: 'Change Tool',
|
|
},
|
|
},
|
|
},
|
|
|
|
Init: {
|
|
always: [
|
|
{
|
|
target: 'SketchIdle',
|
|
cond: 'is editing existing sketch',
|
|
},
|
|
'Line tool',
|
|
],
|
|
},
|
|
|
|
'Tangential arc to': {
|
|
entry: 'set up draft arc',
|
|
|
|
on: {
|
|
'change tool': {
|
|
target: 'Change Tool',
|
|
},
|
|
},
|
|
},
|
|
|
|
'undo startSketchOn': {
|
|
invoke: {
|
|
src: 'AST-undo-startSketchOn',
|
|
id: 'AST-undo-startSketchOn',
|
|
onDone: '#Modeling.idle',
|
|
},
|
|
},
|
|
|
|
'Rectangle tool': {
|
|
entry: ['listen for rectangle origin'],
|
|
|
|
states: {
|
|
'Awaiting second corner': {
|
|
on: {
|
|
'Finish rectangle': 'Finished Rectangle',
|
|
},
|
|
},
|
|
|
|
'Awaiting origin': {
|
|
on: {
|
|
'Add rectangle origin': {
|
|
target: 'Awaiting second corner',
|
|
actions: 'set up draft rectangle',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Finished Rectangle': {
|
|
always: '#Modeling.Sketch.SketchIdle',
|
|
},
|
|
},
|
|
|
|
initial: 'Awaiting origin',
|
|
|
|
on: {
|
|
'change tool': {
|
|
target: 'Change Tool',
|
|
},
|
|
},
|
|
},
|
|
|
|
'clean slate': {
|
|
always: 'SketchIdle',
|
|
},
|
|
|
|
'Await convert to variable': {
|
|
invoke: {
|
|
src: 'Get convert to variable info',
|
|
id: 'get-convert-to-variable-info',
|
|
onError: 'SketchIdle',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: ['Set selection'],
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain remove constraints': {
|
|
invoke: {
|
|
src: 'do-constrain-remove-constraint',
|
|
id: 'do-constrain-remove-constraint',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain horizontally': {
|
|
invoke: {
|
|
src: 'do-constrain-horizontally',
|
|
id: 'do-constrain-horizontally',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain vertically': {
|
|
invoke: {
|
|
src: 'do-constrain-vertically',
|
|
id: 'do-constrain-vertically',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain horizontally align': {
|
|
invoke: {
|
|
src: 'do-constrain-horizontally-align',
|
|
id: 'do-constrain-horizontally-align',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain vertically align': {
|
|
invoke: {
|
|
src: 'do-constrain-vertically-align',
|
|
id: 'do-constrain-vertically-align',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain snap to X': {
|
|
invoke: {
|
|
src: 'do-constrain-snap-to-x',
|
|
id: 'do-constrain-snap-to-x',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain snap to Y': {
|
|
invoke: {
|
|
src: 'do-constrain-snap-to-y',
|
|
id: 'do-constrain-snap-to-y',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain equal length': {
|
|
invoke: {
|
|
src: 'do-constrain-equal-length',
|
|
id: 'do-constrain-equal-length',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Await constrain parallel': {
|
|
invoke: {
|
|
src: 'do-constrain-parallel',
|
|
id: 'do-constrain-parallel',
|
|
onDone: {
|
|
target: 'SketchIdle',
|
|
actions: 'Set selection',
|
|
},
|
|
},
|
|
},
|
|
|
|
'Change Tool': {
|
|
always: [
|
|
{
|
|
target: 'SketchIdle',
|
|
cond: 'next is none',
|
|
},
|
|
{
|
|
target: 'Line tool',
|
|
cond: 'next is line',
|
|
},
|
|
{
|
|
target: 'Rectangle tool',
|
|
cond: 'next is rectangle',
|
|
},
|
|
{
|
|
target: 'Tangential arc to',
|
|
cond: 'next is tangential arc',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
|
|
initial: 'Init',
|
|
|
|
on: {
|
|
CancelSketch: '.SketchIdle',
|
|
|
|
'Delete segment': {
|
|
internal: true,
|
|
actions: ['Delete segment', 'Set sketchDetails'],
|
|
},
|
|
'code edit during sketch': '.clean slate',
|
|
},
|
|
|
|
exit: [
|
|
'sketch exit execute',
|
|
'tear down client sketch',
|
|
'remove sketch grid',
|
|
'engineToClient cam sync direction',
|
|
'Reset Segment Overlays',
|
|
'enable copilot',
|
|
],
|
|
|
|
entry: [
|
|
'add axis n grid',
|
|
'conditionally equip line tool',
|
|
'clientToEngine cam sync direction',
|
|
],
|
|
},
|
|
|
|
'Sketch no face': {
|
|
entry: [
|
|
'disable copilot',
|
|
'show default planes',
|
|
'set selection filter to faces only',
|
|
],
|
|
|
|
exit: ['hide default planes', 'set selection filter to defaults'],
|
|
on: {
|
|
'Select default plane': {
|
|
target: 'animating to plane',
|
|
actions: ['reset sketch metadata'],
|
|
},
|
|
},
|
|
},
|
|
|
|
'animating to plane': {
|
|
invoke: {
|
|
src: 'animate-to-face',
|
|
id: 'animate-to-face',
|
|
onDone: {
|
|
target: 'Sketch',
|
|
actions: 'set new sketch metadata',
|
|
},
|
|
},
|
|
},
|
|
|
|
'animating to existing sketch': {
|
|
invoke: [
|
|
{
|
|
src: 'animate-to-sketch',
|
|
id: 'animate-to-sketch',
|
|
onDone: {
|
|
target: 'Sketch',
|
|
actions: ['disable copilot', 'set new sketch metadata'],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
|
|
initial: 'idle',
|
|
|
|
on: {
|
|
Cancel: {
|
|
target: 'idle',
|
|
// TODO what if we're existing extrude equipped, should these actions still be fired?
|
|
// maybe cancel needs to have a guard for if else logic?
|
|
actions: ['reset sketch metadata', 'enable copilot'],
|
|
},
|
|
|
|
'Set selection': {
|
|
internal: true,
|
|
actions: 'Set selection',
|
|
},
|
|
|
|
'Set mouse state': {
|
|
internal: true,
|
|
actions: 'Set mouse state',
|
|
},
|
|
'Set context': {
|
|
internal: true,
|
|
actions: 'Set context',
|
|
},
|
|
'Set Segment Overlays': {
|
|
internal: true,
|
|
actions: 'Set Segment Overlays',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
guards: {
|
|
'has made first point': ({ sketchDetails }) => {
|
|
if (!sketchDetails?.sketchPathToNode) return false
|
|
const variableDeclaration = getNodeFromPath<VariableDeclarator>(
|
|
kclManager.ast,
|
|
sketchDetails.sketchPathToNode,
|
|
'VariableDeclarator'
|
|
)
|
|
if (err(variableDeclaration)) return false
|
|
if (variableDeclaration.node.type !== 'VariableDeclarator') return false
|
|
const pipeExpression = variableDeclaration.node.init
|
|
if (pipeExpression.type !== 'PipeExpression') return false
|
|
const hasStartSketchOn = pipeExpression.body.some(
|
|
(item) =>
|
|
item.type === 'CallExpression' &&
|
|
item.callee.name === 'startSketchOn'
|
|
)
|
|
return hasStartSketchOn && pipeExpression.body.length > 1
|
|
},
|
|
'is editing existing sketch': ({ sketchDetails }) =>
|
|
isEditingExistingSketch({ sketchDetails }),
|
|
'Can make selection horizontal': ({ selectionRanges }) => {
|
|
const info = horzVertInfo(selectionRanges, 'horizontal')
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can make selection vertical': ({ selectionRanges }) => {
|
|
const info = horzVertInfo(selectionRanges, 'vertical')
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain horizontal distance': ({ selectionRanges }) => {
|
|
const info = horzVertDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'setHorzDistance',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain vertical distance': ({ selectionRanges }) => {
|
|
const info = horzVertDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'setVertDistance',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain ABS X': ({ selectionRanges }) => {
|
|
const info = absDistanceInfo({ selectionRanges, constraint: 'xAbs' })
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain ABS Y': ({ selectionRanges }) => {
|
|
const info = absDistanceInfo({ selectionRanges, constraint: 'yAbs' })
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain angle': ({ selectionRanges }) => {
|
|
const angleBetween = angleBetweenInfo({ selectionRanges })
|
|
if (trap(angleBetween)) return false
|
|
const angleLength = angleLengthInfo({
|
|
selectionRanges,
|
|
angleOrLength: 'setAngle',
|
|
})
|
|
if (trap(angleLength)) return false
|
|
return angleBetween.enabled || angleLength.enabled
|
|
},
|
|
'Can constrain length': ({ selectionRanges }) => {
|
|
const angleLength = angleLengthInfo({ selectionRanges })
|
|
if (trap(angleLength)) return false
|
|
return angleLength.enabled
|
|
},
|
|
'Can constrain perpendicular distance': ({ selectionRanges }) => {
|
|
const info = intersectInfo({ selectionRanges })
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain horizontally align': ({ selectionRanges }) => {
|
|
const info = horzVertDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'setHorzDistance',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain vertically align': ({ selectionRanges }) => {
|
|
const info = horzVertDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'setHorzDistance',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain snap to X': ({ selectionRanges }) => {
|
|
const info = absDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'snapToXAxis',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain snap to Y': ({ selectionRanges }) => {
|
|
const info = absDistanceInfo({
|
|
selectionRanges,
|
|
constraint: 'snapToYAxis',
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain equal length': ({ selectionRanges }) => {
|
|
const info = setEqualLengthInfo({ selectionRanges })
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can canstrain parallel': ({ selectionRanges }) => {
|
|
const info = equalAngleInfo({ selectionRanges })
|
|
if (err(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can constrain remove constraints': ({ selectionRanges }, { data }) => {
|
|
const info = removeConstrainingValuesInfo({
|
|
selectionRanges,
|
|
pathToNodes: data && [data],
|
|
})
|
|
if (trap(info)) return false
|
|
return info.enabled
|
|
},
|
|
'Can convert to variable': (_, { data }) => {
|
|
if (!data) return false
|
|
const ast = parse(recast(kclManager.ast))
|
|
if (err(ast)) return false
|
|
const isSafeRetVal = isNodeSafeToReplacePath(ast, data.pathToNode)
|
|
if (err(isSafeRetVal)) return false
|
|
return isSafeRetVal.isSafe
|
|
},
|
|
'next is tangential arc': ({ sketchDetails }, _, { state }) =>
|
|
(state?.event as any).data.tool === 'tangentialArc' &&
|
|
isEditingExistingSketch({ sketchDetails }),
|
|
'next is rectangle': ({ sketchDetails }, _, { state }) => {
|
|
if ((state?.event as any).data.tool !== 'rectangle') return false
|
|
return canRectangleTool({ sketchDetails })
|
|
},
|
|
'next is line': (_, __, { state }) =>
|
|
(state?.event as any).data.tool === 'line',
|
|
'next is none': (_, __, { state }) =>
|
|
(state?.event as any).data.tool === 'none',
|
|
},
|
|
// end guards
|
|
actions: {
|
|
'set sketchMetadata from pathToNode': assign(({ sketchDetails }) => {
|
|
if (!sketchDetails?.sketchPathToNode || !sketchDetails) return {}
|
|
return {
|
|
sketchDetails: {
|
|
...sketchDetails,
|
|
sketchPathToNode: sketchDetails.sketchPathToNode,
|
|
},
|
|
}
|
|
}),
|
|
'hide default planes': () => {
|
|
sceneInfra.removeDefaultPlanes()
|
|
kclManager.hidePlanes()
|
|
},
|
|
'reset sketch metadata': assign({
|
|
sketchDetails: null,
|
|
sketchEnginePathId: '',
|
|
sketchPlaneId: '',
|
|
}),
|
|
'set new sketch metadata': assign((_, { data }) => ({
|
|
sketchDetails: data,
|
|
})),
|
|
'AST extrude': async ({ store }, event) => {
|
|
if (!event.data) return
|
|
const { selection, distance } = event.data
|
|
let ast = kclManager.ast
|
|
if (
|
|
'variableName' in distance &&
|
|
distance.variableName &&
|
|
distance.insertIndex !== undefined
|
|
) {
|
|
const newBody = [...ast.body]
|
|
newBody.splice(
|
|
distance.insertIndex,
|
|
0,
|
|
distance.variableDeclarationAst
|
|
)
|
|
ast.body = newBody
|
|
}
|
|
const pathToNode = getNodePathFromSourceRange(
|
|
ast,
|
|
selection.codeBasedSelections[0].range
|
|
)
|
|
const extrudeSketchRes = extrudeSketch(
|
|
ast,
|
|
pathToNode,
|
|
false,
|
|
'variableName' in distance
|
|
? distance.variableIdentifierAst
|
|
: distance.valueAst
|
|
)
|
|
if (trap(extrudeSketchRes)) return
|
|
const { modifiedAst, pathToExtrudeArg } = extrudeSketchRes
|
|
|
|
store.videoElement?.pause()
|
|
const updatedAst = await kclManager.updateAst(modifiedAst, true, {
|
|
focusPath: pathToExtrudeArg,
|
|
zoomToFit: true,
|
|
zoomOnRangeAndType: {
|
|
range: selection.codeBasedSelections[0].range,
|
|
type: 'start_path',
|
|
},
|
|
})
|
|
if (!engineCommandManager.engineConnection?.freezeFrame) {
|
|
store.videoElement?.play()
|
|
}
|
|
if (updatedAst?.selections) {
|
|
editorManager.selectRange(updatedAst?.selections)
|
|
}
|
|
},
|
|
'AST delete selection': async ({ sketchDetails, selectionRanges }) => {
|
|
let ast = kclManager.ast
|
|
|
|
const modifiedAst = await deleteFromSelection(
|
|
ast,
|
|
selectionRanges.codeBasedSelections[0],
|
|
kclManager.programMemory,
|
|
getFaceDetails
|
|
)
|
|
if (err(modifiedAst)) return
|
|
|
|
const testExecute = await executeAst({
|
|
ast: modifiedAst,
|
|
useFakeExecutor: true,
|
|
engineCommandManager,
|
|
})
|
|
if (testExecute.errors.length) {
|
|
toast.error('Unable to delete part')
|
|
return
|
|
}
|
|
|
|
await kclManager.updateAst(modifiedAst, true)
|
|
},
|
|
'conditionally equip line tool': (_, { type }) => {
|
|
if (type === 'done.invoke.animate-to-face') {
|
|
sceneInfra.modelingSend({
|
|
type: 'change tool',
|
|
data: { tool: 'line' },
|
|
})
|
|
}
|
|
},
|
|
'setup client side sketch segments': ({
|
|
sketchDetails,
|
|
selectionRanges,
|
|
}) => {
|
|
if (!sketchDetails) return
|
|
;(async () => {
|
|
if (Object.keys(sceneEntitiesManager.activeSegments).length > 0) {
|
|
await sceneEntitiesManager.tearDownSketch({ removeAxis: false })
|
|
}
|
|
sceneInfra.resetMouseListeners()
|
|
await sceneEntitiesManager.setupSketch({
|
|
sketchPathToNode: sketchDetails?.sketchPathToNode || [],
|
|
forward: sketchDetails.zAxis,
|
|
up: sketchDetails.yAxis,
|
|
position: sketchDetails.origin,
|
|
maybeModdedAst: kclManager.ast,
|
|
selectionRanges,
|
|
})
|
|
sceneInfra.resetMouseListeners()
|
|
sceneEntitiesManager.setupSketchIdleCallbacks({
|
|
pathToNode: sketchDetails?.sketchPathToNode || [],
|
|
forward: sketchDetails.zAxis,
|
|
up: sketchDetails.yAxis,
|
|
position: sketchDetails.origin,
|
|
})
|
|
})()
|
|
},
|
|
'tear down client sketch': () => {
|
|
if (sceneEntitiesManager.activeSegments) {
|
|
sceneEntitiesManager.tearDownSketch({ removeAxis: false })
|
|
}
|
|
},
|
|
'remove sketch grid': () => sceneEntitiesManager.removeSketchGrid(),
|
|
'set up draft line': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
sceneEntitiesManager.setUpDraftSegment(
|
|
sketchDetails.sketchPathToNode,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin,
|
|
'line'
|
|
)
|
|
},
|
|
'set up draft arc': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
sceneEntitiesManager.setUpDraftSegment(
|
|
sketchDetails.sketchPathToNode,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin,
|
|
'tangentialArcTo'
|
|
)
|
|
},
|
|
'listen for rectangle origin': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
sceneEntitiesManager.setupRectangleOriginListener()
|
|
},
|
|
'set up draft rectangle': ({ sketchDetails }, { data }) => {
|
|
if (!sketchDetails || !data) return
|
|
sceneEntitiesManager.setupDraftRectangle(
|
|
sketchDetails.sketchPathToNode,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin,
|
|
data
|
|
)
|
|
},
|
|
'set up draft line without teardown': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
sceneEntitiesManager.setUpDraftSegment(
|
|
sketchDetails.sketchPathToNode,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin,
|
|
'line',
|
|
false
|
|
)
|
|
},
|
|
'show default planes': () => {
|
|
sceneInfra.showDefaultPlanes()
|
|
sceneEntitiesManager.setupDefaultPlaneHover()
|
|
kclManager.showPlanes()
|
|
},
|
|
'setup noPoints onClick listener': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
sceneEntitiesManager.createIntersectionPlane()
|
|
const quaternion = quaternionFromUpNForward(
|
|
new Vector3(...sketchDetails.yAxis),
|
|
new Vector3(...sketchDetails.zAxis)
|
|
)
|
|
sceneEntitiesManager.intersectionPlane &&
|
|
sceneEntitiesManager.intersectionPlane.setRotationFromQuaternion(
|
|
quaternion
|
|
)
|
|
sceneEntitiesManager.intersectionPlane &&
|
|
sceneEntitiesManager.intersectionPlane.position.copy(
|
|
new Vector3(...(sketchDetails?.origin || [0, 0, 0]))
|
|
)
|
|
sceneInfra.setCallbacks({
|
|
onClick: async (args) => {
|
|
if (!args) return
|
|
if (args.mouseEvent.which !== 1) return
|
|
const { intersectionPoint } = args
|
|
if (!intersectionPoint?.twoD || !sketchDetails?.sketchPathToNode)
|
|
return
|
|
const addStartProfileAtRes = addStartProfileAt(
|
|
kclManager.ast,
|
|
sketchDetails.sketchPathToNode,
|
|
[intersectionPoint.twoD.x, intersectionPoint.twoD.y]
|
|
)
|
|
|
|
if (trap(addStartProfileAtRes)) return
|
|
const { modifiedAst } = addStartProfileAtRes
|
|
|
|
await kclManager.updateAst(modifiedAst, false)
|
|
sceneEntitiesManager.removeIntersectionPlane()
|
|
sceneInfra.modelingSend('Add start point')
|
|
},
|
|
})
|
|
},
|
|
'add axis n grid': ({ sketchDetails }) => {
|
|
if (!sketchDetails) return
|
|
if (localStorage.getItem('disableAxis')) return
|
|
sceneEntitiesManager.createSketchAxis(
|
|
sketchDetails.sketchPathToNode || [],
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
},
|
|
'reset client scene mouse handlers': () => {
|
|
// when not in sketch mode we don't need any mouse listeners
|
|
// (note the orbit controls are always active though)
|
|
sceneInfra.resetMouseListeners()
|
|
},
|
|
'clientToEngine cam sync direction': () => {
|
|
sceneInfra.camControls.syncDirection = 'clientToEngine'
|
|
},
|
|
'engineToClient cam sync direction': () => {
|
|
sceneInfra.camControls.syncDirection = 'engineToClient'
|
|
},
|
|
'set selection filter to faces only': () =>
|
|
engineCommandManager.sendSceneCommand({
|
|
type: 'modeling_cmd_req',
|
|
cmd_id: uuidv4(),
|
|
cmd: {
|
|
type: 'set_selection_filter',
|
|
filter: ['face', 'object'],
|
|
},
|
|
}),
|
|
'set selection filter to defaults': () =>
|
|
kclManager.defaultSelectionFilter(),
|
|
'Delete segment': ({ sketchDetails }, { data: pathToNode }) =>
|
|
deleteSegment({ pathToNode, sketchDetails }),
|
|
'Reset Segment Overlays': () => sceneEntitiesManager.resetOverlays(),
|
|
'Set context': assign({
|
|
store: ({ store }, { data }) => {
|
|
if (data.streamDimensions) {
|
|
sceneInfra._streamDimensions = data.streamDimensions
|
|
}
|
|
|
|
const result = {
|
|
...store,
|
|
...data,
|
|
}
|
|
const persistedContext: Partial<PersistedModelingContext> = {}
|
|
for (const key of PersistedValues) {
|
|
persistedContext[key] = result[key]
|
|
}
|
|
if (typeof window !== 'undefined') {
|
|
window.localStorage.setItem(
|
|
PERSIST_MODELING_CONTEXT,
|
|
JSON.stringify(persistedContext)
|
|
)
|
|
}
|
|
return result
|
|
},
|
|
}),
|
|
},
|
|
// end actions
|
|
services: {
|
|
'do-constrain-remove-constraint': async (
|
|
{ selectionRanges, sketchDetails },
|
|
{ data }
|
|
) => {
|
|
const constraint = applyRemoveConstrainingValues({
|
|
selectionRanges,
|
|
pathToNodes: data && [data],
|
|
})
|
|
if (trap(constraint)) return
|
|
const { pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
let updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
pathToNodeMap[0],
|
|
constraint.modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
),
|
|
}
|
|
},
|
|
'do-constrain-horizontally': async ({
|
|
selectionRanges,
|
|
sketchDetails,
|
|
}) => {
|
|
const constraint = applyConstraintHorzVert(
|
|
selectionRanges,
|
|
'horizontal',
|
|
kclManager.ast,
|
|
kclManager.programMemory
|
|
)
|
|
if (trap(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails.sketchPathToNode,
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
),
|
|
}
|
|
},
|
|
'do-constrain-vertically': async ({ selectionRanges, sketchDetails }) => {
|
|
const constraint = applyConstraintHorzVert(
|
|
selectionRanges,
|
|
'vertical',
|
|
kclManager.ast,
|
|
kclManager.programMemory
|
|
)
|
|
if (trap(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
),
|
|
}
|
|
},
|
|
'do-constrain-horizontally-align': async ({
|
|
selectionRanges,
|
|
sketchDetails,
|
|
}) => {
|
|
const constraint = applyConstraintHorzVertAlign({
|
|
selectionRanges,
|
|
constraint: 'setVertDistance',
|
|
})
|
|
if (trap(constraint)) return
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
'do-constrain-vertically-align': async ({
|
|
selectionRanges,
|
|
sketchDetails,
|
|
}) => {
|
|
const constraint = applyConstraintHorzVertAlign({
|
|
selectionRanges,
|
|
constraint: 'setHorzDistance',
|
|
})
|
|
if (trap(constraint)) return
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
'do-constrain-snap-to-x': async ({ selectionRanges, sketchDetails }) => {
|
|
const constraint = applyConstraintAxisAlign({
|
|
selectionRanges,
|
|
constraint: 'snapToXAxis',
|
|
})
|
|
if (err(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
'do-constrain-snap-to-y': async ({ selectionRanges, sketchDetails }) => {
|
|
const constraint = applyConstraintAxisAlign({
|
|
selectionRanges,
|
|
constraint: 'snapToYAxis',
|
|
})
|
|
if (trap(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
'do-constrain-parallel': async ({ selectionRanges, sketchDetails }) => {
|
|
const constraint = applyConstraintEqualAngle({
|
|
selectionRanges,
|
|
})
|
|
if (trap(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
|
|
if (!sketchDetails) {
|
|
trap(new Error('No sketch details'))
|
|
return
|
|
}
|
|
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
parse(recast(modifiedAst)),
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
'do-constrain-equal-length': async ({
|
|
selectionRanges,
|
|
sketchDetails,
|
|
}) => {
|
|
const constraint = applyConstraintEqualLength({
|
|
selectionRanges,
|
|
})
|
|
if (trap(constraint)) return false
|
|
const { modifiedAst, pathToNodeMap } = constraint
|
|
if (!sketchDetails) return
|
|
const updatedAst = await sceneEntitiesManager.updateAstAndRejigSketch(
|
|
sketchDetails?.sketchPathToNode || [],
|
|
modifiedAst,
|
|
sketchDetails.zAxis,
|
|
sketchDetails.yAxis,
|
|
sketchDetails.origin
|
|
)
|
|
if (trap(updatedAst, { suppress: true })) return
|
|
if (!updatedAst) return
|
|
const updatedSelectionRanges = updateSelections(
|
|
pathToNodeMap,
|
|
selectionRanges,
|
|
updatedAst.newAst
|
|
)
|
|
return {
|
|
selectionType: 'completeSelection',
|
|
selection: updatedSelectionRanges,
|
|
}
|
|
},
|
|
},
|
|
// end services
|
|
}
|
|
)
|
|
|
|
export function isEditingExistingSketch({
|
|
sketchDetails,
|
|
}: {
|
|
sketchDetails: SketchDetails | null
|
|
}): boolean {
|
|
// should check that the variable declaration is a pipeExpression
|
|
// and that the pipeExpression contains a "startProfileAt" callExpression
|
|
if (!sketchDetails?.sketchPathToNode) return false
|
|
const variableDeclaration = getNodeFromPath<VariableDeclarator>(
|
|
kclManager.ast,
|
|
sketchDetails.sketchPathToNode,
|
|
'VariableDeclarator'
|
|
)
|
|
if (err(variableDeclaration)) return false
|
|
if (variableDeclaration.node.type !== 'VariableDeclarator') return false
|
|
const pipeExpression = variableDeclaration.node.init
|
|
if (pipeExpression.type !== 'PipeExpression') return false
|
|
const hasStartProfileAt = pipeExpression.body.some(
|
|
(item) =>
|
|
item.type === 'CallExpression' && item.callee.name === 'startProfileAt'
|
|
)
|
|
return hasStartProfileAt && pipeExpression.body.length > 2
|
|
}
|
|
|
|
export function canRectangleTool({
|
|
sketchDetails,
|
|
}: {
|
|
sketchDetails: SketchDetails | null
|
|
}): boolean {
|
|
const node = getNodeFromPath<VariableDeclaration>(
|
|
kclManager.ast,
|
|
sketchDetails?.sketchPathToNode || [],
|
|
'VariableDeclaration'
|
|
)
|
|
// This should not be returning false, and it should be caught
|
|
// but we need to simulate old behavior to move on.
|
|
if (err(node)) return false
|
|
return node.node?.declarations?.[0]?.init.type !== 'PipeExpression'
|
|
}
|