scene.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <scimesh/mesh.h>
#include <scimesh/math_utils.h>
#include <string>
 
namespace scimesh {
 
struct SceneNodeRef {
    const Mesh *mesh = nullptr;     
    Mat4 transform = Mat4(1.0f);    
    std::string name;               
};
 
struct Scene {
    std::vector<Mesh> meshes;
 
    std::vector<Mat4> transforms;
 
    std::vector<std::string> names;
 
    void add(const Mesh &mesh, const Mat4 &transform = Mat4(1.0f),
             const std::string &name = "") {
        meshes.push_back(mesh);
        transforms.push_back(transform);
        names.push_back(name);
    }
 
    void set_transform(size_t index, const Mat4 &transform) {
        if (index >= meshes.size())
            return;
        while (transforms.size() <= index)
            transforms.push_back(Mat4(1.0f));
        transforms[index] = transform;
    }
 
    void set_name(size_t index, const std::string &name) {
        if (index >= meshes.size())
            return;
        while (names.size() <= index)
            names.push_back("");
        names[index] = name;
    }
 
    const Mat4 &transform(size_t index) const {
        static const Mat4 kIdentity(1.0f);
        if (index >= transforms.size())
            return kIdentity;
        return transforms[index];
    }
 
    const std::string &name(size_t index) const {
        static const std::string kEmpty;
        if (index >= names.size())
            return kEmpty;
        return names[index];
    }
 
    size_t size() const { return meshes.size(); }
 
    bool empty() const { return meshes.empty(); }
 
    SceneNodeRef node(size_t index) const {
        SceneNodeRef r;
        r.mesh = &meshes[index];
        r.transform = transform(index);
        r.name = name(index);
        return r;
    }
 
    std::vector<SceneNodeRef> nodes() const {
        std::vector<SceneNodeRef> out;
        out.reserve(meshes.size());
        for (size_t i = 0; i < meshes.size(); ++i)
            out.push_back(node(i));
        return out;
    }
 
    void compute_bounding_box(Vec3 &min_bound, Vec3 &max_bound) const {
        bool first = true;
        for (size_t i = 0; i < meshes.size(); ++i) {
            const Mesh &mesh = meshes[i];
            if (mesh.vertices.empty())
                continue;
            Vec3 mesh_min, mesh_max;
            mesh.compute_bounding_box(mesh_min, mesh_max);
            const Mat4 &m = transform(i);
            for (int c = 0; c < 8; ++c) {
                Vec3 corner(
                    (c & 1) ? mesh_max.x : mesh_min.x,
                    (c & 2) ? mesh_max.y : mesh_min.y,
                    (c & 4) ? mesh_max.z : mesh_min.z);
                Vec3 t = transform_point(m, corner);
                if (first) {
                    min_bound = t;
                    max_bound = t;
                    first = false;
                } else {
                    min_bound = glm::min(min_bound, t);
                    max_bound = glm::max(max_bound, t);
                }
            }
        }
        if (first) {  // scene empty or all meshes empty
            min_bound = Vec3(0.0f);
            max_bound = Vec3(0.0f);
        }
    }
};
 
} // namespace scimesh