imstkVTKFluidRenderDelegate.cpp

/*
** 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 "imstkVTKFluidRenderDelegate.h"
#include "imstkPointSet.h"
#include "imstkVisualModel.h"
#include "imstkRenderMaterial.h"
#include "imstkGeometryUtilities.h"

#include <vtkOpenGLFluidMapper.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkDoubleArray.h>
#include <vtkVolume.h>

namespace imstk
{
VTKFluidRenderDelegate::VTKFluidRenderDelegate() :
    m_polydata(vtkSmartPointer<vtkPolyData>::New()),
    m_mappedVertexArray(vtkSmartPointer<vtkDoubleArray>::New())
{
}

void
VTKFluidRenderDelegate::init()
{
    auto geometry = std::dynamic_pointer_cast<PointSet>(m_visualModel->getGeometry());
    CHECK(geometry != nullptr) << "VTKFluidRenderDelegate only works with PointSet geometry";
    m_vertices = geometry->getVertexPositions();

    // Map vertices
    if (m_vertices != nullptr)
    {
        m_mappedVertexArray = vtkDoubleArray::SafeDownCast(GeometryUtils::coupleVtkDataArray(m_vertices));
        auto points = vtkSmartPointer<vtkPoints>::New();
        points->SetNumberOfPoints(geometry->getNumVertices());
        points->SetData(m_mappedVertexArray);
        m_polydata->SetPoints(points);
    }

    // When geometry is modified, update data source, mostly for when an entirely new array/buffer was set
    queueConnect<Event>(geometry, &Geometry::modified,
        std::static_pointer_cast<VTKFluidRenderDelegate>(shared_from_this()),
        &VTKFluidRenderDelegate::geometryModified);

    // When the vertex buffer internals are modified, ie: a single or N elements
    queueConnect<Event>(geometry->getVertexPositions(), &VecDataArray<double, 3>::modified,
        std::static_pointer_cast<VTKFluidRenderDelegate>(shared_from_this()),
        &VTKFluidRenderDelegate::vertexDataModified);

    // Setup mapper
    {
        vtkNew<vtkOpenGLFluidMapper> mapper;
        mapper->SetInputData(m_polydata);
        vtkNew<vtkVolume> volume;
        volume->SetMapper(mapper);
        m_mapper = mapper;
        m_actor  = volume;
    }

    update();
    updateRenderProperties();
}

void
VTKFluidRenderDelegate::processEvents()
{
    // Custom handling of events
    std::shared_ptr<PointSet>                geom     = std::dynamic_pointer_cast<PointSet>(m_visualModel->getGeometry());
    std::shared_ptr<VecDataArray<double, 3>> vertices = geom->getVertexPositions();

    // Only use the most recent event from respective sender
    std::list<Command> cmds;
    bool               contains[4] = { false, false, false, false };
    rforeachEvent([&](Command cmd)
        {
            if (cmd.m_event->m_sender == m_visualModel.get() && !contains[0])
            {
                cmds.push_back(cmd);
                contains[0] = true;
            }
            else if (cmd.m_event->m_sender == m_material.get() && !contains[1])
            {
                cmds.push_back(cmd);
                contains[1] = true;
            }
            else if (cmd.m_event->m_sender == geom.get() && !contains[2])
            {
                cmds.push_back(cmd);
                contains[2] = true;
            }
            else if (cmd.m_event->m_sender == vertices.get() && !contains[3])
            {
                cmds.push_back(cmd);
                contains[3] = true;
            }
        });

    // Now do each event in order recieved
    for (std::list<Command>::reverse_iterator i = cmds.rbegin(); i != cmds.rend(); i++)
    {
        i->invoke();
    }
}

void
VTKFluidRenderDelegate::geometryModified(Event* imstkNotUsed(e))
{
    // Called when the geometry posts modified
    auto geometry = std::static_pointer_cast<PointSet>(m_visualModel->getGeometry());

    // Test if the vertex buffer changed
    if (m_vertices != geometry->getVertexPositions())
    {
        //printf("Vertex data swapped\n");
        m_vertices = geometry->getVertexPositions();
        {
            // Update the pointer of the coupled array
            m_mappedVertexArray->SetNumberOfComponents(3);
            m_mappedVertexArray->SetArray(reinterpret_cast<double*>(m_vertices->getPointer()), m_vertices->size() * 3, 1);
        }
    }
    m_mappedVertexArray->Modified();
}

void
VTKFluidRenderDelegate::vertexDataModified(Event* imstkNotUsed(e))
{
    auto geometry = std::static_pointer_cast<PointSet>(m_visualModel->getGeometry());
    m_vertices = geometry->getVertexPositions();
    if (m_vertices->getVoidPointer() != m_mappedVertexArray->GetVoidPointer(0))
    {
        m_mappedVertexArray->SetNumberOfComponents(3);
        m_mappedVertexArray->SetArray(reinterpret_cast<double*>(m_vertices->getPointer()), m_vertices->size() * 3, 1);
    }
    m_mappedVertexArray->Modified();
}

void
VTKFluidRenderDelegate::updateRenderProperties()
{
    vtkSmartPointer<vtkOpenGLFluidMapper> mapper = vtkOpenGLFluidMapper::SafeDownCast(m_mapper);

    // todo: Expose in RenderMaterial or subclass
    mapper->SetParticleRadius(m_material->getPointSize());
    mapper->SetSurfaceFilterIterations(3);
    mapper->SetSurfaceFilterRadius(5);
    mapper->SetSurfaceFilterMethod(vtkOpenGLFluidMapper::FluidSurfaceFilterMethod::NarrowRange);
    mapper->SetDisplayMode(vtkOpenGLFluidMapper::FluidDisplayMode::TransparentFluidVolume);
    mapper->SetAttenuationColor(0.1f, 0.9f, 0.9f);
    mapper->SetAttenuationScale(16.0f);
    mapper->SetOpaqueColor(0.9f, 0.1f, 0.1f);
    mapper->SetParticleColorPower(0.1f);
    mapper->SetParticleColorScale(0.57f);
    mapper->SetAdditionalReflection(0.0f);
    mapper->SetRefractiveIndex(1.5f);
    mapper->SetRefractionScale(0.07f);
}
} // namespace imstk