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