SimpleScene.h

/*
 * Copyright 2022 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/SurfaceMesh.h>
#include <lagrange/scene/api.h>
#include <lagrange/utils/invalid.h>
 
 
#include <Eigen/Geometry>
 
#include <any>
#include <vector>
 
namespace lagrange::scene {

template <typename Scalar, typename Index, size_t Dimension = 3>
struct LA_SCENE_API MeshInstance
{
    using AffineTransform = Eigen::Transform<Scalar, static_cast<int>(Dimension), Eigen::Affine>;

    Index mesh_index = invalid<Index>();

    AffineTransform transform = AffineTransform::Identity();

    std::any user_data = {};

    constexpr static size_t Dim = Dimension;
};

template <typename Scalar, typename Index, size_t Dimension = 3>
class LA_SCENE_API SimpleScene
{
public:
    using MeshType = SurfaceMesh<Scalar, Index>;

    using InstanceType = MeshInstance<Scalar, Index, Dimension>;

    using AffineTransform = typename InstanceType::AffineTransform;

    constexpr static size_t Dim = Dimension;
 
public:
    Index get_num_meshes() const { return static_cast<Index>(m_meshes.size()); }

    Index get_num_instances(Index mesh_index) const
    {
        return static_cast<Index>(m_instances[mesh_index].size());
    }

    Index compute_num_instances() const;

    const MeshType& get_mesh(Index mesh_index) const { return m_meshes[mesh_index]; }

    MeshType& ref_mesh(Index mesh_index) { return m_meshes[mesh_index]; }

    const InstanceType& get_instance(Index mesh_index, Index instance_index) const
    {
        return m_instances[mesh_index][instance_index];
    }

    InstanceType& ref_instance(Index mesh_index, Index instance_index)
    {
        return m_instances[mesh_index][instance_index];
    }

    void reserve_meshes(Index num_meshes);

    Index add_mesh(MeshType mesh);

    void reserve_instances(Index mesh_index, Index num_instances);

    Index add_instance(InstanceType instance);

    void foreach_instances_for_mesh(Index mesh_index, function_ref<void(const InstanceType&)> func)
        const;

    void foreach_instances(function_ref<void(const InstanceType&)> func) const;
 
protected:
    std::vector<MeshType> m_meshes;

    std::vector<std::vector<InstanceType>> m_instances;
};
 
using SimpleScene32f2 = SimpleScene<float, uint32_t, 2u>;
using SimpleScene32d2 = SimpleScene<double, uint32_t, 2u>;
using SimpleScene64f2 = SimpleScene<float, uint64_t, 2u>;
using SimpleScene64d2 = SimpleScene<double, uint64_t, 2u>;
using SimpleScene32f3 = SimpleScene<float, uint32_t, 3u>;
using SimpleScene32d3 = SimpleScene<double, uint32_t, 3u>;
using SimpleScene64f3 = SimpleScene<float, uint64_t, 3u>;
using SimpleScene64d3 = SimpleScene<double, uint64_t, 3u>;
 
} // namespace lagrange::scene