LayerCommand.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Model.h>
#include <NDEVR/Layer.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/DesignObjectLookup.h>
namespace NDEVR
{
    class SetLayerCommand : public DesignCommand
    {
    public:
        SetLayerCommand(UUID layer)
            : DesignCommand()
            , m_layer(layer)
        {
        }

        virtual StringView icon() const override
        {
            return "new";
        }

        virtual TranslatedString name() const override
        {
            return _t("Set Layer");
        }

        virtual void execute(DesignObjectLookup* lookup) override
        {
            WLock lock(lookup->writeLock());
            m_models_to_set.setUnique();
            m_original_layers.setSize(m_models_to_set.size());
            lib_assert(IsInvalid(m_layer) || lookup->hasLayerID(m_layer, true), "Bad layer");
            for (uint04 i = 0; i < m_models_to_set.size(); i++)
            {
                Model model = lookup->model(m_models_to_set[i]);
                if (!model.isValid())
                    continue;
                UUID scene_id = model.getScene().get<NDPO::guid>();
                Model layer;
                if (is_undo)
                {
                    if (IsValid(m_original_layers[i]))
                        layer = lookup->layer(m_original_layers[i], scene_id, true);
                }
                else
                {
                    Model old_layer = model.directLayer();
                    if(old_layer.isValid())
                        m_original_layers[i] = old_layer.get<NDPO::guid>();
                    else
                        m_original_layers[i] = Constant<UUID>::Invalid;
                    if (IsValid(m_layer))
                    {
                        lookup->ensureLayerExistsInScene(m_layer, scene_id);
                        layer = lookup->layer(m_layer, scene_id, true);
                    }
                }
                if (layer.isValid())
                    model.setLayer(layer);
                else
                    model.clearLayer();
                model.updateModifiedTime();
            }
        }

        virtual bool addTarget(UUID target_id) override { m_models_to_set.add(target_id); return true; }
    public:
        UUID m_layer; 
        Buffer<UUID> m_models_to_set; 
        Buffer<UUID> m_original_layers; 
    };
}