class MhSnapperSpreadToolAnimation

Removed redundant method selection(). It has been replaced with Animation.getSelection().

Removed: public AnimationSelection selection()
Replacement: public AnimationSelection getSelection()

class MhEngineEntryBase

Added default engine as argument when calling below method.

 Old: public MhEngineConstructionEntry toConstructionEntry()
 New: public MhEngineConstructionEntry toConstructionEntry(MhEngine engine=null)

class MhSystemConfigurationItem

Added new argument to rebuildProp and rebuildProps so that we can choose which rebuildFlag to use instead of always using diffRebuildProps.domain.

Old: extend public void rebuildProp(str k) {
New: extend public void rebuildProp(str k, diffRebuildProps rebuildFlag=diffRebuildProps.domain) {

Old: extend public void rebuildProps(str[] keys) {
New: extend public void rebuildProps(str[] keys, diffRebuildProps rebuildFlag=diffRebuildProps.domain) {

class MhEngineEntryBase

Removed the method sortedChildren(MhEngine engine, function(MhEngineEntry, MhEngineEntry, Object):int sortFunc), use sortedChildren(MhEngine engine, function(MhEngineEntry, MhEngineEntry, Object):int sortFunc, Object arg=null) instead.

public class MhEngineEntryBase : abstract, unstreamable {
    Removed: extend public MhEngineEntry[] sortedChildren(MhEngine engine, function(MhEngineEntry, MhEngineEntry, Object):int sortFunc) : deprecated {
}

class MhEngineConstructionEntry

Removed the following deprecated constructors.

public class MhEngineConstructionEntry extends MhEngineSnapperEntry : inherit constructors {
    Removed: public constructor(box b, Transform t, LayerSet classification=null) : deprecated {
    Removed: public constructor(box b, LayerSet classification) : deprecated {
}

class EngineVisualiserDialog

Removed the following deprecated fields and methods.

private class EngineVisualiserDialog extends DialogWindow {
    Removed: public TreeView leftTreeView : deprecated;
    Removed: public REDRenderView3D preview3D : deprecated;
    Removed: extend public void updateEntriesInTreeView() : deprecated {}
    Removed: extend public void updateGraphics() : deprecated {}
}

Moved functions

The following functions have been moved from abstract.materialHandling.storage.engine to abstract.materialHandling.

Moved: public MhEngineEntry[] mhImportedChildren(MhEngineEntry entry, MhEngine engine) {
Moved: public MhEngineEntry[] mhPopulatedChildren(MhEngineEntry entry, MhEngine engine) {
Moved: public int mhEntryXPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

The following functions have been moved from abstract.materialHandling.storage.engine to abstract.materialHandling.engine.

Moved: public MhEngineEntry->double mhEntryXPositions(MhEngineEntry[] entries, bool unmodify) {
Moved: public MhEngineEntry[] mhXSortedEntries(MhEngineEntry[] entries, bool unmodify) {
Moved: public MhEngineEntry->double mhEntryYPositions(MhEngineEntry[] entries, bool unmodify) {
Moved: public MhEngineEntry[] mhYSortedEntries(MhEngineEntry[] entries, bool unmodify) {

The following functions have been added.

New: public int mhEntryPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
New: public int mhEntryYPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

The following function has been removed from abstract.materialHandling.storage.engine. Use the functions listed instead.

Removed: public int entryYPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryYPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

The following functions have been removed, use the replacement functions listed instead.

Removed: public MhEngineEntry[] mhAbsImportedChildren(MhEngineEntry entry, MhEngine engine) {
Use: public MhEngineEntry[] mhImportedChildren(MhEngineEntry entry, MhEngine engine) {

Removed: public MhEngineEntry[] mhAbsPopulatedChildren(MhEngineEntry entry, MhEngine engine) {
Use: public MhEngineEntry[] mhPopulatedChildren(MhEngineEntry entry, MhEngine engine) {

Removed: public int mhAbsEntryRootXYZPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryRootXYZPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

Removed: public int mhAbsEntryFuncRunOrderSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryFuncRunOrderSort(MhEngineEntry a, MhEngineEntry b, Object env) {

Removed: public int mhAbsEntryXPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryXPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

Removed: public int mhAbsEntryPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

Removed: public int mhAbsEntryYPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {
Use: public int mhEntryYPosSort(MhEngineEntry a, MhEngineEntry b, Object env) {

Removed: public MhEngineEntry->double mhAbsEntryXPositions(MhEngineEntry[] entries, bool unmodify) {
Use: public MhEngineEntry->double mhEntryXPositions(MhEngineEntry[] entries, bool unmodify) {

Removed: public MhEngineEntry[] mhAbsXSortedEntries(MhEngineEntry[] entries, bool unmodify) {
Use: public MhEngineEntry[] mhXSortedEntries(MhEngineEntry[] entries, bool unmodify) {

Removed: public MhEngineEntry->double mhAbsEntryYPositions(MhEngineEntry[] entries, bool unmodify) {
Use: public MhEngineEntry->double mhEntryYPositions(MhEngineEntry[] entries, bool unmodify) {

Removed: public MhEngineEntry[] mhAbsYSortedEntries(MhEngineEntry[] entries, bool unmodify) {
Use: public MhEngineEntry[] mhYSortedEntries(MhEngineEntry[] entries, bool unmodify) {

LinkedNeighbors interface changes

New optional arguments are added to these functions in order to reduce number of set and seq created.

Old: public (Snapper{}) endNeighbors(MhSnapper this, LayerSet ls=null) {
New: public (Snapper{}) endNeighbors(MhSnapper this, LayerSet ls=null, Snapper{} snappers=null) {

Old: public (Snapper{}) nextNeighbors(MhSnapper this, LayerSet ls=null) {
New: public (Snapper{}) nextNeighbors(MhSnapper this, LayerSet ls=null, Snapper{} snappers=null) {

Old: public (Snapper{}) prevNeighbors(MhSnapper this, LayerSet ls=null) {
New: public (Snapper{}) prevNeighbors(MhSnapper this, LayerSet ls=null, Snapper{} snappers=null) {

Old: public (Snapper{}) linkedNeighbors(MhSnapper this, LayerSet ls=null) {
New: public (Snapper{}) linkedNeighbors(MhSnapper this, LayerSet ls=null, Snapper{} snappers=null) {

Bound with children functions and methods

There were various different functions and methods to retrieve bounds of snappers including their children bound. We have reduce the number of interfaces by combining them where possible.

We have consolidated the following MhSnapper methods into one. Replace all calls to childrenBound(bool recursive=true), childrenShapeLocalBound(symbol[] symbols=null), and childrenShapeBound(symbol[] symbols=null, SnapperFilter filter=null) with childrenShapeBound(symbol[] symbols=null, SnapperFilter filter=null, bool recursive=false).

Note that the old childrenBound(bool recursive=true) method has recursive's default argument set to true while the new method has recursive's default argument set to false, so any calls to childrenBound() should be replaced with childrenShapeBound(recursive=true).

Old:
public class MhSnapper extends Snapper {

    /**
     * Children bound.
     */
    extend public box childrenBound(bool recursive=true) {
        box bc();
        bool empty=true;
        
        forChildren(MhSnapper c in this) {
            box b = c.localBound();
            b.transform(c.rot == 0deg ? Transform(c.pos) : Transform(c.pos, c.rot));
            
            if (b != box0) {
                if (empty) bc = b;
                else bc += b;
                empty = false;
            }
            
            if (recursive) bc += c.childrenBound(..);
        }
        
        return bc;
    }


    /**
     * Children shape local bound.
     */
    extend public box childrenShapeLocalBound(symbol[] symbols=null) {
        box bc();
        bool empty=true;

        forChildren(MhSnapper c in this) {
            box b = c.shapeBound(symbols);

            if (b != box0) {
                if (empty) bc = b;
                else bc += b;
                empty = false;
            }
        }

        if (MhSnapperBehavior b = snapperInfosBehavior()) {
            for (info in b.infos) {
                info.shape.?setOwner(this);

                box b = info.shape.?localBound(symbols);
                if (b != box0) {
                    if (empty) bc = b;
                    else bc += b;
                }
                info.shape.?setOwner(null);
            }
        }
        
        return bc;
    }


    /**
     * Children shape bound.
     */
    extend public box childrenShapeBound(symbol[] symbols=null, SnapperFilter filter=null) {
        box bc();
        bool empty=true;

        //for (MhSnapper c in children) {
        forChildren(MhSnapper c in this) {
            if (filter and !filter.accepts(c)) continue;
            box b = c.shapeBound(symbols);

            if (b != box0) {
                b.transform(mhTransform(c.pos, c.rot));
                if (empty) bc = b;
                else bc += b;
                empty = false;
            }
        }
        
        for (info in snapperInfos()) {
            try {
                info.shape.?setOwner(this);
                
                box b = info.shape.?localBound(symbols);
                if (b != box0) {
                    b.transform(mhTransform(info.pos, info.rot));
                    if (empty) bc = b;
                    else bc += b;
                    empty = false;
                }
            } finally {
                info.shape.?setOwner(null);
            }
        }
        
        return bc;
    }
}

New:
public class MhSnapper extends Snapper {

    /**
     * Children shape bound.
     */
    extend public box childrenShapeBound(symbol[] symbols=null, SnapperFilter filter=null, bool recursive=false) {
        box bc();
        bool empty = true;

        forChildren(MhSnapper c in this) {
            if (filter and !filter.accepts(c)) continue;
            box b = c.shapeBound(symbols);

            if (b.volume > 0) {
                b.transform(mhTransform(c.pos, c.rot));
                if (empty) bc = b;
                else bc += b;
                empty = false;
            }
            
            if (recursive) {
                box cbc = c.childrenShapeBound(..);
                if (cbc.volume > 0) {
                    cbc.transform(mhTransform(c.pos, c.rot));
                    if (empty) bc = cbc;
                    else bc += cbc;
                    empty = false;
                }
            }
        }

        for (info in snapperInfos()) {
            try {
                info.shape.?setOwner(this);
                box b = info.shape.?localBound(symbols);
                if (b.volume > 0) {
                    b.transform(mhTransform(info.pos, info.rot));
                    if (empty) bc = b;
                    else bc += b;
                    empty = false;
                }
            } finally {
                info.shape.?setOwner(null);
            }
        }

        return bc;
    }
}

Important to note is that we have also made a behavioral change. Previously in localBoundWithChildren(MhSnapper owner, symbol[] symbols=null, SnapperFilter filter=null) and shapeBoundWithChildren(MhSnapper owner, symbol[] symbols, SnapperFilter filter=null) we would always include the result of the children bounds regardless of what they were. Now in both of these functions, we only include the children bounds if their bound volumes are not zero. This is to fix the issue where we could include empty bounds into the resultant bound. Now you may even have a resultant bound that does not include (0, 0, 0) within it. Be aware of this as there may be some existing logic in your codebase that relied on this false positive behavior previously, you can now be more specific in the bounds you include.

Aside from that, we have updated localBoundWithChildren and shapeBoundWithChildren to use the newly introduced MhSnapper.childrenShapeBound(symbol[] symbols=null, SnapperFilter filter=null, bool recursive=false) method.

Old:
/**
 * Get localbound with children
 */
public box localBoundWithChildren(MhSnapper owner, symbol[] symbols=null, SnapperFilter filter=null) {

  
    if (!owner) return box();

    box bc(); bool first = true;
    if (!filter or filter.accepts(owner)) {
        bc = owner.shapeBound(symbols);
        bc += owner.childrenShapeBound(symbols);
        first = false;
    }
    
    forChildren(MhSnapper child in owner) {
        if (child.includeChildrenInLocalBound) {
            box b = localBoundWithChildren(child, symbols, filter);
            Transform t = mhTransform(child.pos, child.rot);
            b = b.transformed(t);
            bc = first ? b : bc + b;
            if (first) first = false;
        }
    }
    
    return bc;
}


/**
 * Get shape bound with children
 */
public box shapeBoundWithChildren(MhSnapper owner, symbol[] symbols, SnapperFilter filter=null) {
    if (!owner) return box();

    box bc(); bool first = true;
    if (!filter or filter.accepts(owner)) {
        bc = owner.shapeBound(symbols);
        bc += owner.childrenShapeBound(symbols, filter); //say what
        first = false;
    }
    
    forChildren(MhSnapper child in owner) {
        box b = shapeBoundWithChildren(child, symbols, filter);
        Transform t = mhTransform(child.pos, child.rot);
        b = b.transformed(t);
        bc = first ? b : bc + b;
        if (first) first = false;
    }
    
    return bc;
}

New:
/**
 * Localbound with children.
 * This differ from shapeBoundWithChildren as this recursiveness controlled by `includeChildrenInLocalBound`.
 */
public box localBoundWithChildren(MhSnapper owner, symbol[] symbols=null, SnapperFilter filter=null) {
    if (filter and !filter.accepts(owner)) return box();
    if (!owner) return box();

    box bc = owner.shapeBound(symbols);
    box b = localBoundWithChildrenRe(..);
    if (b.volume > 0) bc += b;

    return bc;
}
private box localBoundWithChildrenRe(MhSnapper owner, symbol[] symbols, SnapperFilter filter) {
    if (filter and !filter.accepts(owner)) return box();
    if (!owner.includeChildrenInLocalBound) return box();

    box bc = owner.childrenShapeBound(symbols, filter);
    forChildren(MhSnapper c in owner) {
        box b = localBoundWithChildrenRe(c, -..);
        if (b.volume > 0) {
            b.transform(mhTransform(c.pos, c.rot));
            bc += b;
        }
    }

    return bc;
}


New:
/**
 * Get shape bound with children.
 * Always recursive.
 */
public box shapeBoundWithChildren(MhSnapper owner, symbol[] symbols=null, SnapperFilter filter=null) {
    if (!owner) return box();

    box bc();
    
    if (!filter and filter.accepts(owner)) {
        bc = owner.shapeBound(symbols);
        
        box cbc = owner.childrenShapeBound(symbols, filter, recursive=true);
        if (cbc.volume > 0) bc += cbc;
    }

    return bc;
}

class MhEngineSnapperEntry

The toConstructionEntry method now also ensures the imported props of the snapper entry are transferred over to the newly created construction entry.

    /**
     * To construction entry.
     */
    public MhEngineConstructionEntry toConstructionEntry(MhEngine engine=null) {
        MhEngineConstructionEntry res = createConstructionEntry();
        if (snapper) {
            ...
            // Transfer import props to be part of construction entry.
            if (!engine) engine = snapper.engine;
            var env = engine.?engineEnv();
            for (k, _ in snapper.importProps(engine)) {
                if (k in [mhPrevNeighborsKey, mhNextNeighborsKey]) continue;
                Object v = env.getProp(snapper, k);
                if (v) res.putSnapperImportProp(k, v);
            }
        }
        
        return res;
    }

MhSnapperFilter changes

In accepts(Snapper snapper) method, if the childDepth is not the same, it will instantly return false.

    public bool accepts(Snapper snapper) {
        if (owner.childDepth != snapper.childDepth) return false;
        ...
    }

Change in logic for post engine run and appending engine functions

We are moving away from utilizing post engine run functions. Previously when an engine is currently running functions and a new engine function was appended during this (particularly during the export function), it would have been appended to the same engine run that was being executed. This new engine function would then be executed during the post engine run. There was an issue where with a multi-assortment setup during the export function, new engine functions could be appended to the wrong engine run with the wrong assortment. Those functions would not be executed due to the mismatch of assortments.

We have now updated the logic such that when an engine is running, newly appended engine functions would be appended into a new engine run instead of the currently executing engine run. The current exception to this would be for the animation export MhSystemAnimationExportFunction where we still allow new engine functions to be appended and executed during the post engine run.

public class MhEngine extends CxEngine {

Old:
    /**
     * Engine run
     * Return a current run to append functions to it
     */
    extend public MhEngineRun engineRun(MhEngineRun currentRun, MhEngineRun[] currentList, MhAssortment a) {
        MhEngineRun run = null;

        if (runByRegistrationOrder) {
           if (currentRun) return currentRun;
           if (!run) for (r in currentList) { run = r; break; }
        } else {
            if (currentRun and currentRun.assortment == a) run = currentRun;
            if (!run) for (r in currentList) if (r.assortment == a) { run = r; break; }
        }
        return run;
    }


New:
    /**
     * Engine run
     * Return a current run to append functions to it
     */
    extend public MhEngineRun engineRun(MhEngineRun currentRun, MhEngineRun[] currentList, MhAssortment a) {
        if (runByRegistrationOrder) {
           if (currentRun) return currentRun;
           for (r in currentList) { return r; }
        } else {
            if (currentRun.?assortment == a and currentRun.?allowFuncReg) return currentRun;
            for (r in currentList) {
                if (r.assortment == a and r != currentRun) {
                    return r;
                }
            }
        }

        return null;
    }
}


public class MhEngineManager extends CoreObject {

Old:
    /**
     * Register run.
     */
    extend public void register(MhEngine engine, MhEngineFunctionRun func) {
        ...
        
        MhEngineRun run = engine.engineRun(currentRun, list, a);

        if (!run) {
            if (run = createEngineRun(a)) {
                run.assortment = a;
                
                init? list();
                list << run;
                engineRunList.put(engine, list);
            }
        }
        
        run.?append(engine, func);
    }


New:
    /**
     * Register run.
     */
    extend public void register(MhEngine engine, MhEngineFunctionRun func) {
        ...

        MhEngineRun run = engine.engineRun(currentRun, list, a);
        if (!run) {
            if (run = createEngineRun(a)) {
                if (currentRun) run.postRun = currentRun.postRun + 1;
                devassert(run.postRun <= 5) {
                    pln("Exceeding number of recursion allowed"); return;
                }
                
                run.assortment = a;
                init? list();
                
                int index = -1;
                if (currentRun) index = list.indexOf(currentRun);
                if (index >= 0) list.insert(index + 1, run);
                else list << run;
                
                engineRunList.put(engine, list);
            }
        }
        
        run.?append(engine, func);
    }
}

public class MhEngineRun {

New:
    /**
     * Temporarily allow same run function register.
     */
    public bool allowFuncReg;
}