tfThreeDFStructure.h

/*******************************************************************************
 * This file is part of Tissue Forge.
 * Copyright (c) 2022-2024 T.J. Sego
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/
 
// todo: implement a sewing method on ThreeDFStructure to join same vertices but in different meshes
//  Currently, vertices are allocated by mesh; if a vertex is shared by meshes, they will show up as separate entities in each mesh. 
//  This method should detect such occurrences and make one shared vertex among many meshes
 
#ifndef _SOURCE_IO_TFTHREEDFSTRUCTURE_H_
#define _SOURCE_IO_TFTHREEDFSTRUCTURE_H_
 
#include <tf_port.h>
 
#include "tfThreeDFVertexData.h"
#include "tfThreeDFEdgeData.h"
#include "tfThreeDFFaceData.h"
#include "tfThreeDFMeshData.h"
 
#include <unordered_map>
 
 
namespace TissueForge::io {
 
 
    struct CAPI_EXPORT ThreeDFComponentContainer {
        std::vector<ThreeDFVertexData*> vertices;
        std::vector<ThreeDFEdgeData*> edges;
        std::vector<ThreeDFFaceData*> faces;
        std::vector<ThreeDFMeshData*> meshes;
    };
 

    struct CAPI_EXPORT ThreeDFStructure {

        ThreeDFComponentContainer inventory;

        ThreeDFComponentContainer queueRemove;

        FloatP_t vRadiusDef = 0.1;
 
        ~ThreeDFStructure();
 
        // Structure management

        HRESULT fromFile(const std::string &filePath);

        HRESULT toFile(const std::string &format, const std::string &filePath);

        HRESULT flush();
 
        // Inventory management

        HRESULT extend(const ThreeDFStructure &s);

        HRESULT clear();
        
        std::vector<ThreeDFVertexData*> getVertices();

        std::vector<ThreeDFEdgeData*> getEdges();

        std::vector<ThreeDFFaceData*> getFaces();

        std::vector<ThreeDFMeshData*> getMeshes();

        unsigned int getNumVertices();

        unsigned int getNumEdges();

        unsigned int getNumFaces();

        unsigned int getNumMeshes();

        bool has(ThreeDFVertexData *v);

        bool has(ThreeDFEdgeData *e);

        bool has(ThreeDFFaceData *f);

        bool has(ThreeDFMeshData *m);

        void add(ThreeDFVertexData *v);

        void add(ThreeDFEdgeData *e);

        void add(ThreeDFFaceData *f);

        void add(ThreeDFMeshData *m);

        void remove(ThreeDFVertexData *v);

        void remove(ThreeDFEdgeData *e);

        void remove(ThreeDFFaceData *f);

        void remove(ThreeDFMeshData *m);
 
        void onRemoved(ThreeDFVertexData *v);
        void onRemoved(ThreeDFEdgeData *e);
        void onRemoved(ThreeDFFaceData *f);
 
        // Transformations

        FVector3 getCentroid();

        HRESULT translate(const FVector3 &displacement);

        HRESULT translateTo(const FVector3 &position);

        HRESULT rotateAt(const FMatrix3 &rotMat, const FVector3 &rotPt);

        HRESULT rotate(const FMatrix3 &rotMat);

        HRESULT scaleFrom(const FVector3 &scales, const FVector3 &scalePt);

        HRESULT scaleFrom(const FloatP_t &scale, const FVector3 &scalePt);

        HRESULT scale(const FVector3 &scales);

        HRESULT scale(const FloatP_t &scale);
 
    private:
 
        int id_vertex = 0;
        int id_edge = 0;
        int id_face = 0;
        int id_mesh = 0;
 
    };
 
};
 
#endif // _SOURCE_IO_TFTHREEDFSTRUCTURE_H_