bvh_node.h

Go to the documentation of this file.

/*
 * Adapted from code copyright 2009-2010 NVIDIA Corporation
 * Modifications Copyright 2011, Blender Foundation.
 *
 * Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __BVH_NODE_H__
#define __BVH_NODE_H__

#include "util_boundbox.h"
#include "util_debug.h"
#include "util_types.h"

CCL_NAMESPACE_BEGIN

enum BVH_STAT
{
    BVH_STAT_NODE_COUNT,
    BVH_STAT_INNER_COUNT,
    BVH_STAT_LEAF_COUNT,
    BVH_STAT_TRIANGLE_COUNT,
    BVH_STAT_CHILDNODE_COUNT
};

class BVHParams;

class BVHNode
{
public:
    BVHNode()
    {
    }

    virtual ~BVHNode() {}
    virtual bool is_leaf() const = 0;
    virtual int num_children() const = 0;
    virtual BVHNode *get_child(int i) const = 0;
    virtual int num_triangles() const { return 0; }
    virtual void print(int depth = 0) const = 0;

    float getArea() const { return m_bounds.area(); }

    BoundBox m_bounds;
    uint m_visibility;

    // Subtree functions
    int getSubtreeSize(BVH_STAT stat=BVH_STAT_NODE_COUNT) const;
    float computeSubtreeSAHCost(const BVHParams& p, float probability = 1.0f) const;    
    void deleteSubtree();
};

class InnerNode : public BVHNode
{
public:
    InnerNode(const BoundBox& bounds, BVHNode* child0, BVHNode* child1)
    {
        m_bounds = bounds;
        m_visibility = child0->m_visibility|child1->m_visibility;
        children[0] = child0;
        children[1] = child1;
    }

    bool is_leaf() const { return false; }
    int num_children() const { return 2; }
    BVHNode *get_child(int i) const{ assert(i>=0 && i<2); return children[i]; }
    void print(int depth) const;

    BVHNode *children[2];
};

class LeafNode : public BVHNode
{
public:
    LeafNode(const BoundBox& bounds, uint visibility, int lo, int hi) 
    {
        m_bounds = bounds;
        m_visibility = visibility;
        m_lo = lo;
        m_hi = hi;
    }

    LeafNode(const LeafNode& s)
    : BVHNode()
    {
        *this = s;
    }

    bool is_leaf() const { return true; }
    int num_children() const { return 0; }
    BVHNode *get_child(int) const { return NULL; }
    int num_triangles() const { return m_hi - m_lo; }
    void print(int depth) const;

    int m_lo;
    int m_hi;
};

CCL_NAMESPACE_END

#endif /* __BVH_NODE_H__ */