imstkBurner.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#include "imstkComponent.h"
#include "imstkMath.h"

#pragma once

namespace imstk
{
class PbdObject;
class TaskNode;
class CellPicker;
class AnalyticalGeometry;

class Burner : public SceneBehaviour
{
public:
    Burner(const std::string& name = "BurnerPbdObjectBehavior");

    void init() override;

    std::shared_ptr<PbdObject> getBurnerObject() const { return m_burningObj; }

    std::shared_ptr<AnalyticalGeometry> getBurnerGeometry() const { return m_burnGeometry; }
    void setBurnerGeometry(std::shared_ptr<AnalyticalGeometry> geom)
    {
        CHECK(geom != nullptr);
        m_burnGeometry = geom;
    }


    double getOnTime() const { return m_onTime; }
    void setOnTime(const double onTime)
    {
        CHECK(onTime >= 0.0 && onTime <= 1.0) << "On time in the burning component must be between 0 and 1 \n";
        m_onTime = onTime;
    }


    double getWattage() const { return m_wattage; }
    void setWattage(const double wattage)
    {
        CHECK(wattage >= 10.0 && wattage <= 200.0) << "Wattage is currently forced to be within 10 and 200 for the burning tool, set value within these bounds \n";
        m_wattage     = wattage;
        m_normWattage = wattage / 100.0;
    }


    void start() { m_onState = true; }
    void stop() { m_onState = false; }

    void addObject(std::shared_ptr<PbdObject> obj)
    {
        m_burnableObjects.push_back({ obj, nullptr });
    }


    bool getState() const { return m_onState; }

    // Check state of mesh and delete cells that are burned away
    // void update(double dt);
    void visualUpdate(const double& dt) override;

    bool getDidBurn() const;

protected:

    // The handle does the picking to choose which cells are burned.
    void handle();

    void handleBurnable(int burnableId);

    // Applies the burn using the burn model
    void applyBurn(int burnableId, int cellId);

    // Burner model for the monopolar tool (variables defined below)
    // Damage evolution:   damage^{n+1} = damage^{n} + onTime*q*normWattage*dt
    // Visual evolution:   visual^{n+1} = visual^{n} + (1-onTime)*q*normWattage*dt
    void monopolarToolModel(double& burnDmg, double& burnVis, double dt);

    void initGraphEdges(std::shared_ptr<TaskNode> source, std::shared_ptr<TaskNode> sink) override;

    std::shared_ptr<PbdObject> m_burningObj;            
    std::shared_ptr<AnalyticalGeometry> m_burnGeometry; 

    std::shared_ptr<TaskNode> m_burningHandleNode;

    struct Burnable
    {
        std::shared_ptr<PbdObject> object;
        std::shared_ptr<CellPicker> picker;
    };

    std::vector<Burnable> m_burnableObjects; 

    double m_onTime      = 0.5;              
    double m_wattage     = 50;               
    double m_normWattage = 0.5;              
    double m_q = 4.0;                        

    bool m_onState  = false;                 
    bool m_burnOnce = false;                 
    bool m_didBurnLastPhysics = false;       
private:
    bool   m_didBurn  = false;               
    double m_burnTime = 0;
};
} // namespace imstk