scene.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <scimesh/mesh.h>
#include <scimesh/lines.h>
#include <scimesh/text.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;
 
    std::vector<LineLayer> lines;
 
    std::vector<Mat4> line_transforms;
 
    std::vector<std::string> line_names;
 
    std::vector<TextLayer> texts;
 
    std::vector<Mat4> text_transforms;
 
    std::vector<std::string> text_names;
 
    void add(const Mesh &mesh, const Mat4 &transform = Mat4(1.0f),
             const std::string &name = "") {
        meshes.push_back(mesh);
        meshes.back().update_transparency();
        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 add_lines(const LineLayer &layer, const Mat4 &transform = Mat4(1.0f),
                   const std::string &name = "") {
        lines.push_back(layer);
        line_transforms.push_back(transform);
        line_names.push_back(name);
    }
 
    void set_line_transform(size_t index, const Mat4 &transform) {
        if (index >= lines.size())
            return;
        while (line_transforms.size() <= index)
            line_transforms.push_back(Mat4(1.0f));
        line_transforms[index] = transform;
    }
 
    const Mat4 &line_transform(size_t index) const {
        static const Mat4 kIdentity(1.0f);
        if (index >= line_transforms.size())
            return kIdentity;
        return line_transforms[index];
    }
 
    const std::string &line_name(size_t index) const {
        static const std::string kEmpty;
        if (index >= line_names.size())
            return kEmpty;
        return line_names[index];
    }
 
    size_t line_count() const { return lines.size(); }
 
    void set_line_affects_bounds(size_t index, bool affects_bounds) {
        if (index >= lines.size())
            return;
        lines[index].affects_bounds = affects_bounds;
    }
 
    bool set_line_affects_bounds(const std::string &name, bool affects_bounds) {
        for (size_t i = 0; i < lines.size(); ++i) {
            if (line_name(i) == name) {
                lines[i].affects_bounds = affects_bounds;
                return true;
            }
        }
        return false;
    }
 
    bool line_affects_bounds(size_t index) const {
        if (index >= lines.size())
            return false;
        return lines[index].affects_bounds;
    }
 
    LineNodeRef line_node(size_t index) const {
        LineNodeRef r;
        r.layer = &lines[index];
        r.transform = line_transform(index);
        r.name = line_name(index);
        return r;
    }
 
    std::vector<LineNodeRef> line_nodes() const {
        std::vector<LineNodeRef> out;
        out.reserve(lines.size());
        for (size_t i = 0; i < lines.size(); ++i)
            out.push_back(line_node(i));
        return out;
    }
 
    void add_texts(const TextLayer &layer, const Mat4 &transform = Mat4(1.0f),
                   const std::string &name = "") {
        texts.push_back(layer);
        text_transforms.push_back(transform);
        text_names.push_back(name);
    }
 
    void set_text_transform(size_t index, const Mat4 &transform) {
        if (index >= texts.size())
            return;
        while (text_transforms.size() <= index)
            text_transforms.push_back(Mat4(1.0f));
        text_transforms[index] = transform;
    }
 
    const Mat4 &text_transform(size_t index) const {
        static const Mat4 kIdentity(1.0f);
        if (index >= text_transforms.size())
            return kIdentity;
        return text_transforms[index];
    }
 
    const std::string &text_name(size_t index) const {
        static const std::string kEmpty;
        if (index >= text_names.size())
            return kEmpty;
        return text_names[index];
    }
 
    size_t text_count() const { return texts.size(); }
 
    TextNodeRef text_node(size_t index) const {
        TextNodeRef r;
        r.layer = &texts[index];
        r.transform = text_transform(index);
        r.name = text_name(index);
        return r;
    }
 
    std::vector<TextNodeRef> text_nodes() const {
        std::vector<TextNodeRef> out;
        out.reserve(texts.size());
        for (size_t i = 0; i < texts.size(); ++i)
            out.push_back(text_node(i));
        return out;
    }
 
    void compute_bounding_box(Vec3 &min_bound, Vec3 &max_bound) const {
        bool first = true;
 
        // Add the 8 transformed corners of a box to the bounds.
        auto add_box = [&](const Vec3 &box_min, const Vec3 &box_max, const Mat4 &m) {
            for (int c = 0; c < 8; ++c) {
                Vec3 corner(
                    (c & 1) ? box_max.x : box_min.x,
                    (c & 2) ? box_max.y : box_min.y,
                    (c & 4) ? box_max.z : box_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);
                }
            }
        };
 
        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);
            add_box(mesh_min, mesh_max, transform(i));
        }
 
        // Line layers are content unless they opted out, see
        // LineLayer::affects_bounds.
        const bool framed_by_meshes = !first;
        for (size_t i = 0; i < lines.size(); ++i) {
            if (!lines[i].affects_bounds)
                continue;
            Vec3 line_min, line_max;
            if (lines[i].compute_bounding_box(line_min, line_max))
                add_box(line_min, line_max, line_transform(i));
        }
 
        // A scene without meshes and without any layer that claims to define the
        // extent: frame it with the lines anyway (they can only be decoration
        // if there is nothing else), because otherwise the scene would have no
        // geometry to derive a camera from.
        if (!framed_by_meshes && first) {
            for (size_t i = 0; i < lines.size(); ++i) {
                Vec3 line_min, line_max;
                if (lines[i].compute_bounding_box(line_min, line_max))
                    add_box(line_min, line_max, line_transform(i));
            }
        }
 
        if (first) {  // scene empty or all meshes empty
            min_bound = Vec3(0.0f);
            max_bound = Vec3(0.0f);
        }
    }
};
 
} // namespace scimesh