191 lines
7.4 KiB
JavaScript
191 lines
7.4 KiB
JavaScript
import { addToOnly } from 'shared/plugins/plugin-layout-part.mjs'
|
|
import { pluginMirror } from '@freesewing/plugin-mirror'
|
|
const prefix = 'mirroredOnFold'
|
|
|
|
// types of path operations
|
|
const opTypes = ['to', 'from', 'cp1', 'cp2']
|
|
const avoidRegx = new RegExp(`^(cutonfold|grainline|__scalebox|__miniscale|${prefix})`)
|
|
|
|
/**
|
|
* The plugin to handle all business related to mirroring, rotating, and duplicating parts for the cutting layout
|
|
* @param {string} material the material to generate a cutting layout for
|
|
* @param {number} grainAngle the angle of the material's grain
|
|
* @return {Object} the plugin
|
|
*/
|
|
export const cutLayoutPlugin = function (material, grainAngle) {
|
|
return {
|
|
hooks: {
|
|
// after each part
|
|
postPartDraft: (pattern) => {
|
|
// if it's a duplicated cut part, the fabric part, or it's not wanted by the pattern
|
|
if (
|
|
pattern.activePart.startsWith('cut.') ||
|
|
pattern.activePart === 'fabric' ||
|
|
!pattern.__wants(pattern.activePart)
|
|
)
|
|
return
|
|
|
|
// get the part that's just been drafted
|
|
const part = pattern.parts[pattern.activeSet][pattern.activePart]
|
|
// get this part's cutlist configuration
|
|
let partCutlist = pattern.setStores[pattern.activeSet].get(['cutlist', pattern.activePart])
|
|
// if there isn't one, we're done here
|
|
if (!partCutlist) return
|
|
|
|
// if the cutlist has materials but this isn't one of them
|
|
// or it has no materials but this isn't the main fabric
|
|
if (partCutlist.materials ? !partCutlist.materials[material] : material !== 'fabric') {
|
|
// hide the part because it shouldn't be shown on this fabric
|
|
part.hide()
|
|
return
|
|
}
|
|
|
|
// get the cutlist configuration for this material, or default to one
|
|
const matCutConfig =
|
|
partCutlist.materials?.[material] || (material === 'fabric' ? [{ cut: 1 }] : [])
|
|
|
|
// get the config of the active part to be inherited by all duplicates
|
|
const activePartConfig = pattern.config.parts[pattern.activePart]
|
|
|
|
// hide the active part so that all others can inherit from it and be manipulated separately
|
|
part.hide()
|
|
|
|
// for each set of cutting instructions for this material
|
|
matCutConfig.forEach((instruction, i) => {
|
|
// for each piece that should be cut
|
|
for (let c = 0; c < instruction.cut; c++) {
|
|
const dupPartName = `cut.${pattern.activePart}.${material}_${c + i + 1}`
|
|
|
|
// make a new part that will follow these cutting instructions
|
|
pattern.addPart({
|
|
name: dupPartName,
|
|
from: activePartConfig,
|
|
draft: ({ part, macro, utils }) => {
|
|
part.attributes.remove('transform')
|
|
|
|
// if they shouldn't be identical, flip every other piece
|
|
if (!instruction.identical && c % 2 === 1) {
|
|
part.attributes.add(
|
|
'transform',
|
|
grainAngle === 90 ? 'scale(-1, 1)' : 'scale(1, -1)'
|
|
)
|
|
}
|
|
|
|
macro('handleFoldAndGrain', {
|
|
partCutlist,
|
|
instruction,
|
|
})
|
|
|
|
// combine the transforms
|
|
const combinedTransform = utils.combineTransforms(
|
|
part.attributes.getAsArray('transform')
|
|
)
|
|
part.attributes.set('transform', combinedTransform)
|
|
|
|
return part
|
|
},
|
|
})
|
|
|
|
// add it to the only list if there is one
|
|
addToOnly(pattern, dupPartName)
|
|
}
|
|
})
|
|
},
|
|
},
|
|
macros: {
|
|
...pluginMirror.macros,
|
|
// handle mirroring on the fold and rotating to sit along the grain or bias
|
|
handleFoldAndGrain: ({ partCutlist, instruction }, { points, macro }) => {
|
|
// get the grain angle for the part for this set of instructions
|
|
const grainSpec = partCutlist.grain
|
|
? partCutlist.grain + (instruction.bias ? 45 : 0)
|
|
: undefined
|
|
// if the part has cutonfold instructions
|
|
if (partCutlist.cutOnFold) {
|
|
// if we're not meant to igore those instructions, mirror on the fold
|
|
if (!instruction.ignoreOnFold) macro('mirrorOnFold', { fold: partCutlist.cutOnFold })
|
|
// if we are meant to ignore those instructions, but there's a grainline
|
|
else if (grainSpec !== undefined) {
|
|
// replace the cutonfold with a grainline
|
|
macro('grainline', { from: points.cutonfoldVia1, to: points.cutonfoldVia2 })
|
|
macro('cutonfold', false)
|
|
}
|
|
}
|
|
|
|
// if there's a grain angle, rotate the part to be along it
|
|
macro('rotateToGrain', { bias: instruction.bias, grainSpec })
|
|
},
|
|
// mirror the part across the line indicated by cutonfold
|
|
mirrorOnFold: ({ fold }, { paths, snippets, macro, points, utils, Point }) => {
|
|
// get all the paths to mirror
|
|
const mirrorPaths = []
|
|
for (const p in paths) {
|
|
// skip ones that are hidden
|
|
if (!paths[p].hidden && !p.match(avoidRegx)) mirrorPaths.push(p)
|
|
}
|
|
|
|
// store all the points to mirror
|
|
const mirrorPoints = []
|
|
// store snippets by type so we can re-sprinkle later
|
|
const snippetsByType = {}
|
|
// for each snippet
|
|
let anchorNames = 0
|
|
for (var s in snippets) {
|
|
const snip = snippets[s]
|
|
// don't mirror these ones
|
|
if (['logo'].indexOf(snip.def) > -1) continue
|
|
|
|
// get or make an array for this type of snippet
|
|
snippetsByType[snip.def] = snippetsByType[snip.def] || []
|
|
|
|
// put the anchor on the list to mirror
|
|
const anchorName = `snippetAnchors_${anchorNames++}`
|
|
points[anchorName] = new Point(snip.anchor.x, snip.anchor.y)
|
|
mirrorPoints.push(anchorName)
|
|
snippetsByType[snip.def].push(`${prefix}${utils.capitalize(anchorName)}`)
|
|
}
|
|
|
|
// mirror
|
|
macro('mirror', {
|
|
paths: mirrorPaths,
|
|
points: mirrorPoints,
|
|
mirror: fold,
|
|
prefix,
|
|
})
|
|
|
|
// sprinkle the snippets
|
|
for (var def in snippetsByType) {
|
|
macro('sprinkle', {
|
|
snippet: def,
|
|
on: snippetsByType[def],
|
|
})
|
|
}
|
|
},
|
|
/**
|
|
* rotate the part so that it is oriented properly with regard to the fabric grain
|
|
* if the part should be on the bias, this rotates the part to lie on the bias
|
|
* while keeping the grainline annotation along the grain
|
|
*/
|
|
rotateToGrain: ({ bias, grainSpec }, { part, paths, points, Point }) => {
|
|
// the amount to rotate is the difference between this part's grain angle (as drafted) and the fabric's grain angle
|
|
let toRotate = grainSpec === undefined ? 0 : grainAngle + grainSpec
|
|
// don't over rotate
|
|
toRotate = toRotate % 180
|
|
if (toRotate < 0) toRotate += 180
|
|
// if there's no difference, don't rotate
|
|
if (toRotate === 0) return
|
|
|
|
if (paths.grainline && bias) {
|
|
const pivot = points.grainlineFrom || new Point(0, 0)
|
|
paths.grainline.ops.forEach((op) => {
|
|
opTypes.forEach((t) => {
|
|
if (op[t]) op[t] = op[t].rotate(45, pivot)
|
|
})
|
|
})
|
|
}
|
|
|
|
part.attributes.add('transform', `rotate(${toRotate})`)
|
|
},
|
|
},
|
|
}
|
|
}
|