CADDimensionWriteModifier.h

Go to the documentation of this file.

#pragma once
#include "CAD/Headers/DXFBlockWriter.h"
#if NDEVR_VIEWPORT && NDEVR_MEASURE_MODELS
#include "Design/Headers/MeasurementModels.h"
namespace NDEVR
{
    class Model;
    struct CADGeometryWriter;
    class DXFTableWriteIterator;
    class DXFBlockWriter;
    class CADDistanceWriteModifier : public CADWriteModifier
    {
    public:
        static void WriteDistance(DXFBlockWriter& options, const Matrix<fltp08>& transform, const DistanceMeasureModel& dim, uint04 parent_handle)
        {
            auto iter = options.block_data.find(dim.uuid());
            if (iter == options.block_data.end())
                return;
            DimAlignedData dim_data;
            FillOutData(dim, dim_data);
            dim_data.color_info = GenerateDXFColorInfo(dim, false, false);
            options.writer.cleanupCADName(dim_data.layer);
            dim_data.handle = options.writer.handleManager()->getHandleIndex(dim.uuid());
            dim_data.dimension_block_name = iter.value().name;
            dim_data.parent_handle = parent_handle;
            dim_data.alignment_data = transform * dim.measurementLine();
            dim_data.definition_point = dim_data.alignment_data[B];
            dim_data.text_middle_point = (dim_data.alignment_data[A] + dim_data.alignment_data[B]) / 2.0;
            
            //dim_data.extrusion = orientation.first;
            options.writer.addDimAligned(dim_data);
        }
        bool canHandleBlock(const Model&) final override
        {
            return false;
            //return model.isOfType(DistanceMeasureModel::TypeName());
        }
        ModelIterator::ParseResult handleBlock(const Model& model, DXFTableWriteIterator& options) final override
        {
            BlockData data = options.convertToBlock(model);
            data.handle = options.handle_manager->getHandleIndex(data.name);
            options.handle_manager->setHandleToUUID(model.uuid(), data.handle);
            options.handle_manager->setTransfromCoords(data.handle
                , options.params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform());
            options.block_data.insert({ model.uuid(), data });
            return ModelIterator::ParseResult::e_do_not_parse_children;
        }
        ModelIterator::ParseResult handleBlock(const Model& model, DXFBlockWriter& options) final override
        {
            const BlockData& block = options.block_data.get(model.uuid());
            options.writer.startBlock(block);
 
            DistanceMeasureModel distance(model);
            Matrix<fltp08> transform = options.writer.handleManager()->transfromCoords(block.handle).invert()
                * options.params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform();
            LineData data;
            data.color_info.mode = ColorMode::e_by_block;
            data.layer = block.layer;
 
            FillOutData(model, data);
            data.handle = options.writer.handleManager()->generateTempHandleIndex();
            data.parent_handle = block.handle;
            data.line = transform * distance.measurementLine();
            options.writer.addLine(data);
            options.writer.endBlock(block);
            return ModelIterator::ParseResult::e_continue_parsing;
        }
        bool canHandleInsert(const Model& model) final override
        {
            return model.isOfType(DistanceMeasureModel::TypeName());
        }
        void handleInsert(const Matrix<fltp08>& parent_transform, const Model& model, uint04 parent_handle, DXFBlockWriter& options)  final override
        {
            DistanceMeasureModel distance(model);
            WriteDistance(options, parent_transform, distance, parent_handle);
        }
        void handleInsert(const Matrix<fltp08>&, const Model&, uint04, CADGeometryWriter&) final override
        {
 
        }
    };
}
#endif