WebService / ben-test · Files

import { ref } from 'vue';
import { defineStore } from 'pinia';
import Selection from '@/utility/jsm/Selection';

import ObjectsSelect from '@/utility/jsm/ObjectsControl/ObjectsSelect';
import ObjectsControl from '@/utility/jsm/ObjectsControl/ObjectsControl';
import OrientBottom from '@/utility/jsm/OrientBottom';
import TransformUndoredo from '@/utility/jsm/unredo/TransformUnRedo';
import Measures from '@/utility/jsm/Measures';
import CopyMirror from '@/utility/jsm/CopyMirror';

import DrawMargin from '@/utility/jsm/draw/DrawMargin';
import EditCurve from '@/utility/jsm/EditCurve';
import Sculpt from '@/utility/jsm/meshEditor/meshEdit/Sculpt';
import CutPlaneControl from '@/utility/jsm/CutPlane/CutPlaneControl';
import SectionContour from '@/utility/jsm/SectionContour';
import MarkPointsOnMesh from '@/utility/jsm/MarkPointsOnMesh';

export const useClassFunctionStore = defineStore('class-function', () => {
    const DrawSelectionClass = ref(null);
    const SelectsClass = ref(null);
    const ObjectsControlClass = ref(null);
    const OrientBottomClass = ref(null);
    const TransformUndoredoClass = ref(null);
    const MeasuresClass = ref(null);
    const CopyMirrorClass = ref(null);
    const DrawMarginClass = ref(null);
    const EditCurveClass = ref(null);
    const SculptClass = ref(null);
    const CutPlaneClass = ref(null);
    const SectionContourClass = ref(null);
    const MarkPointsOnMeshClass = ref(null);

    const MarkPointsOnMeshClassInit = ({ camera, scene, domElement }) => {
        if (!MarkPointsOnMeshClass.value) {
            MarkPointsOnMeshClass.value = new MarkPointsOnMesh({ camera, scene, domElement });
        }
    };
    const MarkPointsOnMeshClassDispose = () => {
        MarkPointsOnMeshClass.value.dispose();
        MarkPointsOnMeshClass.value = null;
    };

    const SectionContourClassInit = ({ scene, sectionviewScene }) => {
        if (!SectionContourClass.value) {
            SectionContourClass.value = new SectionContour({ scene, sectionviewScene });
        }
    };

    const CutPlaneClassInit = ({ camera, scene, domElement, control }) => {
        if (!CutPlaneClass.value) {
            CutPlaneClass.value = new CutPlaneControl({ camera, scene, domElement, control });
        }
    };
    const CutPlaneDispose = () => {
        CutPlaneClass.value.dispose();
        CutPlaneClass.value = null;
    };

    const SculptClassInit = ({ camera, scene, domElement }) => {
        if (!SculptClass.value) {
            SculptClass.value = new Sculpt({ camera, scene, domElement });
        }
    };
    const SculptClassDispose = () => {
        SculptClass.value.dispose();
        SculptClass.value = null;
    };

    const EditCurveClassInit = ({ camera, scene, domElement }) => {
        if (!EditCurveClass.value) {
            EditCurveClass.value = new EditCurve({ camera, scene, domElement });
        }
    };
    const EditCurveClassDispose = () => {
        EditCurveClass.value.dispose();
        EditCurveClass.value = null;
    };

    const DrawMarginClassInit = ({ scene }) => {
        if (!DrawMarginClass.value) {
            DrawMarginClass.value = new DrawMargin({ scene });
        }
    };
    const DrawMarginClassDispose = () => {
        DrawMarginClass.value = null;
    };

    const DrawSelectionClassInit = ({ camera, scene, domElement, control }) => {
        if (!DrawSelectionClass.value) {
            DrawSelectionClass.value = new Selection({ camera, scene, domElement, control });
        }
    };
    const DrawSelectionClassDispose = () => {
        SelectsClass.value.dispose();
        SelectsClass.value = null;
    };

    const ObjectsSelectClassInit = ({ camera, scene, domElement, control }) => {
        if (!SelectsClass.value) {
            SelectsClass.value = new ObjectsSelect({ camera, scene, domElement, control });
        }
    };
    const ObjectsControlClassInit = ({ camera, scene, domElement, control }) => {
        if (!ObjectsControlClass.value) {
            ObjectsControlClass.value = new ObjectsControl({ camera, scene, domElement, control });
            ObjectsControlClass.value.setControlItemsEnabled([
                'translate-x',
                'translate-y',
                'translate-z',
                'rotate-x',
                'rotate-y',
                'rotate-z'
            ]);
        }
    };
    const ObjectsControlClassDispose = () => {
        if (ObjectsControlClass.value) {
            ObjectsControlClass.value.dispose();
            ObjectsControlClass.value = null;
        }
    };

    const OrientBottomClassInit = ({ camera, scene, domElement, control }) => {
        if (!OrientBottomClass.value) {
            OrientBottomClass.value = new OrientBottom({ camera, scene, domElement, control });
            OrientBottomClass.value.removeEvents();
        }
    };
    const OrientBottomClassDispose = () => {
        if (OrientBottomClass.value) {
            OrientBottomClass.value.dispose();
        }
        OrientBottomClass.value = null;
    };

    const TransformUndoredoClassInit = ({ scene }) => {
        if (!TransformUndoredoClass.value) {
            TransformUndoredoClass.value = new TransformUndoredo({ scene });
        }
    };
    const TransformUndoredoClassDispose = () => {
        if (TransformUndoredoClass.value) {
            TransformUndoredoClass.value.dispose();
        }
        TransformUndoredoClass.value = null;
    };

    const MeasuresClassInit = ({ camera, scene, domElement, control }) => {
        if (!MeasuresClass.value) {
            MeasuresClass.value = new Measures({ camera, scene, domElement, control });
        }
    };
    const MeasuresClassDispose = () => {
        if (MeasuresClass.value) {
            MeasuresClass.value.dispose();
        }
        MeasuresClass.value = null;
    };

    const CopyMirrorClassInit = ({ scene }) => {
        if (!CopyMirrorClassInit.value) {
            CopyMirrorClass.value = new CopyMirror({ scene });
        }
    };

    return {
        DrawSelectionClass,
        SelectsClass,
        ObjectsControlClass,
        OrientBottomClass,
        TransformUndoredoClass,
        MeasuresClass,
        CopyMirrorClass,
        DrawMarginClass,
        EditCurveClass,
        SculptClass,
        CutPlaneClass,
        SectionContourClass,
        MarkPointsOnMeshClass,

        DrawSelectionClassInit,
        DrawSelectionClassDispose,

        ObjectsSelectClassInit,
        ObjectsControlClassInit,
        ObjectsControlClassDispose,

        OrientBottomClassInit,
        OrientBottomClassDispose,

        TransformUndoredoClassInit,
        TransformUndoredoClassDispose,

        MeasuresClassInit,
        MeasuresClassDispose,

        CopyMirrorClassInit,

        DrawMarginClassInit,
        DrawMarginClassDispose,

        EditCurveClassInit,
        EditCurveClassDispose,

        SculptClassInit,
        SculptClassDispose,

        CutPlaneClassInit,
        CutPlaneDispose,

        SectionContourClassInit,

        MarkPointsOnMeshClassInit,
        MarkPointsOnMeshClassDispose
    };
});