blender/intern/cycles/bvh/split.h

/*
 * 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_SPLIT_H__
#define __BVH_SPLIT_H__

#include "bvh/build.h"
#include "bvh/params.h"

CCL_NAMESPACE_BEGIN

class BVHBuild;
class Hair;
class Mesh;
class PointCloud;
struct Transform;

/* Object Split */

class BVHObjectSplit {
 public:
  float sah;
  int dim;
  int num_left;
  BoundBox left_bounds;
  BoundBox right_bounds;

  BVHObjectSplit()
  {
  }
  BVHObjectSplit(BVHBuild *builder,
                 BVHSpatialStorage *storage,
                 const BVHRange &range,
                 vector<BVHReference> &references,
                 float nodeSAH,
                 const BVHUnaligned *unaligned_heuristic = NULL,
                 const Transform *aligned_space = NULL);

  void split(BVHRange &left, BVHRange &right, const BVHRange &range);

 protected:
  BVHSpatialStorage *storage_;
  vector<BVHReference> *references_;
  const BVHUnaligned *unaligned_heuristic_;
  const Transform *aligned_space_;

  __forceinline BoundBox get_prim_bounds(const BVHReference &prim) const
  {
    if (aligned_space_ == NULL) {
      return prim.bounds();
    }
    else {
      return unaligned_heuristic_->compute_aligned_prim_boundbox(prim, *aligned_space_);
    }
  }
};

/* Spatial Split */

class BVHSpatialSplit {
 public:
  float sah;
  int dim;
  float pos;

  BVHSpatialSplit() : sah(FLT_MAX), dim(0), pos(0.0f), storage_(NULL), references_(NULL)
  {
  }
  BVHSpatialSplit(const BVHBuild &builder,
                  BVHSpatialStorage *storage,
                  const BVHRange &range,
                  vector<BVHReference> &references,
                  float nodeSAH,
                  const BVHUnaligned *unaligned_heuristic = NULL,
                  const Transform *aligned_space = NULL);

  void split(BVHBuild *builder, BVHRange &left, BVHRange &right, const BVHRange &range);

  void split_reference(const BVHBuild &builder,
                       BVHReference &left,
                       BVHReference &right,
                       const BVHReference &ref,
                       int dim,
                       float pos);

 protected:
  BVHSpatialStorage *storage_;
  vector<BVHReference> *references_;
  const BVHUnaligned *unaligned_heuristic_;
  const Transform *aligned_space_;

  /* Lower-level functions which calculates boundaries of left and right nodes
   * needed for spatial split.
   *
   * Operates directly with primitive specified by its index, reused by higher
   * level splitting functions.
   */
  void split_triangle_primitive(const Mesh *mesh,
                                const Transform *tfm,
                                int prim_index,
                                int dim,
                                float pos,
                                BoundBox &left_bounds,
                                BoundBox &right_bounds);
  void split_curve_primitive(const Hair *hair,
                             const Transform *tfm,
                             int prim_index,
                             int segment_index,
                             int dim,
                             float pos,
                             BoundBox &left_bounds,
                             BoundBox &right_bounds);
  void split_point_primitive(const PointCloud *pointcloud,
                             const Transform *tfm,
                             int prim_index,
                             int dim,
                             float pos,
                             BoundBox &left_bounds,
                             BoundBox &right_bounds);

  /* Lower-level functions which calculates boundaries of left and right nodes
   * needed for spatial split.
   *
   * Operates with BVHReference, internally uses lower level API functions.
   */
  void split_triangle_reference(const BVHReference &ref,
                                const Mesh *mesh,
                                int dim,
                                float pos,
                                BoundBox &left_bounds,
                                BoundBox &right_bounds);
  void split_curve_reference(const BVHReference &ref,
                             const Hair *hair,
                             int dim,
                             float pos,
                             BoundBox &left_bounds,
                             BoundBox &right_bounds);
  void split_point_reference(const BVHReference &ref,
                             const PointCloud *pointcloud,
                             int dim,
                             float pos,
                             BoundBox &left_bounds,
                             BoundBox &right_bounds);
  void split_object_reference(
      const Object *object, int dim, float pos, BoundBox &left_bounds, BoundBox &right_bounds);

  __forceinline BoundBox get_prim_bounds(const BVHReference &prim) const
  {
    if (aligned_space_ == NULL) {
      return prim.bounds();
    }
    else {
      return unaligned_heuristic_->compute_aligned_prim_boundbox(prim, *aligned_space_);
    }
  }

  __forceinline float3 get_unaligned_point(const float3 &point) const
  {
    if (aligned_space_ == NULL) {
      return point;
    }
    else {
      return transform_point(aligned_space_, point);
    }
  }
};

/* Mixed Object-Spatial Split */

class BVHMixedSplit {
 public:
  BVHObjectSplit object;
  BVHSpatialSplit spatial;

  float leafSAH;
  float nodeSAH;
  float minSAH;

  bool no_split;

  BoundBox bounds;

  BVHMixedSplit()
  {
  }

  __forceinline BVHMixedSplit(BVHBuild *builder,
                              BVHSpatialStorage *storage,
                              const BVHRange &range,
                              vector<BVHReference> &references,
                              int level,
                              const BVHUnaligned *unaligned_heuristic = NULL,
                              const Transform *aligned_space = NULL)
  {
    if (aligned_space == NULL) {
      bounds = range.bounds();
    }
    else {
      bounds = unaligned_heuristic->compute_aligned_boundbox(
          range, &references.at(0), *aligned_space);
    }
    /* find split candidates. */
    float area = bounds.safe_area();

    leafSAH = area * builder->params.primitive_cost(range.size());
    nodeSAH = area * builder->params.node_cost(2);

    object = BVHObjectSplit(
        builder, storage, range, references, nodeSAH, unaligned_heuristic, aligned_space);

    if (builder->params.use_spatial_split && level < BVHParams::MAX_SPATIAL_DEPTH) {
      BoundBox overlap = object.left_bounds;
      overlap.intersect(object.right_bounds);

      if (overlap.safe_area() >= builder->spatial_min_overlap) {
        spatial = BVHSpatialSplit(
            *builder, storage, range, references, nodeSAH, unaligned_heuristic, aligned_space);
      }
    }

    /* leaf SAH is the lowest => create leaf. */
    minSAH = min(min(leafSAH, object.sah), spatial.sah);
    no_split = (minSAH == leafSAH && builder->range_within_max_leaf_size(range, references));
  }

  __forceinline void split(BVHBuild *builder,
                           BVHRange &left,
                           BVHRange &right,
                           const BVHRange &range)
  {
    if (builder->params.use_spatial_split && minSAH == spatial.sah)
      spatial.split(builder, left, right, range);
    if (!left.size() || !right.size())
      object.split(left, right, range);
  }
};

CCL_NAMESPACE_END

#endif /* __BVH_SPLIT_H__ */