tfMeshSolver.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of Tissue Forge.
 * Copyright (c) 2022-2024 T.J. Sego and Tien Comlekoglu
 * 
 * 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/>.
 * 
 ******************************************************************************/
 
#ifndef _MODELS_VERTEX_SOLVER_TFMESHSOLVER_H_
#define _MODELS_VERTEX_SOLVER_TFMESHSOLVER_H_
 
#include <tf_port.h>
 
#include "tfMesh.h"
#include "tfMeshLogger.h"
 
#include <tfSubEngine.h>
#include <tf_cycle.h>
 
 
namespace TissueForge::models::vertex { 
 
 
    class MeshRenderer;
 
 
    HRESULT VertexForce(const Vertex *v, FloatP_t *f);
 
    static HRESULT VertexForce(const Vertex *v, FVector3 &f) { return VertexForce(v, f.data()); }
 
    static FVector3 VertexForce(const Vertex *v) {
        FVector3 f;
        VertexForce(v, f.data());
        return f;
    }
 
 
    struct CAPI_EXPORT MeshSolverTimers {
 
        enum Section : unsigned int {
            FORCE=0,
            ADVANCE,
            UPDATE,
            QUALITY,
            RENDERING,
            LAST
        };
 
        HRESULT append(const Section &section, const ticks _ticks) { timers[section] += _ticks; return S_OK; }
 
        double ms(const Section &section, const bool &avg=true) const;
 
        HRESULT reset() {
            for(size_t i = 0; i < Section::LAST; i++) timers[i] = 0;
            return S_OK;
        }
 
        std::string str() const;
 
    private:
 
        ticks timers[Section::LAST];
        
    };
 
 
    class CAPI_EXPORT MeshSolverTimerInstance {
        
        MeshSolverTimers::Section section;
        ticks tic;
 
    public:
 
        MeshSolverTimerInstance(const MeshSolverTimers::Section &_section);
        ~MeshSolverTimerInstance();
 
    };
 
 
    struct CAPI_EXPORT MeshSolver : SubEngine { 
 
        const char *name = "MeshSolver";
 
        Mesh *mesh;
 
        MeshSolverTimers timers;
 
        static HRESULT init();
 
        static MeshSolver *get();
 
        static HRESULT compact();
 
        static HRESULT engineLock();
        
        static HRESULT engineUnlock();
 
        static bool isDirty();
 
        static HRESULT setDirty(const bool &_isDirty);
 
        static Mesh *getMesh();
 
        static bool is3D();
 
        static HRESULT registerType(BodyType *_type);
 
        static HRESULT registerType(SurfaceType *_type);
 
        static SurfaceType *findSurfaceFromName(const std::string &_name);
 
        static BodyType *findBodyFromName(const std::string &_name);
 
        static BodyType *getBodyType(const unsigned int &typeId);
 
        static SurfaceType *getSurfaceType(const unsigned int &typeId);
 
        static const int numBodyTypes();
 
        static const int numSurfaceTypes();
 
        static unsigned int numVertices();
 
        static unsigned int numSurfaces();
 
        static unsigned int numBodies();
 
        static unsigned int sizeVertices();
 
        static unsigned int sizeSurfaces();
 
        static unsigned int sizeBodies();
 
        static HRESULT positionChanged();
 
        static HRESULT update(const bool &_force=false);
 
        HRESULT preStepStart() override;
        HRESULT preStepJoin() override;
        HRESULT postStepStart() override;
        HRESULT postStepJoin() override;
 
        static std::vector<unsigned int> getSurfaceVertexIndices();
 
        static HRESULT getSurfaceVertexIndicesAsyncStart();
 
        static std::vector<unsigned int> getSurfaceVertexIndicesAsyncJoin();
 
        static std::vector<MeshLogEvent> getLog() {
            return MeshLogger::events();
        }
 
        static HRESULT log(const MeshLogEventType &type, const std::vector<int> &objIDs, const std::vector<MeshObjTypeLabel> &objTypes, const std::string &name="");
 
        friend MeshRenderer;
 
    private:
 
        FloatP_t *_forces;
        unsigned int _bufferSize;
        unsigned int _surfaceVertices;
        unsigned int _totalVertices;
        bool _isDirty;
        std::mutex _engineLock;
        std::vector<unsigned int> _surfaceVertexIndices;
 
        std::vector<BodyType*> _bodyTypes;
        std::vector<SurfaceType*> _surfaceTypes;
 
        HRESULT _compactInst();
 
        bool _isDirtyInst() const;
 
        HRESULT _setDirtyInst(const bool &_isDirty);
 
        Mesh *_newMeshInst();
 
        HRESULT _loadMeshInst(Mesh *mesh);
 
        HRESULT _unloadMeshInst(Mesh *mesh);
 
        HRESULT _registerTypeInst(BodyType *_type);
 
        HRESULT _registerTypeInst(SurfaceType *_type);
 
        SurfaceType *_findSurfaceFromNameInst(const std::string &_name);
 
        BodyType *_findBodyFromNameInst(const std::string &_name);
 
        BodyType *_getBodyTypeInst(const unsigned int &typeId) const;
 
        SurfaceType *_getSurfaceTypeInst(const unsigned int &typeId) const;
 
        HRESULT _positionChangedInst();
 
        std::vector<unsigned int> _getSurfaceVertexIndicesInst() const;
 
        HRESULT _getSurfaceVertexIndicesAsyncStartInst();
 
        std::vector<unsigned int> _getSurfaceVertexIndicesAsyncJoinInst();
 
        HRESULT _logInst(const MeshLogEventType &type, const std::vector<int> &objIDs, const std::vector<MeshObjTypeLabel> &objTypes, const std::string &name="");
        
    };
 
}
 
#endif // _MODELS_VERTEX_SOLVER_TFMESHSOLVER_H_