minor changes (bounds lazy eval state)

[laserbrain_demo] / src / snode.cc

#include <float.h>
#include <assert.h>
#include <algorithm>
#include "snode.h"
#include "objmesh.h"
#include "dbg_gui.h"

SceneNode::SceneNode()
        : scale(1, 1, 1)
{
        scene = 0;
        parent = 0;
        name = 0;
        bvol_valid = false;
}

SceneNode::SceneNode(Object *obj)
        : scale(1, 1, 1)
{
        scene = 0;
        parent = 0;
        name = 0;
        bvol_valid = false;
        add_object(obj);
}

SceneNode::~SceneNode()
{
        delete [] name;
}

void SceneNode::set_name(const char *s)
{
        delete [] name;
        name = new char[strlen(s) + 1];
        strcpy(name, s);
}

const char *SceneNode::get_name() const
{
        return name;
}

void SceneNode::add_child(SceneNode *node)
{
        if(!node) return;

        if(node->parent) {
                if(node->parent == this) {
                        return;
                }
                node->parent->remove_child(node);
        }

        children.push_back(node);
        node->parent = this;
        node->scene = scene;

        bvol_valid = false;
}

bool SceneNode::remove_child(SceneNode *node)
{
        if(!node) return false;

        auto it = std::find(children.begin(), children.end(), node);
        if(it != children.end()) {
                assert(node->parent == this);
                node->parent = 0;
                node->scene = 0;
                children.erase(it);

                bvol_valid = false;
                return true;
        }
        return false;
}

int SceneNode::get_num_children() const
{
        return (int)children.size();
}

SceneNode *SceneNode::get_child(int idx) const
{
        return children[idx];
}

SceneNode *SceneNode::get_parent() const
{
        return parent;
}

void SceneNode::add_object(Object *obj)
{
        if(obj->node == this) return;

        if(obj->node) {
                obj->node->remove_object(obj);
        }

        this->obj.push_back(obj);
        obj->node = this;

        bvol_valid = false;
}

bool SceneNode::remove_object(Object *o)
{
        if(o->node != this) {
                return false;
        }
        o->node = 0;

        auto it = std::find(obj.begin(), obj.end(), o);
        if(it == obj.end()) {
                return false;
        }
        obj.erase(it);

        bvol_valid = false;
        return true;
}

int SceneNode::get_num_objects() const
{
        return (int)obj.size();
}

Object *SceneNode::get_object(int idx) const
{
        return obj[idx];
}

void SceneNode::set_position(const Vec3 &pos)
{
        this->pos = pos;
}

void SceneNode::set_rotation(const Quat &rot)
{
        this->rot = rot;
}

void SceneNode::set_scaling(const Vec3 &scale)
{
        this->scale = scale;
}


const Vec3 &SceneNode::get_node_position() const
{
        return pos;
}

const Quat &SceneNode::get_node_rotation() const
{
        return rot;
}

const Vec3 &SceneNode::get_node_scaling() const
{
        return scale;
}


Vec3 SceneNode::get_position() const
{
        return xform * Vec3(0, 0, 0);
}

Quat SceneNode::get_rotation() const
{
        return rot;     // TODO
}

Vec3 SceneNode::get_scaling() const
{
        return scale;   // TODO
}

const Mat4 &SceneNode::get_matrix() const
{
        return xform;
}

const Mat4 &SceneNode::get_inv_matrix() const
{
        return inv_xform;
}


void SceneNode::update_node(float dt)
{
        xform = Mat4::identity;
        xform.pre_translate(pos);
        xform.pre_rotate(rot);
        xform.pre_scale(scale);

        if(parent) {
                xform = xform * parent->xform;
        }
        inv_xform = inverse(xform);
}

void SceneNode::update(float dt)
{
        bool expanded = false;

        if(debug_gui) {
                if(parent_expanded) {
                        int flags = children.empty() ? ImGuiTreeNodeFlags_Leaf : 0;
                        expanded = ImGui::TreeNodeEx(name ? name : "<nameless node>", flags);
                }
        }

        update_node(dt);

        int num = children.size();
        for(int i=0; i<num; i++) {
                parent_expanded = expanded;
                children[i]->update(dt);
        }

        if(debug_gui && expanded) {
                ImGui::TreePop();
        }
}

void SceneNode::apply_xform()
{
        update_node();

        // apply post-order to make sure we don't affect the children xform by our reset

        int nchild = children.size();
        for(int i=0; i<nchild; i++) {
                children[i]->apply_xform();
        }

        int nobj = obj.size();
        for(int i=0; i<nobj; i++) {
                if(obj[i]->get_type() == OBJ_MESH) {
                        ObjMesh *om = (ObjMesh*)obj[i];
                        if(om->mesh) {
                                om->mesh->apply_xform(xform);
                        }
                }
        }

        pos = Vec3(0, 0, 0);
        rot = Quat::identity;
        scale = Vec3(1, 1, 1);
}

bool SceneNode::intersect(const Ray &ray, HitPoint *hit) const
{
        Ray local_ray = inv_xform * ray;

        HitPoint nearest;
        nearest.dist = FLT_MAX;
        for(size_t i=0; i<obj.size(); i++) {
                if(obj[i]->intersect(local_ray, hit)) {
                        if(!hit) return true;
                        if(hit->dist < nearest.dist) {
                                nearest = *hit;
                                nearest.data = (void*)this;
                                nearest.local_ray = local_ray;
                        }
                }
        }

        for(size_t i=0; i<children.size(); i++) {
                if(children[i]->intersect(ray, hit)) {
                        if(!hit) return true;
                        if(hit->dist < nearest.dist) {
                                nearest = *hit;
                        }
                }
        }

        if(nearest.dist < FLT_MAX) {
                *hit = nearest;
                hit->ray = ray;
                return true;
        }
        return false;
}

const Box &SceneNode::calc_bounds()
{
        // TODO
}

const Box &SceneNode::get_bounds() const
{
        if(!bvol_valid) {
                return ((SceneNode*)this)->calc_bounds();
        }
        return bvol;
}