commands/shape_factory.cpp - initial - spivag/command_occ

commands/shape_factory.cpp
410 строк15 KB
spivag
Запрос на слияние 'c3d_sdk_removal' (#2) из c3d_sdk_removal в initial
16 апр 2026, 15:34
16 апр 2026, 15:34e04e876
#include "shape_factory.h"

// Конкретные реализации фабрик
class ConcreteExtrusionSolidBuilder : public ExtrusionSolidBuilder
{
public:
  std::shared_ptr< BuildExtrusionSolid > build(
      SweptEntity::Sketch2D const& profile,
      R3::Vector const& direction,
      BuildExtrusionSolid::DepthAngleForward const& positiveSweptDepthAngle ) const override
  {
    return std::make_shared< BuildExtrusionSolid >( profile, direction, positiveSweptDepthAngle );
  }

  std::shared_ptr< BuildExtrusionSolid > build(
      SweptEntity::Sketch2D const& profile,
      R3::Vector const& direction,
      BuildExtrusionSolid::DepthAngleBackward const& negativeSweptDepthAngle ) const override
  {
    return std::make_shared< BuildExtrusionSolid >( profile, direction, negativeSweptDepthAngle );
  }

  std::shared_ptr< BuildExtrusionSolid > build(
      SweptEntity::Sketch2D const& profile,
      R3::Vector const& direction,
      BuildExtrusionSolid::DepthAngleForward const& positiveSweptDepthAngle,
      BuildExtrusionSolid::DepthAngleBackward const& negativeSweptDepthAngle ) const override
  {
    return std::make_shared< BuildExtrusionSolid >(
        profile, direction, positiveSweptDepthAngle, negativeSweptDepthAngle );
  }
};

class ConcreteRevolutionSolidBuilder : public RevolutionSolidBuilder
{
public:
  std::shared_ptr< BuildRevolutionSolid > build( SweptEntity::Sketch2D const& profile,
                                                 R3::Axis const& axis,
                                                 R1::AngleCcw< R1::Angle02pi > const& angleCcw ) const override
  {
    return std::make_shared< BuildRevolutionSolid >( profile, axis, angleCcw );
  }

  std::shared_ptr< BuildRevolutionSolid > build( SweptEntity::Sketch2D const& profile,
                                                 R3::Axis const& axis,
                                                 R1::AngleCw< R1::Angle02pi > const& angleCw ) const override
  {
    return std::make_shared< BuildRevolutionSolid >( profile, axis, angleCw );
  }

  std::shared_ptr< BuildRevolutionSolid > build( SweptEntity::Sketch2D const& profile,
                                                 R3::Axis const& axis,
                                                 R1::AngleCcw< R1::Angle02pi > const& angleCcw,
                                                 R1::AngleCw< R1::Angle02pi > const& angleCw ) const override
  {
    return std::make_shared< BuildRevolutionSolid >( profile, axis, angleCcw, angleCw );
  }
};

class ConcreteSectionsBasedSolidBuilder : public SectionsBasedSolidBuilder
{
public:
  std::shared_ptr< BuildSolidBySections > build( BuildSolidBySections::Ruled const& ruled ) const override
  {
    return std::make_shared< BuildSolidBySections >( ruled );
  }

  std::shared_ptr< BuildSolidBySections > build( BuildSolidBySections::Loft const& loft,
                                                 std::optional< WallThickness > const& wallThickness ) const override
  {
    return std::make_shared< BuildSolidBySections >( loft, wallThickness );
  }
};

class ConcreteChamferBuilder : public ChamferBuilder
{
public:
  std::shared_ptr< BuildChamfer > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                         BuildChamfer::Symmetric const& symmetricChamferParametes ) const override
  {
    return std::make_shared< BuildChamfer >( originalBrep, symmetricChamferParametes );
  }

  std::shared_ptr< BuildChamfer > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                         BuildChamfer::NonSymmetric const& nonSymmetricChamferParametes ) const override
  {
    return std::make_shared< BuildChamfer >( originalBrep, nonSymmetricChamferParametes );
  }
};

class ConcreteOffsetFacesBuilder : public OffsetFacesBuilder
{
public:
  std::shared_ptr< BuildOffsetFaces > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                             std::shared_ptr< IBrepFaceHandle > const& faceToOffset,
                                             double offsetDistance ) const override
  {
    return std::make_shared< BuildOffsetFaces >( originalBrep, faceToOffset, offsetDistance );
  }
};

class ConcreteThinWallViaFaceRemoveBuilder : public ThinWallViaFaceRemoveBuilder
{
public:
  std::shared_ptr< BuildWallViaFaceRemove > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                                   std::vector<std::shared_ptr< IBrepFaceHandle >> const& facesToRemove,
                                                   R1::ForwardDistance outherThickness ) const override
  {
    return std::make_shared< BuildWallViaFaceRemove >(
        originalBrep, facesToRemove, outherThickness.m_distance.m_distance, 0.0 );
  }

  std::shared_ptr< BuildWallViaFaceRemove > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                                   std::vector<std::shared_ptr< IBrepFaceHandle >> const& facesToRemove,
                                                   R1::BackwardDistance innerThickness ) const override
  {
    return std::make_shared< BuildWallViaFaceRemove >(
        originalBrep, facesToRemove, 0.0, innerThickness.m_distance.m_distance );
  }

  std::shared_ptr< BuildWallViaFaceRemove > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                                   std::vector<std::shared_ptr< IBrepFaceHandle >> const& facesToRemove,
                                                   R1::ForwardDistance outherThickness,
                                                   R1::BackwardDistance innerThickness ) const override
  {
    return std::make_shared< BuildWallViaFaceRemove >(
        originalBrep, facesToRemove, outherThickness.m_distance.m_distance, innerThickness.m_distance.m_distance );
  }
};

class ConcreteFilletBuilder : public FilletBuilder
{
public:
  std::shared_ptr< BuildFillet > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                        BuildFillet::Symmetric const& symmetricFilletParametes ) const override
  {
    return std::make_shared< BuildFillet >( originalBrep, symmetricFilletParametes, std::optional< BlendMate >{} );
  }

  std::shared_ptr< BuildFillet > build( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                        BuildFillet::NonSymmetric const& nonSymmetricFilletParametes ) const override
  {
    return std::make_shared< BuildFillet >( originalBrep, nonSymmetricFilletParametes, std::optional< BlendMate >{} );
  }
};

class ConcreteTransformedCloneBuilder : public TransformedCloneBuilder
{
public:
  std::shared_ptr< BuildTransformedClone > build( std::shared_ptr< IShapeBuilder > const& originalShape,
                                                  R3::Placement const& location ) const override
  {
    return std::make_shared< BuildTransformedClone >( originalShape, location );
  }

  std::shared_ptr< BuildTransformedClone > build( std::shared_ptr< IShapeBuilder > const& originalShape,
                                                  R3::Transform const& transformation ) const override
  {
    return std::make_shared< BuildTransformedClone >( originalShape, transformation );
  }
};

class ConcreteBlockBuilder : public BlockBuilder
{
public:
  std::shared_ptr< BuildBlock > build( BuildBlock::OriginInLeftBackBottomCorner const& dimensions ) const override
  {
    return std::make_shared< BuildBlock >( dimensions );
  }

  std::shared_ptr< BuildBlock > build( BuildBlock::OriginInMiddleBottomFace const& dimensions ) const override
  {
    return std::make_shared< BuildBlock >( dimensions );
  }

  std::shared_ptr< BuildBlock > build( BuildBlock::OriginInMiddleVolume const& dimensions ) const override
  {
    return std::make_shared< BuildBlock >( dimensions );
  }
  std::shared_ptr< BuildBlock > build( BuildBlock::PointsOnDiagonal const& dimensions ) const override
  {
    return std::make_shared< BuildBlock >( dimensions.m_oneCorner, dimensions.m_otherCorner );
  }
};

class ConcreteCylinderBuilder : public CylinderBuilder
{
public:
  std::shared_ptr< BuildCylinder > build( R1::Distance radius,
                                          R1::ForwardDistance height,
                                          R3::Placement const& location ) const override
  {
    return std::make_shared< BuildCylinder >( radius.m_distance, height, location );
  }

  std::shared_ptr< BuildCylinder > build( R1::Distance radius,
                                          R1::BackwardDistance height,
                                          R3::Placement const& location ) const override
  {
    return std::make_shared< BuildCylinder >( radius.m_distance, height, location );
  }

  std::shared_ptr< BuildCylinder > build( R1::Distance radius,
                                          R1::ForwardDistance heightPositive,
                                          R1::BackwardDistance heightNegative,
                                          R3::Placement const& location ) const override
  {
    return std::make_shared< BuildCylinder >( radius.m_distance, heightPositive, heightNegative, location );
  }
};

class ConcreteConeCommandBuilder : public ConeBuilder
{
public:
  std::shared_ptr< BuildCone > build( BuildCone::CreateByRadiaHeight const& radiaHeight ) const override
  {
    return std::make_shared< BuildCone >( radiaHeight );
  }

  std::shared_ptr< BuildCone > build( BuildCone::CreateByRadiaAngle const& radiaAngle ) const override
  {
    return std::make_shared< BuildCone >( radiaAngle );
  }
};

class ConcreteTorusBuilder : public TorusBuilder
{
public:
  std::shared_ptr< BuildTorus > build( double majorRadius,
                                       double minorRadius,
                                       R3::Placement const& location,
                                       BuildTorus::Shape torusType ) const override
  {
    return std::make_shared< BuildTorus >( majorRadius, minorRadius, location, torusType );
  }
};

class ConcreteBooleanOperationBuilder : public BooleanOperationBuilder
{
public:
  std::shared_ptr< BooleanOperation > build( const std::shared_ptr< IShapeBuilder >& firstSolid,
                                             const std::shared_ptr< IShapeBuilder >& secondSolid,
                                             BooleanOperation::Operation operationType ) const override
  {
    return std::make_shared< BooleanOperation >( firstSolid, secondSolid, operationType );
  }
};

// Главная фабрика
class ShapeFactory : public IShapeFactory
{
public:
  std::shared_ptr< TransformedCloneBuilder > TransformedClone() const override
  {
    if ( !m_transformedCloneBuilder )
    {
      m_transformedCloneBuilder = std::make_shared< ConcreteTransformedCloneBuilder >();
    }
    return m_transformedCloneBuilder;
  }

  std::shared_ptr< BooleanOperationBuilder > Boolean() const override
  {
    if ( !m_booleanOperationBuilder )
    {
      m_booleanOperationBuilder = std::make_shared< ConcreteBooleanOperationBuilder >();
    }
    return m_booleanOperationBuilder;
  }

private:
  mutable std::shared_ptr< TransformedCloneBuilder > m_transformedCloneBuilder{};
  mutable std::shared_ptr< BooleanOperationBuilder > m_booleanOperationBuilder{};
};

// Главная фабрика
class BrepFactory : public IBrepFactory
{
public:
  std::shared_ptr< ExtrusionSolidBuilder > Extrusion() const override
  {
    if ( !m_extruxionBrepBuilder )
    {
      m_extruxionBrepBuilder = std::make_shared< ConcreteExtrusionSolidBuilder >();
    }

    return m_extruxionBrepBuilder;
  }

  std::shared_ptr< RevolutionSolidBuilder > Revolution() const override
  {
    if ( !m_revolutionBrepBuilder )
    {
      m_revolutionBrepBuilder = std::make_shared< ConcreteRevolutionSolidBuilder >();
    }
    return m_revolutionBrepBuilder;
  }

  std::shared_ptr< SectionsBasedSolidBuilder > Sections() const override
  {
    if ( !m_sectionsBrepBuilder )
    {
      m_sectionsBrepBuilder = std::make_shared< ConcreteSectionsBasedSolidBuilder >();
    }
    return m_sectionsBrepBuilder;
  }

  std::shared_ptr< ChamferBuilder > Chamfer() const override
  {
    if ( !m_chamferBrepBuilder )
    {
      m_chamferBrepBuilder = std::make_shared< ConcreteChamferBuilder >();
    }
    return m_chamferBrepBuilder;
  }

  std::shared_ptr< OffsetFacesBuilder > OffsetFaces() const override
  {
    if ( !m_offsetFacesBrepBuilder )
    {
      m_offsetFacesBrepBuilder = std::make_shared< ConcreteOffsetFacesBuilder >();
    }
    return m_offsetFacesBrepBuilder;
  }

  std::shared_ptr< ThinWallViaFaceRemoveBuilder > ThinWallViaFaceRemove() const override
  {
    if ( !m_offsetFacesBrepBuilder )
    {
      m_offsetWallViaFaceRemoveBuilder = std::make_shared< ConcreteThinWallViaFaceRemoveBuilder >();
    }
    return m_offsetWallViaFaceRemoveBuilder;
  }

  std::shared_ptr< FilletBuilder > Fillet() const override
  {
    if ( !m_filletBrepBuilder )
    {
      m_filletBrepBuilder = std::make_shared< ConcreteFilletBuilder >();
    }
    return m_filletBrepBuilder;
  }

  std::shared_ptr< BlockBuilder > Block() const override
  {
    if ( !m_blockBrepBuilder )
    {
      m_blockBrepBuilder = std::make_shared< ConcreteBlockBuilder >();
    }
    return m_blockBrepBuilder;
  }

  std::shared_ptr< CylinderBuilder > Cylinder() const override
  {
    if ( !m_cylinderBrepBuilder )
    {
      m_cylinderBrepBuilder = std::make_shared< ConcreteCylinderBuilder >();
    }
    return m_cylinderBrepBuilder;
  }

  std::shared_ptr< ConeBuilder > Cone() const override
  {
    if ( !m_coneBrepBuilder )
    {
      m_coneBrepBuilder = std::make_shared< ConcreteConeCommandBuilder >();
    }
    return m_coneBrepBuilder;
  }

  std::shared_ptr< TorusBuilder > Torus() const override
  {
    if ( !m_torusBrepBuilder )
    {
      m_torusBrepBuilder = std::make_shared< ConcreteTorusBuilder >();
    }
    return m_torusBrepBuilder;
  }

private:
  mutable std::shared_ptr< ExtrusionSolidBuilder > m_extruxionBrepBuilder{};
  mutable std::shared_ptr< RevolutionSolidBuilder > m_revolutionBrepBuilder{};
  mutable std::shared_ptr< ChamferBuilder > m_chamferBrepBuilder{};
  mutable std::shared_ptr< OffsetFacesBuilder > m_offsetFacesBrepBuilder{};
  mutable std::shared_ptr< ThinWallViaFaceRemoveBuilder > m_offsetWallViaFaceRemoveBuilder{};
  mutable std::shared_ptr< FilletBuilder > m_filletBrepBuilder{};
  mutable std::shared_ptr< BlockBuilder > m_blockBrepBuilder{};
  mutable std::shared_ptr< CylinderBuilder > m_cylinderBrepBuilder{};
  mutable std::shared_ptr< ConeBuilder > m_coneBrepBuilder{};
  mutable std::shared_ptr< SectionsBasedSolidBuilder > m_sectionsBrepBuilder{};
  mutable std::shared_ptr< TorusBuilder > m_torusBrepBuilder{};
};

IBrepFactory& Factory::Brep()
{
  static BrepFactory m_factory;
  return m_factory;
}

IShapeFactory& Factory::Shape()
{
  static ShapeFactory m_shapeFactory;
  return m_shapeFactory;
}

IOpenGLMeshFactory& Factory::OpenGLMesh()
{
  static OpenGLMeshFactory m_meshFactory;
  return m_meshFactory;
}